cwn0812

[置顶] cocos2dx 自定义进度条的实现！

//好久没写博客，本人比较懒，而且没啥技术，所以。。。

进度条，2dx源码的ProgressTimer只有条形进度条和弧形进度条！那么请问，以下

这种图片的进度条要怎么做呢！然后有人会说，用弧形进度条，进度条的中心点事图片的中心点，那样你会发现在一些地方会出现斜边，并且图片长宽不等的情况下，速度不一样！

那现在问题来了，要怎么解决呢？我们先看源码！

ProgressTimer的核心函数draw()（它又调用ondraw方法），所以！

void ProgressTimer::onDraw(const Mat4 &transform, uint32_t flags)
{

    getGLProgram()->use();
    getGLProgram()->setUniformsForBuiltins(transform);

    GL::blendFunc( _sprite->getBlendFunc().src, _sprite->getBlendFunc().dst );

    GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX );

    GL::bindTexture2D( _sprite->getTexture()->getName() );

    glVertexAttribPointer( GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(_vertexData[0]) , &_vertexData[0].vertices);
    glVertexAttribPointer( GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(_vertexData[0]), &_vertexData[0].texCoords);
    glVertexAttribPointer( GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(_vertexData[0]), &_vertexData[0].colors);

    if(_type == Type::RADIAL)
    {
        glDrawArrays(GL_TRIANGLE_FAN, 0, _vertexDataCount);
        CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_vertexDataCount);
    }
    else if (_type == Type::BAR)
    {
        if (!_reverseDirection) 
        {
            glDrawArrays(GL_TRIANGLE_STRIP, 0, _vertexDataCount);
            CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_vertexDataCount);
        }
        else 
        {
            glDrawArrays(GL_TRIANGLE_STRIP, 0, _vertexDataCount/2);
            glDrawArrays(GL_TRIANGLE_STRIP, 4, _vertexDataCount/2);
            // 2 draw calls
            CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(2,_vertexDataCount);
        }
    }
}

其中_vertexData是一些当前位置的的数组，_vertexDataCount这个数组的大小。

主要看下这个函数glDrawArrays(GL_TRIANGLE_FAN, 0, _vertexDataCount)的GL_TRIANGLE_FAN，可以看以下链接

点击打开链接

就拿GL_TRIANGLE_STRIP来说

		if (!_vertexData) {
			_vertexDataCount = 4;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(1, 0));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(1, 0));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(0, 0));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(0, 0));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(1, 1));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(1, 1));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(0, 1));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(0, 1));

然后在onDraw()方法的相应位置：

	glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(_vertexData[0]), &_vertexData[0].vertices);
	glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(_vertexData[0]), &_vertexData[0].texCoords);
	glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(_vertexData[0]), &_vertexData[0].colors);
	glDrawArrays(GL_TRIANGLE_STRIP, 0, _vertexDataCount);
	CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _vertexDataCount);

就可以画出整张图片（说实在的，opengl我也不懂，只能看源码依葫芦画瓢抄出来！）
现在看我重写的类： MyProgressTimer

MyProgressTimer.h:

#pragma once
#include "cocos2d.h"

#define  kMyProgressTextureCoordsCount 4
const char kMyProgressTextureCoords = 0x4b;
USING_NS_CC;

class MyProgressFromTo : public ActionInterval
{

public:
	static MyProgressFromTo* create(float duration, float fromPercentage, float toPercentage);

	virtual MyProgressFromTo* clone() const override;
	virtual MyProgressFromTo* reverse() const override;
	virtual void startWithTarget(Node *target) override;
	virtual void update(float time) override;

CC_CONSTRUCTOR_ACCESS:
	MyProgressFromTo() {}
	virtual ~MyProgressFromTo() {}

	bool initWithDuration(float duration, float fromPercentage, float toPercentage);

protected:
	float _to;
	float _from;

private:
	CC_DISALLOW_COPY_AND_ASSIGN(MyProgressFromTo);
};

class MyProgressTimer : public cocos2d::Node
{
public:
	MyProgressTimer(){ m_pSpr = nullptr; _vertexData = nullptr; _vertexDataCount = 0; m_fPercentage = 0.0f; };
	~MyProgressTimer(){
		if (m_pSpr)
		{
			CC_SAFE_RELEASE(m_pSpr);
		}
		if (_vertexData)
		{
			CC_SAFE_FREE(_vertexData);
		}
	};

	enum class ProgressType
	{
		None,
		Start,
		Step1,
		Circle1_1,
		Circle1_2,
		Step2,
		Circle2_1,
		Circle2_2,
		Step3,
		Circle3_1,
		Circle3_2,
		Step4,
		Circle4_1,
		Circle4_2,
		Step5,
		End
	};

	static MyProgressTimer* create(Sprite* sp);

	bool initWithSprite(Sprite* sp);

	void onDraw(const Mat4 &transform, uint32_t flags);
	
	void setSprite(Sprite *sprite);

	void draw(Renderer *renderer, const Mat4& transform, uint32_t flags);

	virtual void updateColor(void) override;

	void updateProgress(void);

	Vec2 boundaryTexCoord(char index);

	Tex2F textureCoordFromAlphaPoint(Vec2 alpha);
	Vec2 vertexFromAlphaPoint(Vec2 alpha);

	void setPercentage(float percentage);

	void setOrigin(Vec2 _vOrigin);
	void setTop(Vec2 _vTop);

	float getPercentage(){ return m_fPercentage; };

	ProgressType percentToStep(float &_pos);

	float m_fPercentage;

	CustomCommand _customCommand;

	Sprite* m_pSpr;

	int _vertexDataCount;
	V2F_C4B_T2F *_vertexData;

	ProgressType m_type;

	Vec2 m_vOrigin;
	Vec2 m_vTop;
};

MyProgressTimer.cpp

#pragma once
#include "MyProgressTimer.h"

USING_NS_CC;

MyProgressTimer* MyProgressTimer::create(Sprite* sp)
{
	MyProgressTimer *progressTimer = new (std::nothrow) MyProgressTimer();
	if (progressTimer->initWithSprite(sp))
	{
		progressTimer->autorelease();
	}
	else
	{
		delete progressTimer;
		progressTimer = nullptr;
	}

	return progressTimer;
}

bool MyProgressTimer::initWithSprite(Sprite* sp)
{
	setSprite(sp);

	setOrigin(Vec2(0.05f, 0.05f));
	setTop(Vec2(0.95f, 0.95f));

	setAnchorPoint(Vec2(0.5f,0.5f));

	setGLProgramState(GLProgramState::getOrCreateWithGLProgramName(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR));

	m_type = ProgressType::None;

	setPercentage(0.0f);

	ProgressFromTo;

	return true;
}

