2012-04-19 14:35:52 +08:00
|
|
|
/****************************************************************************
|
2012-06-14 15:13:16 +08:00
|
|
|
Copyright (c) 2010-2012 cocos2d-x.org
|
2012-04-19 14:35:52 +08:00
|
|
|
Copyright (c) 2010 Lam Pham
|
|
|
|
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
|
|
|
#include "CCProgressTimer.h"
|
|
|
|
|
|
|
|
#include "ccMacros.h"
|
2012-06-19 16:20:46 +08:00
|
|
|
#include "textures/CCTextureCache.h"
|
|
|
|
#include "support/CCPointExtension.h"
|
|
|
|
#include "shaders/CCGLProgram.h"
|
|
|
|
#include "shaders/CCShaderCache.h"
|
|
|
|
#include "shaders/ccGLStateCache.h"
|
2012-04-19 14:35:52 +08:00
|
|
|
#include "CCDirector.h"
|
|
|
|
#include "support/TransformUtils.h"
|
2012-11-16 14:23:14 +08:00
|
|
|
#include "draw_nodes/CCDrawingPrimitives.h"
|
2012-04-19 14:35:52 +08:00
|
|
|
// extern
|
|
|
|
#include "kazmath/GL/matrix.h"
|
|
|
|
|
|
|
|
#include <float.h>
|
|
|
|
|
|
|
|
NS_CC_BEGIN
|
|
|
|
|
|
|
|
#define kProgressTextureCoordsCount 4
|
|
|
|
// kProgressTextureCoords holds points {0,1} {0,0} {1,0} {1,1} we can represent it as bits
|
2013-06-20 14:13:12 +08:00
|
|
|
const char kProgressTextureCoords = 0x4b;
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
ProgressTimer::ProgressTimer()
|
|
|
|
:_type(kProgressTimerTypeRadial)
|
2013-06-15 14:03:30 +08:00
|
|
|
,_percentage(0.0f)
|
|
|
|
,_sprite(NULL)
|
|
|
|
,_vertexDataCount(0)
|
|
|
|
,_vertexData(NULL)
|
|
|
|
,_midpoint(0,0)
|
|
|
|
,_barChangeRate(0,0)
|
|
|
|
,_reverseDirection(false)
|
2012-04-19 14:35:52 +08:00
|
|
|
{}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
ProgressTimer* ProgressTimer::create(Sprite* sp)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-20 14:13:12 +08:00
|
|
|
ProgressTimer *pProgressTimer = new ProgressTimer();
|
2012-04-19 14:35:52 +08:00
|
|
|
if (pProgressTimer->initWithSprite(sp))
|
|
|
|
{
|
|
|
|
pProgressTimer->autorelease();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
delete pProgressTimer;
|
|
|
|
pProgressTimer = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pProgressTimer;
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
bool ProgressTimer::initWithSprite(Sprite* sp)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
|
|
|
setPercentage(0.0f);
|
2013-06-15 14:03:30 +08:00
|
|
|
_vertexData = NULL;
|
|
|
|
_vertexDataCount = 0;
|
2012-04-19 14:35:52 +08:00
|
|
|
|
2013-07-12 14:11:55 +08:00
|
|
|
setAnchorPoint(Point(0.5f,0.5f));
|
2013-06-20 14:13:12 +08:00
|
|
|
_type = kProgressTimerTypeRadial;
|
2013-06-15 14:03:30 +08:00
|
|
|
_reverseDirection = false;
|
2013-07-12 14:11:55 +08:00
|
|
|
setMidpoint(Point(0.5f, 0.5f));
|
|
|
|
setBarChangeRate(Point(1,1));
|
2012-04-19 14:35:52 +08:00
|
|
|
setSprite(sp);
|
|
|
|
// shader program
|
2013-06-20 14:13:12 +08:00
|
|
|
setShaderProgram(ShaderCache::sharedShaderCache()->programForKey(kShader_PositionTextureColor));
|
2012-04-19 14:35:52 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
ProgressTimer::~ProgressTimer(void)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
CC_SAFE_FREE(_vertexData);
|
|
|
|
CC_SAFE_RELEASE(_sprite);
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
void ProgressTimer::setPercentage(float fPercentage)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_percentage != fPercentage)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_percentage = clampf(fPercentage, 0, 100);
|
2012-04-19 14:35:52 +08:00
|
|
|
updateProgress();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
void ProgressTimer::setSprite(Sprite *pSprite)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_sprite != pSprite)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
|
|
|
CC_SAFE_RETAIN(pSprite);
|
2013-06-15 14:03:30 +08:00
|
|
|
CC_SAFE_RELEASE(_sprite);
|
|
|
|
_sprite = pSprite;
|
|
|
|
setContentSize(_sprite->getContentSize());
|
2012-04-19 14:35:52 +08:00
|
|
|
|
2012-09-17 15:02:24 +08:00
|
|
|
// Every time we set a new sprite, we free the current vertex data
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_vertexData)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
CC_SAFE_FREE(_vertexData);
|
|
|
|
_vertexDataCount = 0;
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
void ProgressTimer::setType(ProgressTimerType type)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (type != _type)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
|
|
|
// release all previous information
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_vertexData)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
CC_SAFE_FREE(_vertexData);
|
|
|
|
_vertexData = NULL;
|
|
|
|
_vertexDataCount = 0;
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
_type = type;
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
void ProgressTimer::setReverseProgress(bool reverse)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if( _reverseDirection != reverse ) {
|
|
|
|
_reverseDirection = reverse;
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// release all previous information
|
2013-06-15 14:03:30 +08:00
|
|
|
CC_SAFE_FREE(_vertexData);
|
|
|
|
_vertexDataCount = 0;
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
void ProgressTimer::setOpacityModifyRGB(bool bValue)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
|
|
|
CC_UNUSED_PARAM(bValue);
|
|
|
|
}
|
|
|
|
|
2013-07-05 15:06:38 +08:00
|
|
|
bool ProgressTimer::isOpacityModifyRGB(void) const
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Interval
|
|
|
|
|
2010-12-25 15:09:42 +08:00
|
|
|
///
|
2012-04-19 14:35:52 +08:00
|
|
|
// @returns the vertex position from the texture coordinate
|
2010-12-25 15:09:42 +08:00
|
|
|
///
|
2013-07-05 16:49:22 +08:00
|
|
|
Tex2F ProgressTimer::textureCoordFromAlphaPoint(Point alpha)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-07-07 21:08:14 +08:00
|
|
|
Tex2F ret(0.0f, 0.0f);
|
2013-06-15 14:03:30 +08:00
|
|
|
if (!_sprite) {
|
2012-04-19 14:35:52 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2013-07-05 16:49:22 +08:00
|
|
|
V3F_C4B_T2F_Quad quad = _sprite->getQuad();
|
2013-07-12 14:11:55 +08:00
|
|
|
Point min = Point(quad.bl.texCoords.u,quad.bl.texCoords.v);
|
|
|
|
Point max = Point(quad.tr.texCoords.u,quad.tr.texCoords.v);
|
2012-04-19 14:35:52 +08:00
|
|
|
// Fix bug #1303 so that progress timer handles sprite frame texture rotation
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_sprite->isTextureRectRotated()) {
|
2012-04-19 14:35:52 +08:00
|
|
|
CC_SWAP(alpha.x, alpha.y, float);
|
|
|
|
}
|
2013-07-05 16:49:22 +08:00
|
|
|
return Tex2F(min.x * (1.f - alpha.x) + max.x * alpha.x, min.y * (1.f - alpha.y) + max.y * alpha.y);
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
|
2013-07-05 16:49:22 +08:00
|
|
|
Vertex2F ProgressTimer::vertexFromAlphaPoint(Point alpha)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-07-07 21:08:14 +08:00
|
|
|
Vertex2F ret(0.0f, 0.0f);
|
2013-06-15 14:03:30 +08:00
|
|
|
if (!_sprite) {
|
2012-04-19 14:35:52 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2013-07-05 16:49:22 +08:00
|
|
|
V3F_C4B_T2F_Quad quad = _sprite->getQuad();
|
2013-07-12 14:11:55 +08:00
|
|
|
Point min = Point(quad.bl.vertices.x,quad.bl.vertices.y);
|
|
|
|
Point max = Point(quad.tr.vertices.x,quad.tr.vertices.y);
|
2012-04-19 14:35:52 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
void ProgressTimer::updateColor(void)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (!_sprite) {
|
2012-04-19 14:35:52 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_vertexData)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-07-05 16:49:22 +08:00
|
|
|
Color4B sc = _sprite->getQuad().tl.colors;
|
2013-06-15 14:03:30 +08:00
|
|
|
for (int i = 0; i < _vertexDataCount; ++i)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_vertexData[i].colors = sc;
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
void ProgressTimer::updateProgress(void)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
switch (_type)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-20 14:13:12 +08:00
|
|
|
case kProgressTimerTypeRadial:
|
2012-04-19 14:35:52 +08:00
|
|
|
updateRadial();
|
|
|
|
break;
|
2013-06-20 14:13:12 +08:00
|
|
|
case kProgressTimerTypeBar:
|
2012-04-19 14:35:52 +08:00
|
|
|
updateBar();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-05 15:06:38 +08:00
|
|
|
void ProgressTimer::setAnchorPoint(const Point& anchorPoint)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-20 14:13:12 +08:00
|
|
|
Node::setAnchorPoint(anchorPoint);
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
Point ProgressTimer::getMidpoint(void)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
return _midpoint;
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
void ProgressTimer::setMidpoint(Point midPoint)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-07-12 14:47:36 +08:00
|
|
|
_midpoint = midPoint.getClampPoint(Point::ZERO, Point(1, 1));
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
|
2010-12-25 15:09:42 +08:00
|
|
|
///
|
2012-04-19 14:35:52 +08:00
|
|
|
// Update does the work of mapping the texture onto the triangles
|
|
|
|
// It now doesn't occur the cost of free/alloc data every update cycle.
|
|
|
|
// It also only changes the percentage point but no other points if they have not
|
|
|
|
// been modified.
|
|
|
|
//
|
|
|
|
// It now deals with flipped texture. If you run into this problem, just use the
|
|
|
|
// sprite property and enable the methods flipX, flipY.
|
|
|
|
///
|
2013-06-20 14:13:12 +08:00
|
|
|
void ProgressTimer::updateRadial(void)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (!_sprite) {
|
2012-04-19 14:35:52 +08:00
|
|
|
return;
|
|
|
|
}
|
2013-06-15 14:03:30 +08:00
|
|
|
float alpha = _percentage / 100.f;
|
2012-04-19 14:35:52 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
float angle = 2.f*((float)M_PI) * ( _reverseDirection ? alpha : 1.0f - alpha);
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// We find the vector to do a hit detection based on the percentage
|
|
|
|
// We know the first vector is the one @ 12 o'clock (top,mid) so we rotate
|
2013-06-15 14:03:30 +08:00
|
|
|
// from that by the progress angle around the _midpoint pivot
|
2013-07-12 14:11:55 +08:00
|
|
|
Point topMid = Point(_midpoint.x, 1.f);
|
2013-07-11 16:38:58 +08:00
|
|
|
Point percentagePt = topMid.rotateByAngle(_midpoint, angle);
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
|
|
|
|
int index = 0;
|
2013-07-12 14:47:36 +08:00
|
|
|
Point hit = Point::ZERO;
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
if (alpha == 0.f) {
|
|
|
|
// More efficient since we don't always need to check intersection
|
|
|
|
// If the alpha is zero then the hit point is top mid and the index is 0.
|
|
|
|
hit = topMid;
|
|
|
|
index = 0;
|
|
|
|
} else if (alpha == 1.f) {
|
|
|
|
// More efficient since we don't always need to check intersection
|
|
|
|
// If the alpha is one then the hit point is top mid and the index is 4.
|
|
|
|
hit = topMid;
|
|
|
|
index = 4;
|
|
|
|
} else {
|
|
|
|
// We run a for loop checking the edges of the texture to find the
|
|
|
|
// intersection point
|
|
|
|
// We loop through five points since the top is split in half
|
|
|
|
|
|
|
|
float min_t = FLT_MAX;
|
|
|
|
|
|
|
|
for (int i = 0; i <= kProgressTextureCoordsCount; ++i) {
|
|
|
|
int pIndex = (i + (kProgressTextureCoordsCount - 1))%kProgressTextureCoordsCount;
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
Point edgePtA = boundaryTexCoord(i % kProgressTextureCoordsCount);
|
|
|
|
Point edgePtB = boundaryTexCoord(pIndex);
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// Remember that the top edge is split in half for the 12 o'clock position
|
|
|
|
// Let's deal with that here by finding the correct endpoints
|
|
|
|
if(i == 0){
|
2013-07-11 16:38:58 +08:00
|
|
|
edgePtB = edgePtA.lerp(edgePtB, 1-_midpoint.x);
|
2012-04-19 14:35:52 +08:00
|
|
|
} else if(i == 4){
|
2013-07-11 16:38:58 +08:00
|
|
|
edgePtA = edgePtA.lerp(edgePtB, 1-_midpoint.x);
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// s and t are returned by ccpLineIntersect
|
|
|
|
float s = 0, t = 0;
|
2013-07-11 16:38:58 +08:00
|
|
|
if(Point::isLineIntersect(edgePtA, edgePtB, _midpoint, percentagePt, &s, &t))
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
|
|
|
|
|
|
|
// Since our hit test is on rays we have to deal with the top edge
|
|
|
|
// being in split in half so we have to test as a segment
|
|
|
|
if ((i == 0 || i == 4)) {
|
|
|
|
// s represents the point between edgePtA--edgePtB
|
|
|
|
if (!(0.f <= s && s <= 1.f)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// As long as our t isn't negative we are at least finding a
|
2013-06-15 14:03:30 +08:00
|
|
|
// correct hitpoint from _midpoint to percentagePt.
|
2012-04-19 14:35:52 +08:00
|
|
|
if (t >= 0.f) {
|
|
|
|
// Because the percentage line and all the texture edges are
|
|
|
|
// rays we should only account for the shortest intersection
|
|
|
|
if (t < min_t) {
|
|
|
|
min_t = t;
|
|
|
|
index = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now that we have the minimum magnitude we can use that to find our intersection
|
2013-07-11 16:38:58 +08:00
|
|
|
hit = _midpoint+ ((percentagePt - _midpoint) * min_t);
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// The size of the vertex data is the index from the hitpoint
|
2013-06-15 14:03:30 +08:00
|
|
|
// the 3 is for the _midpoint, 12 o'clock point and hitpoint position.
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
bool sameIndexCount = true;
|
2013-06-15 14:03:30 +08:00
|
|
|
if(_vertexDataCount != index + 3){
|
2012-04-19 14:35:52 +08:00
|
|
|
sameIndexCount = false;
|
2013-06-15 14:03:30 +08:00
|
|
|
CC_SAFE_FREE(_vertexData);
|
|
|
|
_vertexDataCount = 0;
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
if(!_vertexData) {
|
|
|
|
_vertexDataCount = index + 3;
|
2013-07-05 16:49:22 +08:00
|
|
|
_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
|
2013-06-15 14:03:30 +08:00
|
|
|
CCAssert( _vertexData, "CCProgressTimer. Not enough memory");
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
updateColor();
|
|
|
|
|
|
|
|
if (!sameIndexCount) {
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
// First we populate the array with the _midpoint, then all
|
2012-04-19 14:35:52 +08:00
|
|
|
// vertices/texcoords/colors of the 12 'o clock start and edges and the hitpoint
|
2013-06-15 14:03:30 +08:00
|
|
|
_vertexData[0].texCoords = textureCoordFromAlphaPoint(_midpoint);
|
|
|
|
_vertexData[0].vertices = vertexFromAlphaPoint(_midpoint);
|
2012-04-19 14:35:52 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
_vertexData[1].texCoords = textureCoordFromAlphaPoint(topMid);
|
|
|
|
_vertexData[1].vertices = vertexFromAlphaPoint(topMid);
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
for(int i = 0; i < index; ++i){
|
2013-06-20 14:13:12 +08:00
|
|
|
Point alphaPoint = boundaryTexCoord(i);
|
2013-06-15 14:03:30 +08:00
|
|
|
_vertexData[i+2].texCoords = textureCoordFromAlphaPoint(alphaPoint);
|
|
|
|
_vertexData[i+2].vertices = vertexFromAlphaPoint(alphaPoint);
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// hitpoint will go last
|
2013-06-15 14:03:30 +08:00
|
|
|
_vertexData[_vertexDataCount - 1].texCoords = textureCoordFromAlphaPoint(hit);
|
|
|
|
_vertexData[_vertexDataCount - 1].vertices = vertexFromAlphaPoint(hit);
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
///
|
|
|
|
// Update does the work of mapping the texture onto the triangles for the bar
|
|
|
|
// It now doesn't occur the cost of free/alloc data every update cycle.
|
|
|
|
// It also only changes the percentage point but no other points if they have not
|
|
|
|
// been modified.
|
|
|
|
//
|
|
|
|
// It now deals with flipped texture. If you run into this problem, just use the
|
|
|
|
// sprite property and enable the methods flipX, flipY.
|
|
|
|
///
|
2013-06-20 14:13:12 +08:00
|
|
|
void ProgressTimer::updateBar(void)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (!_sprite) {
|
2012-04-19 14:35:52 +08:00
|
|
|
return;
|
|
|
|
}
|
2013-06-15 14:03:30 +08:00
|
|
|
float alpha = _percentage / 100.0f;
|
2013-07-12 14:11:55 +08:00
|
|
|
Point alphaOffset = Point(1.0f * (1.0f - _barChangeRate.x) + alpha * _barChangeRate.x, 1.0f * (1.0f - _barChangeRate.y) + alpha * _barChangeRate.y) * 0.5f;
|
2013-07-11 16:38:58 +08:00
|
|
|
Point min = _midpoint - alphaOffset;
|
|
|
|
Point max = _midpoint + alphaOffset;
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
if (min.x < 0.f) {
|
|
|
|
max.x += -min.x;
|
|
|
|
min.x = 0.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (max.x > 1.f) {
|
|
|
|
min.x -= max.x - 1.f;
|
|
|
|
max.x = 1.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (min.y < 0.f) {
|
|
|
|
max.y += -min.y;
|
|
|
|
min.y = 0.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (max.y > 1.f) {
|
|
|
|
min.y -= max.y - 1.f;
|
|
|
|
max.y = 1.f;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
if (!_reverseDirection) {
|
|
|
|
if(!_vertexData) {
|
|
|
|
_vertexDataCount = 4;
|
2013-07-05 16:49:22 +08:00
|
|
|
_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
|
2013-06-15 14:03:30 +08:00
|
|
|
CCAssert( _vertexData, "CCProgressTimer. Not enough memory");
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
// TOPLEFT
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[0].texCoords = textureCoordFromAlphaPoint(Point(min.x,max.y));
|
|
|
|
_vertexData[0].vertices = vertexFromAlphaPoint(Point(min.x,max.y));
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// BOTLEFT
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[1].texCoords = textureCoordFromAlphaPoint(Point(min.x,min.y));
|
|
|
|
_vertexData[1].vertices = vertexFromAlphaPoint(Point(min.x,min.y));
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// TOPRIGHT
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[2].texCoords = textureCoordFromAlphaPoint(Point(max.x,max.y));
|
|
|
|
_vertexData[2].vertices = vertexFromAlphaPoint(Point(max.x,max.y));
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// BOTRIGHT
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[3].texCoords = textureCoordFromAlphaPoint(Point(max.x,min.y));
|
|
|
|
_vertexData[3].vertices = vertexFromAlphaPoint(Point(max.x,min.y));
|
2012-04-19 14:35:52 +08:00
|
|
|
} else {
|
2013-06-15 14:03:30 +08:00
|
|
|
if(!_vertexData) {
|
|
|
|
_vertexDataCount = 8;
|
2013-07-05 16:49:22 +08:00
|
|
|
_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
|
2013-06-15 14:03:30 +08:00
|
|
|
CCAssert( _vertexData, "CCProgressTimer. Not enough memory");
|
2012-04-19 14:35:52 +08:00
|
|
|
// TOPLEFT 1
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[0].texCoords = textureCoordFromAlphaPoint(Point(0,1));
|
|
|
|
_vertexData[0].vertices = vertexFromAlphaPoint(Point(0,1));
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// BOTLEFT 1
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[1].texCoords = textureCoordFromAlphaPoint(Point(0,0));
|
|
|
|
_vertexData[1].vertices = vertexFromAlphaPoint(Point(0,0));
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// TOPRIGHT 2
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[6].texCoords = textureCoordFromAlphaPoint(Point(1,1));
|
|
|
|
_vertexData[6].vertices = vertexFromAlphaPoint(Point(1,1));
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// BOTRIGHT 2
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[7].texCoords = textureCoordFromAlphaPoint(Point(1,0));
|
|
|
|
_vertexData[7].vertices = vertexFromAlphaPoint(Point(1,0));
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// TOPRIGHT 1
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[2].texCoords = textureCoordFromAlphaPoint(Point(min.x,max.y));
|
|
|
|
_vertexData[2].vertices = vertexFromAlphaPoint(Point(min.x,max.y));
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// BOTRIGHT 1
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[3].texCoords = textureCoordFromAlphaPoint(Point(min.x,min.y));
|
|
|
|
_vertexData[3].vertices = vertexFromAlphaPoint(Point(min.x,min.y));
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// TOPLEFT 2
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[4].texCoords = textureCoordFromAlphaPoint(Point(max.x,max.y));
|
|
|
|
_vertexData[4].vertices = vertexFromAlphaPoint(Point(max.x,max.y));
|
2012-04-19 14:35:52 +08:00
|
|
|
|
|
|
|
// BOTLEFT 2
|
2013-07-12 14:11:55 +08:00
|
|
|
_vertexData[5].texCoords = textureCoordFromAlphaPoint(Point(max.x,min.y));
|
|
|
|
_vertexData[5].vertices = vertexFromAlphaPoint(Point(max.x,min.y));
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
updateColor();
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
Point ProgressTimer::boundaryTexCoord(char index)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
|
|
|
if (index < kProgressTextureCoordsCount) {
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_reverseDirection) {
|
2013-07-12 14:11:55 +08:00
|
|
|
return Point((kProgressTextureCoords>>(7-(index<<1)))&1,(kProgressTextureCoords>>(7-((index<<1)+1)))&1);
|
2012-04-19 14:35:52 +08:00
|
|
|
} else {
|
2013-07-12 14:11:55 +08:00
|
|
|
return Point((kProgressTextureCoords>>((index<<1)+1))&1,(kProgressTextureCoords>>(index<<1))&1);
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
}
|
2013-07-12 14:47:36 +08:00
|
|
|
return Point::ZERO;
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
void ProgressTimer::draw(void)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if( ! _vertexData || ! _sprite)
|
2012-04-19 14:35:52 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
CC_NODE_DRAW_SETUP();
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
ccGLBlendFunc( _sprite->getBlendFunc().src, _sprite->getBlendFunc().dst );
|
2012-04-19 14:35:52 +08:00
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
ccGLEnableVertexAttribs(kVertexAttribFlag_PosColorTex );
|
2012-04-19 14:35:52 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
ccGLBindTexture2D( _sprite->getTexture()->getName() );
|
2012-04-19 14:35:52 +08:00
|
|
|
|
2013-04-09 12:07:49 +08:00
|
|
|
#ifdef EMSCRIPTEN
|
2013-07-05 16:49:22 +08:00
|
|
|
setGLBufferData((void*) _vertexData, (_vertexDataCount * sizeof(V2F_C4B_T2F)), 0);
|
2013-04-09 12:07:49 +08:00
|
|
|
|
|
|
|
int offset = 0;
|
2013-07-05 16:49:22 +08:00
|
|
|
glVertexAttribPointer( kVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), (GLvoid*)offset);
|
2013-04-09 12:07:49 +08:00
|
|
|
|
2013-07-05 16:49:22 +08:00
|
|
|
offset += sizeof(Vertex2F);
|
|
|
|
glVertexAttribPointer( kVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(V2F_C4B_T2F), (GLvoid*)offset);
|
2013-04-09 12:07:49 +08:00
|
|
|
|
2013-07-05 16:49:22 +08:00
|
|
|
offset += sizeof(Color4B);
|
|
|
|
glVertexAttribPointer( kVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), (GLvoid*)offset);
|
2013-04-09 12:07:49 +08:00
|
|
|
#else
|
2013-06-20 14:13:12 +08:00
|
|
|
glVertexAttribPointer( kVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, sizeof(_vertexData[0]) , &_vertexData[0].vertices);
|
|
|
|
glVertexAttribPointer( kVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, sizeof(_vertexData[0]), &_vertexData[0].texCoords);
|
|
|
|
glVertexAttribPointer( kVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(_vertexData[0]), &_vertexData[0].colors);
|
2013-04-09 12:07:49 +08:00
|
|
|
#endif // EMSCRIPTEN
|
2012-04-19 14:35:52 +08:00
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
if(_type == kProgressTimerTypeRadial)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
glDrawArrays(GL_TRIANGLE_FAN, 0, _vertexDataCount);
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
2013-06-20 14:13:12 +08:00
|
|
|
else if (_type == kProgressTimerTypeBar)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (!_reverseDirection)
|
2012-04-19 14:35:52 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
glDrawArrays(GL_TRIANGLE_STRIP, 0, _vertexDataCount);
|
2012-04-19 14:35:52 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
glDrawArrays(GL_TRIANGLE_STRIP, 0, _vertexDataCount/2);
|
|
|
|
glDrawArrays(GL_TRIANGLE_STRIP, 4, _vertexDataCount/2);
|
2012-04-19 14:35:52 +08:00
|
|
|
// 2 draw calls
|
|
|
|
CC_INCREMENT_GL_DRAWS(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
CC_INCREMENT_GL_DRAWS(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_CC_END
|