void MyProgressTimer::onDraw(const Mat4 &transform, uint32_t flags)
{
	getGLProgram()->use();
	getGLProgram()->setUniformsForBuiltins(transform);

	GL::blendFunc(m_pSpr->getBlendFunc().src, m_pSpr->getBlendFunc().dst);

	GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX);

	GL::bindTexture2D(m_pSpr->getTexture()->getName());

	glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(_vertexData[0]), &_vertexData[0].vertices);
	glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(_vertexData[0]), &_vertexData[0].texCoords);
	glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(_vertexData[0]), &_vertexData[0].colors);
	glDrawArrays(GL_TRIANGLE_STRIP, 0, _vertexDataCount);
	CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _vertexDataCount);
}

void MyProgressTimer::draw(Renderer *renderer, const Mat4& transform, uint32_t flags)
{
	if (!_vertexData || !m_pSpr)
		return;

	_customCommand.init(_globalZOrder);
	_customCommand.func = CC_CALLBACK_0(MyProgressTimer::onDraw, this, transform, flags);
	renderer->addCommand(&_customCommand);
}

void MyProgressTimer::setSprite(Sprite *sprite)
{
	if (m_pSpr != sprite)
	{
		CC_SAFE_RETAIN(sprite);
		CC_SAFE_RELEASE(m_pSpr);
		m_pSpr = sprite;
		setContentSize(m_pSpr->getContentSize());

		if (_vertexData)
		{
			CC_SAFE_FREE(_vertexData);
			_vertexDataCount = 0;
		}
	}
}

void MyProgressTimer::updateColor(void)
{
	if (!m_pSpr) {
		return;
	}

	if (_vertexData)
	{
		Color4B sc = m_pSpr->getQuad().tl.colors;
		for (int i = 0; i < _vertexDataCount; ++i)
		{
			_vertexData[i].colors = sc;
		}
	}
}

cocos2d::Tex2F MyProgressTimer::textureCoordFromAlphaPoint(Vec2 alpha)
{
	Tex2F ret(0.0f, 0.0f);
	if (!m_pSpr) {
		return ret;
	}
	V3F_C4B_T2F_Quad quad = m_pSpr->getQuad();
	Vec2 min = Vec2(quad.bl.texCoords.u, quad.bl.texCoords.v);
	Vec2 max = Vec2(quad.tr.texCoords.u, quad.tr.texCoords.v);
	//  Fix bug #1303 so that progress timer handles sprite frame texture rotation
	if (m_pSpr->isTextureRectRotated()) {
		CC_SWAP(alpha.x, alpha.y, float);
	}
	return Tex2F(min.x * (1.f - alpha.x) + max.x * alpha.x, min.y * (1.f - alpha.y) + max.y * alpha.y);
}

cocos2d::Vec2 MyProgressTimer::vertexFromAlphaPoint(Vec2 alpha)
{
	Vec2 ret(0.0f, 0.0f);
	if (!m_pSpr) {
		return ret;
	}
	V3F_C4B_T2F_Quad quad = m_pSpr->getQuad();
	Vec2 min = Vec2(quad.bl.vertices.x, quad.bl.vertices.y);
	Vec2 max = Vec2(quad.tr.vertices.x, quad.tr.vertices.y);
	ret.x = min.x * (1.f - alpha.x) + max.x * alpha.x;
	ret.y = min.y * (1.f - alpha.y) + max.y * alpha.y;
	return ret;
}

Vec2 MyProgressTimer::boundaryTexCoord(char index)
{
	if (index < kMyProgressTextureCoordsCount) {
		if (true) {
			return Vec2((kMyProgressTextureCoords >> (7 - (index << 1))) & 1, (kMyProgressTextureCoords >> (7 - ((index << 1) + 1))) & 1);
		}
		else {
			return Vec2((kMyProgressTextureCoords >> ((index << 1) + 1)) & 1, (kMyProgressTextureCoords >> (index << 1)) & 1);
		}
	}
	return Vec2::ZERO;
}

void MyProgressTimer::setPercentage(float percentage)
{
	m_fPercentage = clampf(percentage, 0, 100);
	updateProgress();
}

void MyProgressTimer::updateProgress(void)
{
	if (!m_pSpr) {
		return;
	}

	Vec2 min = Vec2(0, 0);
	Vec2 max = Vec2(1, 1);
	Vec2 mid = Vec2(.5, .5);

	float pos = 0.0f;
	auto step = percentToStep(pos);
	if (ProgressType::Start == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, min.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(min.x, min.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, min.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(max.x, min.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		for (int i = 3; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, max.y));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(max.x, max.y));
		}
	}
	else if (ProgressType::Step1 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));

		_vertexData[4].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, min.y));
		_vertexData[4].vertices = vertexFromAlphaPoint(Vec2(min.x, min.y));

		_vertexData[5].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));
		_vertexData[5].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));

		_vertexData[6].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, min.y));
		_vertexData[6].vertices = vertexFromAlphaPoint(Vec2(max.x, min.y));

		_vertexData[7].texCoords = textureCoordFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));
		_vertexData[7].vertices = vertexFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));

		_vertexData[8].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, max.y));
		_vertexData[8].vertices = vertexFromAlphaPoint(Vec2(max.x, max.y));

		_vertexData[9].texCoords = textureCoordFromAlphaPoint(Vec2(m_vTop.x, m_vTop.y));
		_vertexData[9].vertices = vertexFromAlphaPoint(Vec2(m_vTop.x, m_vTop.y));

		_vertexData[10].texCoords = textureCoordFromAlphaPoint(Vec2(pos, max.y));
		_vertexData[10].vertices = vertexFromAlphaPoint(Vec2(pos, max.y));

		_vertexData[11].texCoords = textureCoordFromAlphaPoint(Vec2(pos, m_vTop.y));
		_vertexData[11].vertices = vertexFromAlphaPoint(Vec2(pos, m_vTop.y));

	}
	else if (ProgressType::Circle1_1 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));

		_vertexData[4].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, min.y));
		_vertexData[4].vertices = vertexFromAlphaPoint(Vec2(min.x, min.y));

		_vertexData[5].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));
		_vertexData[5].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));

		_vertexData[6].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, min.y));
		_vertexData[6].vertices = vertexFromAlphaPoint(Vec2(max.x, min.y));

		_vertexData[7].texCoords = textureCoordFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));
		_vertexData[7].vertices = vertexFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));

		_vertexData[8].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, max.y));
		_vertexData[8].vertices = vertexFromAlphaPoint(Vec2(max.x, max.y));

		_vertexData[9].texCoords = textureCoordFromAlphaPoint(Vec2(m_vTop.x, m_vTop.y));
		_vertexData[9].vertices = vertexFromAlphaPoint(Vec2(m_vTop.x, m_vTop.y));

		for (int i = 10; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(pos, max.y));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(pos, max.y));
		}
	}
	else if (ProgressType::Circle1_2 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));

		_vertexData[4].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, min.y));
		_vertexData[4].vertices = vertexFromAlphaPoint(Vec2(min.x, min.y));

		_vertexData[5].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));
		_vertexData[5].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));

		_vertexData[6].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, min.y));
		_vertexData[6].vertices = vertexFromAlphaPoint(Vec2(max.x, min.y));

		_vertexData[7].texCoords = textureCoordFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));
		_vertexData[7].vertices = vertexFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));

		_vertexData[8].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, pos));
		_vertexData[8].vertices = vertexFromAlphaPoint(Vec2(max.x, pos));

		for (int i = 9; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(m_vTop.x, m_vTop.y));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(m_vTop.x, m_vTop.y));
		}
	}
	else if (ProgressType::Step2 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));

		_vertexData[4].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, min.y));
		_vertexData[4].vertices = vertexFromAlphaPoint(Vec2(min.x, min.y));

		_vertexData[5].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));
		_vertexData[5].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));

		_vertexData[6].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, min.y));
		_vertexData[6].vertices = vertexFromAlphaPoint(Vec2(max.x, min.y));

		_vertexData[7].texCoords = textureCoordFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));
		_vertexData[7].vertices = vertexFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));

		_vertexData[8].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, pos));
		_vertexData[8].vertices = vertexFromAlphaPoint(Vec2(max.x, pos));

		for (int i = 9; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(m_vTop.x, pos));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(m_vTop.x, pos));
		}
	}
	else if (ProgressType::Circle2_1 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));

		_vertexData[4].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, min.y));
		_vertexData[4].vertices = vertexFromAlphaPoint(Vec2(min.x, min.y));

		_vertexData[5].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));
		_vertexData[5].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));

		_vertexData[6].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, min.y));
		_vertexData[6].vertices = vertexFromAlphaPoint(Vec2(max.x, min.y));

		_vertexData[7].texCoords = textureCoordFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));
		_vertexData[7].vertices = vertexFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));

		for (int i = 8; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(max.x, pos));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(max.x, pos));
		}
	}
	else if (ProgressType::Circle2_2 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));

		_vertexData[4].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, min.y));
		_vertexData[4].vertices = vertexFromAlphaPoint(Vec2(min.x, min.y));

		_vertexData[5].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));
		_vertexData[5].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));

		_vertexData[6].texCoords = textureCoordFromAlphaPoint(Vec2(pos, min.y));
		_vertexData[6].vertices = vertexFromAlphaPoint(Vec2(pos, min.y));

		for (int i = 7; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(m_vTop.x, m_vOrigin.y));
		}
	}
	else if (ProgressType::Step3 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));

		_vertexData[4].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, min.y));
		_vertexData[4].vertices = vertexFromAlphaPoint(Vec2(min.x, min.y));

		_vertexData[5].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));
		_vertexData[5].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));

		_vertexData[6].texCoords = textureCoordFromAlphaPoint(Vec2(pos, min.y));
		_vertexData[6].vertices = vertexFromAlphaPoint(Vec2(pos, min.y));

		for (int i = 7; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(pos, m_vOrigin.y));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(pos, m_vOrigin.y));
		}
	}
	else if (ProgressType::Circle3_1 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));

		_vertexData[4].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, min.y));
		_vertexData[4].vertices = vertexFromAlphaPoint(Vec2(min.x, min.y));

		_vertexData[5].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));
		_vertexData[5].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));

		for (int i = 6; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(pos, min.y));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(pos, min.y));
		}
	}
	else if (ProgressType::Circle3_2 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));

		_vertexData[4].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, pos));
		_vertexData[4].vertices = vertexFromAlphaPoint(Vec2(min.x, pos));

		for (int i = 5; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vOrigin.y));
		}
	}
	else if (ProgressType::Step4 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));

		_vertexData[4].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, pos));
		_vertexData[4].vertices = vertexFromAlphaPoint(Vec2(min.x, pos));

		for (int i = 5; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, pos));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, pos));
		}
	}
	else if (ProgressType::Circle4_1 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(min.x, max.y));

		_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		_vertexData[3].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));

		for (int i = 4; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, pos));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(min.x, pos));
		}
	}
	else if (ProgressType::Circle4_2 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(pos, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(pos, max.y));

		for (int i = 3; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(m_vOrigin.x, m_vTop.y));
		}
	}
	else if (ProgressType::Step5 == step)
	{
		if (!_vertexData) {
			_vertexDataCount = 12;
			_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
			CCASSERT(_vertexData, "CCProgressTimer. Not enough memory");
		}

		_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, max.y));
		_vertexData[0].vertices = vertexFromAlphaPoint(Vec2(mid.x, max.y));

		_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vec2(mid.x, m_vTop.y));
		_vertexData[1].vertices = vertexFromAlphaPoint(Vec2(mid.x, m_vTop.y));

		_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vec2(pos, max.y));
		_vertexData[2].vertices = vertexFromAlphaPoint(Vec2(pos, max.y));

		for (int i = 3; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(pos, m_vTop.y));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(pos, m_vTop.y));
		}
	}
	else if (ProgressType::End == step)
	{
		for (int i = 0; i < _vertexDataCount; i++)
		{
			_vertexData[i].texCoords = textureCoordFromAlphaPoint(Vec2(min.x, min.y));
			_vertexData[i].vertices = vertexFromAlphaPoint(Vec2(min.x, min.y));
		}
	}
}

void MyProgressTimer::setOrigin(Vec2 _vOrigin)
{
	if (m_pSpr)
	{
		float topX = clampf(_vOrigin.x, 0, 0.5);
		float topY = clampf(_vOrigin.y, 0, 0.5);

		auto thisSize = m_pSpr->getContentSize();
		auto max1 = thisSize.width * topX;
		auto max2 = thisSize.height * topY;
		auto max3 = MAX(max1, max2);
		m_vOrigin = Vec2(max3 / thisSize.width, max3 / thisSize.height);

		updateProgress();
	}
}

void MyProgressTimer::setTop(Vec2 _vTop)
{
	if (m_pSpr)
	{
		float topX = clampf(_vTop.x, 0.5, 1);
		float topY = clampf(_vTop.y, 0.5, 1);

		auto thisSize = m_pSpr->getContentSize();
		auto max1 = thisSize.width * (1-topX);
		auto max2 = thisSize.height * (1-topY);
		auto max3 = MAX(max1, max2);
		m_vTop = Vec2(1- max3 / thisSize.width, 1 - max3 / thisSize.height);

		updateProgress();
	}

}

MyProgressTimer::ProgressType MyProgressTimer::percentToStep(float &_pos)
{
	if (m_fPercentage == 0)
	{
		return ProgressType::Start;
	}
	else if (m_fPercentage == 100)
	{
		return ProgressType::End;
	}
	else if (m_fPercentage > 0 && m_fPercentage < 100)
	{
		auto thisSize = this->getContentSize();
		auto topR1 = thisSize.width * (1 - m_vTop.x);
		auto topR2 = thisSize.height * (1 - m_vTop.y);
		auto originR1 = thisSize.width * m_vOrigin.x;
		auto originR2 = thisSize.height * m_vOrigin.y;

		auto pi = 3.1415926f;

		float posNode[13] = {
			thisSize.width / 2 - topR1,
			thisSize.width / 2 - topR1 + pi*topR2 / 4,
			thisSize.width / 2 - topR1 + pi*topR1 / 4 + pi*topR2 / 4,
			thisSize.width / 2 - topR1 + pi*topR1 / 4 + pi*topR2 / 4 + thisSize.height - topR2 - originR2,
			thisSize.width / 2 - topR1 + pi*topR1 / 4 + pi*topR2 / 4 + thisSize.height - topR2 - originR2 + pi*topR1 / 4,
			thisSize.width / 2 - topR1 + pi*topR1 / 4 + pi*topR2 / 4 + thisSize.height - topR2 - originR2 + pi*topR1 / 4 + pi*originR2 / 4,
			thisSize.width / 2 - topR1 + pi*topR1 / 4 + pi*topR2 / 4 + thisSize.height - topR2 - originR2 + pi*topR1 / 4 + pi*originR2 / 4 + thisSize.width - originR1 - topR1,
			thisSize.width / 2 - topR1 + pi*topR1 / 4 + pi*topR2 / 4 + thisSize.height - topR2 - originR2 + pi*topR1 / 4 + pi*originR2 / 4 + thisSize.width - originR1 - topR1 + pi*originR2 / 4,
			thisSize.width / 2 - topR1 + pi*topR1 / 4 + pi*topR2 / 4 + thisSize.height - topR2 - originR2 + pi*topR1 / 4 + pi*originR2 / 4 + thisSize.width - originR1 - topR1 + pi*originR2 / 4 + pi*originR1 / 4,
			thisSize.width / 2 - topR1 + pi*topR1 / 4 + pi*topR2 / 4 + thisSize.height - topR2 - originR2 + pi*topR1 / 4 + pi*originR2 / 4 + thisSize.width - originR1 - topR1 + pi*originR2 / 4 + pi*originR1 / 4 + thisSize.height - originR2 - topR2,
			thisSize.width / 2 - topR1 + pi*topR1 / 4 + pi*topR2 / 4 + thisSize.height - topR2 - originR2 + pi*topR1 / 4 + pi*originR2 / 4 + thisSize.width - originR1 - topR1 + pi*originR2 / 4 + pi*originR1 / 4 + thisSize.height - originR2 - topR2 + pi*originR1 / 4,
			thisSize.width / 2 - topR1 + pi*topR1 / 4 + pi*topR2 / 4 + thisSize.height - topR2 - originR2 + pi*topR1 / 4 + pi*originR2 / 4 + thisSize.width - originR1 - topR1 + pi*originR2 / 4 + pi*originR1 / 4 + thisSize.height - originR2 - topR2 + pi*originR1 / 4 + pi*topR2 / 4,
			thisSize.width / 2 - topR1 + pi*topR1 / 4 + pi*topR2 / 4 + thisSize.height - topR2 - originR2 + pi*topR1 / 4 + pi*originR2 / 4 + thisSize.width - originR1 - topR1 + pi*originR2 / 4 + pi*originR1 / 4 + thisSize.height - originR2 - topR2 + pi*originR1 / 4 + pi*topR2 / 4 + thisSize.width / 2 - originR1
		};

		auto allLength = posNode[12];

		auto nowPosLength = allLength*m_fPercentage / 100;

		if (nowPosLength <= posNode[0])
		{
			_pos = (nowPosLength + thisSize.width / 2) / thisSize.width;

			if (_pos == 0.5f)
				return ProgressType::Start;
			return ProgressType::Step1;
		}
		else if (nowPosLength <= posNode[1])
		{
			auto huchang = nowPosLength - posNode[0];
			auto angle = huchang / topR2;
			_pos = (topR2 * tanf(angle) + thisSize.width - topR1) / thisSize.width;

			return ProgressType::Circle1_1;
		}
		else if (nowPosLength <= posNode[2])
		{
			auto huchang = pi*topR1 / 4 - (nowPosLength - posNode[1]);
			auto angle = huchang / topR1;
			_pos = (topR1 * tanf(angle) + thisSize.height - topR2) / thisSize.height;

			return ProgressType::Circle1_2;
		}
		else if (nowPosLength <= posNode[3])
		{
			_pos = 1 - (nowPosLength - posNode[2] + topR2) / thisSize.height;

			return ProgressType::Step2;
		}
		else if (nowPosLength <= posNode[4])
		{
			auto huchang = nowPosLength - posNode[3];
			auto angle = huchang / topR1;
			_pos = (originR2 - tanf(angle) * topR1) / thisSize.height;

			return ProgressType::Circle2_1;
		}
		else if (nowPosLength <= posNode[5])
		{
			auto huchang = pi*originR2 / 4 - (nowPosLength - posNode[4]);
			auto angle = huchang / originR2;
			_pos = (tanf(angle) * originR2 + thisSize.width - topR1) / thisSize.width;

			return ProgressType::Circle2_2;
		}
		else if (nowPosLength <= posNode[6])
		{
			auto nowPos = nowPosLength - posNode[5] + topR1;
			_pos = 1.0f - nowPos / thisSize.width;

			return ProgressType::Step3;
		}
		else if (nowPosLength < posNode[7])
		{
			auto huchang = nowPosLength - posNode[6];
			auto angle = huchang / originR2;
			_pos = (originR1 - tanf(angle) * originR2) / thisSize.width;

			return ProgressType::Circle3_1;
		}
		else if (nowPosLength < posNode[8])
		{
			auto huchang = pi*originR1 / 4 - (nowPosLength - posNode[7]);
			auto angle = huchang / originR1;
			_pos = (originR2 - tanf(angle) * originR2) / thisSize.height;

			return ProgressType::Circle3_2;
		}
		else if (nowPosLength < posNode[9])
		{
			auto huchang = nowPosLength - posNode[8] + originR2;
			_pos = huchang / thisSize.height;

			return ProgressType::Step4;
		}
		else if (nowPosLength < posNode[10])
		{
			auto huchang = (nowPosLength - posNode[9]);
			auto angle = huchang / originR1;
			_pos = (tanf(angle) * originR1 + thisSize.height - topR2) / thisSize.height;

			return ProgressType::Circle4_1;
		}
		else if (nowPosLength < posNode[11])
		{
			auto huchang = pi*topR2 / 4 - (nowPosLength - posNode[10]);
			auto angle = huchang / topR2;
			_pos = (originR1 - tanf(angle) * topR2) / thisSize.width;

			return ProgressType::Circle4_2;
		}
		else if (nowPosLength < posNode[12])
		{
			auto huchang = nowPosLength - posNode[11] + originR1;
			_pos = huchang / thisSize.width;

			return ProgressType::Step5;
		}
		return ProgressType::End;
	}

	return ProgressType::None;
}

MyProgressFromTo* MyProgressFromTo::create(float duration, float fromPercentage, float toPercentage)
{
	MyProgressFromTo *progressFromTo = new (std::nothrow) MyProgressFromTo();
	progressFromTo->initWithDuration(duration, fromPercentage, toPercentage);
	progressFromTo->autorelease();

	return progressFromTo;
}

MyProgressFromTo* MyProgressFromTo::clone() const
{
	auto a = new (std::nothrow) MyProgressFromTo();
	a->initWithDuration(_duration, _from, _to);
	a->autorelease();
	return a;
}

MyProgressFromTo* MyProgressFromTo::reverse() const
{
	return MyProgressFromTo::create(_duration, _to, _from);
}

void MyProgressFromTo::startWithTarget(Node *target)
{
	ActionInterval::startWithTarget(target);
}

void MyProgressFromTo::update(float time)
{
	((MyProgressTimer*)(_target))->setPercentage(_from + (_to - _from) * time);
}

bool MyProgressFromTo::initWithDuration(float duration, float fromPercentage, float toPercentage)
{
	if (ActionInterval::initWithDuration(duration))
	{
		_to = toPercentage;
		_from = fromPercentage;

		return true;
	}

	return false;
}

其中这个函数percentToStep（），这个算法我写吐了！不知道你们看的懂不！

原理：就是我把整个图片分成9个部分，两个竖边，一个下边，一个左上边和右上边还有四个弧度。

分割则是靠两个红点（代码中的m_vOrigin，m_vTop）这样就显示黑色区域！！！

调用方法：

	MyProgressTimer* progressTimer = MyProgressTimer::create(Sprite::create("thinking_border.png"));
	progressTimer->setPosition(Vec2(winSize.width / 2-100, winSize.height*0.5));
	this->addChild(progressTimer);
	progressTimer->setOrigin(Vec2(0.08, 0.08));
	progressTimer->setTop(Vec2(0.92, 0.92));

	progressTimer->stopAllActions();
	progressTimer->runAction(Sequence::create(
		MyProgressFromTo::create(15.0f, 0, 100),
		CallFunc::create([&](){
		CCLOG("CallFunc: end!");
	}),
		nullptr));

以上版本是cocos2dx3.2版本的，代码直接复制黏贴即可！之前我给一个朋友弄个2.2.1版本的，以下是2dx-2.2.1版本的下载链接：

点击打开链接

写的有点复杂，大家可以自己去看看，可能你会发现更好的解决方式，到时候告诉我哦！
你的支持是我学习的动力！！！

等过一阵子，我会写老虎机的实现方式！！！预告一下！

你可能感兴趣的:(cocos2d-x)

c/c++导出lua绑定 ajt1472580369 lua c/c++python
【转载】https://note.youdao.com/share/?id=0f4132271151c4b62f9afb712e8304d9&type=note#/1、在纯C环境下，把C函数注册进Lua环境，理解Lua和C之间可以互相调用的本质2、在cocos2d-x项目里，把纯C函数注册进Lua环境，理解cocos2d-x是怎样创建Lua环境的、以及怎样得到这个环境并继续自定义它3、了解为什么要
[源码和文档分享]基于VS2012和Cocos2d-x实现的StickToLast益智小游戏 ggdd5151
第1章问题陈述1.1项目背景手机用户在休闲时倾向于玩一些类似于FlappyBird、2048等游戏，这类游戏用户界面简单，游戏模式单一，单手即可操作，随着游戏地进行，游戏的难度会增加。随着手机用户地爆发式增长，这类游戏的需求量愈发庞大。StickToLast是一款益智类游戏。主角陷于宇宙漩涡之中，被吸入中央的黑洞或者逃离该区域都无法被即将来到的救援部队拯救，只能停留在这一区域，躲避宇宙陨石，坚持的
【Cocos2d-x】开发基础-第一个Cocos2d-x游戏 weixin_34239169 游戏 python 移动开发
本篇博客讲解:1.第一个Cocos2d-x游戏第一个Cocos2d-x游戏创建工程cocos工具：就是这个，看图命令工具cocos实现，cocos工具其实是cocos2d团队自己开发的。是使用Python脚本编写的，cocos工具的运行需要安装Python环境(还会用到ant,eclipse等工具哦，后面介绍)Python下载地址https://www.python.org/需要注意的是它目前有P
cocos2d-x 4.0 安装教程（Windows + VS） + cocosui入门知识储备 Gosick_Geass_Gate 编程语言 cocos2d
（一）前期准备Windows10操作系统VS2019或VS2017Python2.7.18：记得勾选将python添加到环境变量的复选框，不然自己手动添加也行。CMake3.19.0：记得勾选将cmake添加到环境变量的复选框，不然自己手动添加也行。cocos2d-x4.0：手动将cocos2d-x-4.0\tools\cocos2d-console\bin目录添加到环境变量。以上全都下载最新版本
使用cocos2d-x的console实现远程调试 CHEN_玦儿 Cocos2d-x
使用Lua开发有一个很爽的地方就是可以从控制台实时输入Lua指令来进行调试，但是之前该方法仅在windows下有效，之前也介绍过，见这里。研究了下发现cocos2d-x是有一个console类来支持远程调试的，哈哈，从此真机调试也可以很方便了。这里先介绍下console的关键API先：listenOnTCP(number)这里参数是监听的端口号addCommand(tb,funciton)这里第一
使用cocos2d-console初始化一个项目 sun_weitao cocos2d 游戏引擎
先下载好cocos2d-x的源码包地址https://www.cocos.com/cocos2dx-download这里使用的版本是自己的电脑要先装好python27用python安装cocos2d-console看到项目中有个setup.py的一个文件pythonsetup.py用上面的命令执行一下。如果执行正常的话回出现上面的图然后source一下source/Users/sun-weitao
【玩转cocos2d-x之三十六】Flappy Bird大集结偶尔e网事 cocos2d-x cocos2d-x Flappy Bird 各版本
前几天看到cocos2d-x官网论坛让各种姿势的flappybird霸占了，矮油真受不鸟，你们够啦！！！今天准备用一个贴来秒杀你们。准备好了么。。。放图镇楼：1.C++版先来个传统版，@OiteBoys童鞋很有爱，将flappybird用cocos2d-xv3.0写了一遍，同时加入了新的3.0物理系统。在这一系列教程中flappybird被大卸八块，剥骨抽筋（好残忍。。。），每一个模块精彩的图文代
Cocos Creator实现windows窗口全屏 wudics creaor 游戏全屏 cocos creator
发布CocosCreator来发布全屏的windows游戏客户端，默认是窗口模式的。要实现全屏需要改动CocosCreator提供的desktop端构建源码，要修改的文件为：#通过glfw创建全屏窗口C:\CocosCreator\resources\cocos2d-x\cocos\platform\desktop\CCGLView-desktop.cpp以及#通过传递尺寸参数修改视觉窗口，此文件
Cocos2d-x windows編譯出現GWL_WNDPROC、GWL_USERDATA未定义 ALoppd cocos2d windows 游戏引擎
錯誤復現：D:\Software\cocos2d-x\cocos\ui\UIEditBox\UIEditBoxImpl-win32.cpp(64,70):errorC2065:'GWL_WNDPROC':undeclaredidentifier[D:\Projects\CPP\CMake\cocos\Runner\fakebuild\engine\cocos\core\cocos2d.vcxpro
在Windows上搭建Cocos2d-x 3.0开发环境 __Ben__ Cocos2dx cocos2d-x windows visual studio
建议：为了避免安全相关的问题，请以管理员权限执行所有的操作，当运行命令的时候，也要确保之前是以管理员权限打开了命令行窗口.工具准备搭建开发环境需要安装工具包括VisualStudiopython———(本教程以python2.7.3版本为例），下载地址：http://www.python.org/download/releases/2.7.3/。Cocos2d-x———(本教程以cocos2d-x
windows下开发cocos2dx的环境搭建 ahaitongxue cocos2d
前面把VisualStudio+Python开发环境配好了，但还没有讲如何在Android中使用创建好的项目，本篇博客介绍如何在win7下进行Android与cocos2d-x的交叉编译，我的电脑是64位，所以下面的配置是基于x86_64下配置的。下载：CygwinCygwin的主要目的是通过重新编译，将POSIX系统（例如Linux、BSD，以及其他Unix系统）上的软件移植到Windows上。
Visual Studio 和Clion配置Cocos2d-x环境无相孤君 C/C++日常操作 Cocos2d-x visual studio cocos2d ide c++游戏引擎 c语言
VisualStudio和Clion配置Cocos2d-x环境我就不贴图片的，懒得上传图床。懒。开发环境:系统:Window11编译器:CMake+MSVC开发工具：ClionorVisualStudio请自行配置好，Python2.7，和CmakeCocos2d-x下载首先，我们需要去Github下载(cocos2d-x)的源码，由于源码过于庞大如果clone失败，请自行查找方法。随便找一个目录
cocos2dx-lua读取json文件亮亮同学
cocos2d-x技术群新群：117871561c++技术交流群：593010226localstr=cc.FileUtils:getInstance():getStringFromFile("xxxx.json")localok,datatable=pcall(function()returncjson.decode(str)end)iftrue==okandtype(datatable)=="
如何制作一个类似Tiny Wings的游戏 Cocos2d-x 2.1.4内含iOS版源代码杜甲同学 cocos2d-x cocos2d-x
在第一篇《如何使用CCRenderTexture创建动态纹理》基础上，增加创建动态山丘，原文《HowToCreateAGameLikeTinyWingswithCocos2D2.XPart1》，在这里继续以Cocos2d-x进行实现。有关源码、资源等在文章下面给出了地址。步骤如下：1.使用上一篇的工程；2.添加地形类Terrain，派生自CCNode类。文件Terrain.h代码如下：123456
如何制作一个简单的游戏 Cocos2d-x 2.1.2 杜甲同学 cocos2d-x cocos2d-x 移动开发 cocos2d 游戏
本文实践自RayWenderlich的文章《HowToMakeASimpleiPhoneGamewithCocos2D2.XTutorial》，文中使用Cocos2D，我在这里使用Cocos2D-x2.1.2进行学习和移植，前者是用Object-C所写，所以移植到Cocos2D-x会有些差异，比如某些函数、某些功能不能跟原文一样直接实现，需另转换方法实现。之前已经对Cocos2D-x的安装以及简单
Android——Cocosd2d-x手机游戏开发学习思路霸气的名字 Cocos2d-X游戏开发 Cocos2d-x Android开发手机游戏 android 游戏引擎
手机APP应用如雨后春笋般冒了出来，而在众多的APP应用中，游戏占据了半壁江山。它丰富着人们的业余生活，增进了人们之间的沟通交流。也有许多开发的朋友对游戏开发情有独钟，他们不止是享受着有很多的人们去下载的成就感，更多的是享受着自己开发出一款满意游戏的成就感。为此越来越多的开发者们向着游戏应用进军了。可是很多开发者不知道怎么入手游戏开发，不知道游戏开发的路应该怎么走。作为一个仅用Cocos2d-x游
在 Cocos Creator 中使用缓动系统（cc.tween） kzc爱吃梨
缓动系统（cc.tween）介绍CocosCreator在v2.0.9提供了一套新的API——cc.tween。cc.tween能够对对象的任意属性进行缓动，功能类似于cc.Action（动作系统）。但是cc.tween会比cc.Action更加简洁易用，因为cc.tween提供了链式创建的方法，可以对任何对象进行操作，并且可以对对象的任意属性进行缓动。动作系统是从Cocos2d-x迁移到Coco
解决Command CodeSign failed with a nonzero exit code 奔五码农
Cocos2d-x项目，报错CodeSign/Users/xxx/Library/Developer/Xcode/DerivedData/xxx-dabhdlnwdwoowjeiqavvwikjihix/Build/Products/Debug-iphonesimulator/xxx.app(intarget'xxx-mobile'fromproject'xxx')cd/Users/xxx/Doc
cocos2d-x lua 开发环境搭建（让lua具备代码提示等） WeiQ_ Cocos2d-x
2013年是手游开发井喷的一年，也是手游市场竞争最为激烈的一年，ios市场除了刷榜、刷榜，还是刷榜，而android有点像黑市的感觉，水太深（很多渠道商已经从上游控制了流量的入口）。而cocos2d-x作为国内手游2d游戏中最流行的引擎，也渐渐由c++开发转为lua，究其原因。最主要的是：通过lua写的游戏，可以实现动态更新(你知道苹果每次审核会让人疼蛋差不多一个礼拜或者更久)；在很大程度上也避免
Cocos2d-x Lua中的AssetsManagerEx JunChow520
Cocos2d-xLua中的热更机制主要是通过AssetsManagerEx来实现的。传统的热更方式传统PC的方式是将差异文件打包成一个压缩包，客户端根据大版本差异，将对应的压缩包下载到本地后解压覆盖。这种做法的好处在于下载一个文件会比较快。缺点在于当客户端版本比较多的时候，升级压缩包会变得很多，进而难以维护。其次是如果压缩包体积过大，解压时间会比较长，而且不容易制作进度条，导致程序感觉被卡住了。
Sonic云真机直接获取POCO控件实战 ZhouYixun
前言Sonic官网用户交流社区效果展示image.pngimage.pngimage.pngimage.png目前已支持POCO-SDK的所有游戏引擎（Unity3d、Cocos2dx系列、白鹭、UE4），使用前需游戏已接入SDK。v1.4.0-beta更新后就可以使用啦~（预计五一后更新）什么是POCOPoco是一个基于UI控件搜索的跨引擎自动化测试框架。支持主流游戏引擎：Cocos2d-x、U
Cocos2D-X 3.17.2 安装配置闲人狸猫 Cocos2d-x Cocos2d-x 配置 Android studio Cocos2d-x 3.17.2
网上关于cocos2d-x的安装教程有很多，但是都是旧版本的，我找了很多资料都无法创建proj.android-studio。后来发现是新版本的软件对安卓平台进行合并，只有proj.android文件，使用Androidstudio编写。一、安装准备：JDK–->>JavaSEDevelopmentKit8u202Androidstudio-->>android-studio-ide-183.56
html gui的源码,FairyGUI是一款专业的 UI编辑器我有多作怪 html gui的源码
FairyGUIUI编辑器操作简单，使用习惯与Adobe系列软件保持一致，美术设计师可以轻松上手。FairyGUI是一个跨平台的UI解决方案，它提供了一个可以在Windows和Mac上使用的编辑器和可以在多个游戏引擎中使用的SDK(Unity、Flash、Starling、白鹭、LayaAir等，未来还将支持cocos2d-x、UE4、libgdx等)。借助FairyGUI提供的组件、关联、控制器
cocos2d-lua游戏解决方案无脑_码农 cocos2d-lua
cocos2d-lua引擎版本cocos2d-x官方版:https://www.cocos.com/cocos2dxQuick-Cocos2dx-Community:http://www.cocos2d-lua.org/Cocos-lua(重写tolua值得借鉴):https://github.com/zhongfq/cocos-luaUI编辑器FairyGUI：https://www.fairy
cocos2d-x lua ProgressTimer 蚂蚁呀嘿嘿嘿 cocos xcode ios android cocos2d lua
cocos2d-xluaProgressTimer下载进度条使用functiontest()locallayer=cc.Layer:create()localto1=cc.ProgressTo:create(2,100)localto2=cc.ProgressTo:create(2,100)localpath1="Jms_PetSystem/img/passMailIcon.png"--RADIA
cocos2d-x lua --递归遍历子节点并且变换颜色蚂蚁呀嘿嘿嘿 cocos cocos2d lua 游戏引擎
--递归遍历子节点并且变换颜色给节点置灰functionGD.util_nodeChangeColor(root,_color)if_color==nilthen_color=cc.c3b(192,192,192)endifnotrootthenreturnendroot:setColor(_color)localchild_list=root:getChildren()for_,nodeinpa
【四】CocosCreator-修改引擎源码 0zien0 cocoscreator 修改引擎修改引擎源码
看源码的过程中，少不了得修修改改源码，做点实验。果断去找找源码在哪里，然后就可以快乐动手改源码了。CocosCreator引擎源码主要就是js和原生C++两类，分别在引擎目录的resources/engine和resources/cocos2d-x下，如图：这次我们主要分析的是web平台相关的JS代码，主要的源码就在engine/cocos2d里面。PS：cocos2d-x的源码我以前也曾经简单看
Android 实现 Slots 游戏旋转效果 LMF· AndroidStudio android 游戏
文章目录前言一、效果展示二、代码实现1.UI布局2.SlotAdapter2.SlotsActivity总结前言slots游戏：Slots游戏是一种极具流行度的赌博和娱乐形式，通常被称为老虎机或水果机。它们在赌场、线上游戏平台和手机应用中广泛存在。一般这类游戏都使用Unity和Cocos2d-x两个常见的游戏引擎去开发的，下面介绍下Android原生代码实现Slots旋转动画。一、效果展示二、代码
Cocos2d-x 开发笔记 JunChow520
1.判断操作系统平台类型根据Cocos2d-x源码可以获得所支持的平台类型C++cocos2d\platform\CCPlatformConfig.h#ifndef__CC_PLATFORM_CONFIG_H_#define__CC_PLATFORM_CONFIG_H_/**Configofcocos2d-xprojectpertargetplatform*////////////////////
【教程】使用ipagurd打包与混淆Cocos2d-x的Lua脚本憧憬blog 代码混淆 ipa guard 加密工具 cocos2d lua 游戏引擎
文章目录摘要引言正文1.准备工作2.使用ipaguard处理Lua文件3.运行ipagurd进行混淆代码加密具体步骤测试和配置阶段IPA重签名操作步骤4.IPA重签名与发布总结摘要本文将介绍如何使用ipagurd工具对Cocos2d-x中的Lua脚本进行打包与混淆，以及在iOS应用开发中的实际应用。我们将以Cocos2d-x-2.2.1samples中的HelloLua为例，详细展示整个处理流程，
多线程编程之理财周凡杨 java 多线程生产者消费者理财
现实生活中，我们一边工作，一边消费，正常情况下会把多余的钱存起来，比如存到余额宝，还可以多挣点钱，现在就有这个情况：我每月可以发工资20000万元（暂定每月的1号），每月消费5000（租房+生活费）元（暂定每月的1号），其中租金是大头占90%，交房租的方式可以选择（一月一交，两月一交、三月一交），理财：1万元存余额宝一天可以赚1元钱，
[Zookeeper学习笔记之三]Zookeeper会话超时机制 bit1129 zookeeper
首先，会话超时是由Zookeeper服务端通知客户端会话已经超时，客户端不能自行决定会话已经超时，不过客户端可以通过调用Zookeeper.close()主动的发起会话结束请求，如下的代码输出内容 Created /zoo-739160015 CONNECTEDCONNECTED .............CONNECTEDCONNECTED CONNECTEDCLOSEDCLOSED
SecureCRT快捷键 daizj secureCRT 快捷键
ctrl + a : 移动光标到行首ctrl + e ：移动光标到行尾crtl + b: 光标前移1个字符crtl + f: 光标后移1个字符crtl + h : 删除光标之前的一个字符ctrl + d ：删除光标之后的一个字符crtl + k ：删除光标到行尾所有字符crtl + u : 删除光标至行首所有字符crtl + w: 删除光标至行首
Java 子类与父类这间的转换周凡杨 java 父类与子类的转换
最近同事调的一个服务报错，查看后是日期之间转换出的问题。代码里是把 java.sql.Date 类型的对象强制转换为 java.sql.Timestamp 类型的对象。报java.lang.ClassCastException。代码：
可视化swing界面编辑朱辉辉33 eclipse swing
今天发现了一个WindowBuilder插件，功能好强大，啊哈哈，从此告别手动编辑swing界面代码，直接像VB那样编辑界面，代码会自动生成。首先在Eclipse中点击help，选择Install New Software,然后在Work with中输入WindowBui
web报表工具FineReport常用函数的用法总结（文本函数）老A不折腾 finereport web报表工具报表软件 java报表
文本函数 CHAR CHAR(number):根据指定数字返回对应的字符。CHAR函数可将计算机其他类型的数字代码转换为字符。 Number:用于指定字符的数字，介于1Number:用于指定字符的数字，介于165535之间（包括1和65535）。示例: CHAR(88)等于“X”。 CHAR(45)等于“-”。 CODE CODE(text):计算文本串中第一个字
mysql安装出错林鹤霄 mysql安装
[root@localhost ~]# rpm -ivh MySQL-server-5.5.24-1.linux2.6.x86_64.rpm Preparing... #####################
linux下编译libuv aigo libuv
下载最新版本的libuv源码，解压后执行： ./autogen.sh 这时会提醒找不到automake命令，通过一下命令执行安装（redhat系用yum，Debian系用apt-get）： # yum -y install automake # yum -y install libtool 如果提示错误：make: *** No targe
中国行政区数据及三级联动菜单 alxw4616
近期做项目需要三级联动菜单,上网查了半天竟然没有发现一个能直接用的! 呵呵,都要自己填数据....我了个去这东西麻烦就麻烦的数据上. 哎,自己没办法动手写吧. 现将这些数据共享出了,以方便大家.嗯,代码也可以直接使用文件说明 lib\area.sql -- 县及县以上行政区划分代码（截止2013年8月31日)来源：国家统计局发布时间：2014-01-17 15:0
哈夫曼加密文件百合不是茶哈夫曼压缩哈夫曼加密二叉树
在上一篇介绍过哈夫曼编码的基础知识,下面就直接介绍使用哈夫曼编码怎么来做文件加密或者压缩与解压的软件,对于新手来是有点难度的,主要还是要理清楚步骤; 加密步骤: 1,统计文件中字节出现的次数,作为权值 2,创建节点和哈夫曼树 3,得到每个子节点01串 4,使用哈夫曼编码表示每个字节
JDK1.5 Cyclicbarrier实例 bijian1013 java thread java多线程 Cyclicbarrier
CyclicBarrier类一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。 CyclicBarrier支持一个可选的 Runnable 命令，
九项重要的职业规划 bijian1013 工作学习
一. 学习的步伐不停止古人说，活到老，学到老。终身学习应该是您的座右铭。世界在不断变化，每个人都在寻找各自的事业途径。您只有保证了足够的技能储
【Java范型四】范型方法 bit1129 java
范型参数不仅仅可以用于类型的声明上，例如 package com.tom.lang.generics; import java.util.List; public class Generics<T> { private T value; public Generics(T value) { this.value =
【Hadoop十三】HDFS Java API基本操作 bit1129 hadoop
package com.examples.hadoop; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FSDataInputStream; import org.apache.hadoop.fs.FileStatus; import org.apache.hadoo
ua实现split字符串分隔 ronin47 lua split
LUA并不象其它许多"大而全"的语言那样，包括很多功能，比如网络通讯、图形界面等。但是LUA可以很容易地被扩展：由宿主语言(通常是C或 C++)提供这些功能，LUA可以使用它们，就像是本来就内置的功能一样。LUA只包括一个精简的核心和最基本的库。这使得LUA体积小、启动速度快，从而适合嵌入在别的程序里。因此在lua中并没有其他语言那样多的系统函数。习惯了其他语言的字符串分割函
java-从先序遍历和中序遍历重建二叉树 bylijinnan java
public class BuildTreePreOrderInOrder { /** * Build Binary Tree from PreOrder and InOrder * _______7______ / \ __10__ ___2 / \ / 4
openfire开发指南《连接和登陆》开窍的石头 openfire 开发指南 smack
第一步官网下载smack.jar包下载地址：http://www.igniterealtime.org/downloads/index.jsp#smack 第二步把smack里边的jar导入你新建的java项目中开始编写smack连接openfire代码 p
[移动通讯]手机后盖应该按需要能够随时开启 comsci 移动
看到新的手机，很多由金属材质做的外壳，内存和闪存容量越来越大，CPU速度越来越快，对于这些改进，我们非常高兴，也非常欢迎但是，对于手机的新设计，有几点我们也要注意第一：手机的后盖应该能够被用户自行取下来，手机的电池的可更换性应该是必须保留的设计,
20款国外知名的php开源cms系统 cuiyadll cms
内容管理系统，简称CMS，是一种简易的发布和管理新闻的程序。用户可以在后端管理系统中发布，编辑和删除文章，即使您不需要懂得HTML和其他脚本语言，这就是CMS的优点。在这里我决定介绍20款目前国外市面上最流行的开源的PHP内容管理系统，以便没有PHP知识的读者也可以通过国外内容管理系统建立自己的网站。 1. Wordpress WordPress的是一个功能强大且易于使用的内容管
Java生成全局唯一标识符 darrenzhu java uuid unique identifier id
How to generate a globally unique identifier in Java http://stackoverflow.com/questions/21536572/generate-unique-id-in-java-to-label-groups-of-related-entries-in-a-log http://stackoverflow
php安装模块检测是否已安装过, 使用的SQL语句 dcj3sjt126com sql
SHOW [FULL] TABLES [FROM db_name] [LIKE 'pattern'] SHOW TABLES列举了给定数据库中的非TEMPORARY表。您也可以使用mysqlshow db_name命令得到此清单。本命令也列举数据库中的其它视图。支持FULL修改符，这样SHOW FULL TABLES就可以显示第二个输出列。对于一个表，第二列的值为BASE T
5天学会一种 web 开发框架 dcj3sjt126com Web 框架 framework
web framework层出不穷，特别是ruby/python,各有10+个,php/java也是一大堆根据我自己的经验写了一个to do list,按照这个清单，一条一条的学习，事半功倍，很快就能掌握一共25条，即便很磨蹭，2小时也能搞定一条，25*2=50。只需要50小时就能掌握任意一种web框架各类web框架大同小异:现代web开发框架的6大元素，把握主线，就不会迷路建议把本文
Gson使用三(Map集合的处理,一对多处理) eksliang json gson Gson map Gson 集合处理
转载请出自出处：http://eksliang.iteye.com/blog/2175532 一、概述 Map保存的是键值对的形式，Json的格式也是键值对的，所以正常情况下，map跟json之间的转换应当是理所当然的事情。二、Map参考实例 package com.ickes.json; import java.lang.refl
cordova实现“再点击一次退出”效果 gundumw100 android
基本的写法如下： document.addEventListener("deviceready", onDeviceReady, false); function onDeviceReady() { //navigator.splashscreen.hide(); document.addEventListener("b
openldap configuration leaning note iwindyforest configuration
hostname // to display the computer name hostname <changed name> // to change go to: /etc/sysconfig/network, add/modify HOSTNAME=NEWNAME to change permenately dont forget to change /etc/hosts
Nullability and Objective-C 啸笑天 Objective-C
https://developer.apple.com/swift/blog/?id=25 http://www.cocoachina.com/ios/20150601/11989.html http://blog.csdn.net/zhangao0086/article/details/44409913 http://blog.sunnyxx
jsp中实现参数隐藏的两种方法 macroli JavaScript jsp
在一个JSP页面有一个链接，//确定是一个链接?点击弹出一个页面，需要传给这个页面一些参数。//正常的方法是设置弹出页面的src="***.do?p1=aaa&p2=bbb&p3=ccc"//确定目标URL是Action来处理?但是这样会在页面上看到传过来的参数，可能会不安全。要求实现src="***.do"，参数通过其他方法传！//////
Bootstrap A标签关闭modal并打开新的链接解决方案 qiaolevip 每天进步一点点学习永无止境 bootstrap 纵观千象
Bootstrap里面的js modal控件使用起来很方便，关闭也很简单。只需添加标签 data-dismiss="modal" 即可。可是偏偏有时候需要a标签既要关闭modal，有要打开新的链接，尝试多种方法未果。只好使用原始js来控制。 <a href="#/group-buy" class="btn bt
二维数组在Java和C中的区别流淚的芥末 java c 二维数组数组
Java代码： public class test03 { public static void main(String[] args) { int[][] a = {{1},{2,3},{4,5,6}}; System.out.println(a[0][1]); } } 运行结果： Exception in thread "mai
systemctl命令用法 wmlJava linux systemctl
对比表，以 apache / httpd 为例任务旧指令新指令使某服务自动启动 chkconfig --level 3 httpd on systemctl enable httpd.service 使某服务不自动启动 chkconfig --level 3 httpd off systemctl disable httpd.service 检查服务状态 service h