axmol/cocos/2d/CCProgressTimer.cpp

566 lines
18 KiB
C++
Raw Normal View History

/****************************************************************************
Copyright (c) 2010 Lam Pham
Copyright (c) 2010-2012 cocos2d-x.org
Copyright (c) 2013-2014 Chukong Technologies Inc
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 "2d/CCProgressTimer.h"
2014-04-30 08:37:36 +08:00
#include "base/ccMacros.h"
2014-05-10 09:39:25 +08:00
#include "base/CCDirector.h"
Squashed commit of the following: commit c16dcfaaea0922039aad05bce1f4efed18e04871 Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 19:05:18 2014 -0700 more linux fixes commit 1553795976c9090a1b46deb53d12910fe0676008 Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 19:04:04 2014 -0700 more linux fixes commit 1e43a8cabff33cbf25aa5eb5412f53a878222d83 Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 19:02:07 2014 -0700 fixes linux isuses commit 723a445dd6411f91846da2b801248ad8298174f1 Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:58:50 2014 -0700 more linux fixes commit 533c8025e794fc76cef02f396b3a93b3d7f4cfc8 Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:57:33 2014 -0700 more linux fixes commit 4ba1e84959670bcbf044f18d1c0d4b3cb3be4090 Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:53:43 2014 -0700 more linux fixes commit 1f8e011f306a47ed4134224e5e349929201f0539 Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:49:28 2014 -0700 more linux fixes commit 3e2033100822ff6d532a1b4f012337491dc11920 Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:47:43 2014 -0700 more linux fixes commit 2e708863c75fd032f1b2396dfdf1d31f7a62b713 Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:46:00 2014 -0700 more linux fixes commit 861b5b92a6efd4de7b926c20d636ce9d749b293f Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:43:15 2014 -0700 more linux fixes commit 2a43365a0c1755e9b9cada53301be1a20adb31cf Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:36:06 2014 -0700 more fixes for linux commit 7d332bf911892f87c7824d2a5da7bf73ce7ec411 Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:35:29 2014 -0700 more fixes for linux commit f1becc17d3316dfe3678c23c9dcedb7a447d9235 Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:34:44 2014 -0700 more fixes for linux commit d2e5959bb0dde921dd5e73be1d8acc3b3f50e51d Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:33:45 2014 -0700 fixes for linux commit ad9b633c352107cf0e8b060a0e23d6e6a3f5e80f Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:16:48 2014 -0700 compiles on Windows commit 4425ee8e5de8f42a2d6050e4470109600dce8b5d Author: Ricardo Quesada <ricardoquesada@gmail.com> Date: Wed Apr 30 18:07:20 2014 -0700 fix builder
2014-05-01 10:09:13 +08:00
#include "2d/CCTextureCache.h"
2014-05-10 09:39:25 +08:00
#include "2d/CCDrawingPrimitives.h"
#include "renderer/CCGLProgram.h"
2014-05-10 09:39:25 +08:00
#include "renderer/CCGLProgramState.h"
#include "renderer/ccGLStateCache.h"
2014-04-30 08:37:36 +08:00
#include "renderer/CCRenderer.h"
#include "renderer/CCCustomCommand.h"
2014-05-10 09:39:25 +08:00
#include "math/TransformUtils.h"
// extern
#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
const char kProgressTextureCoords = 0x4b;
ProgressTimer::ProgressTimer()
2013-07-26 17:28:18 +08:00
:_type(Type::RADIAL)
,_midpoint(0,0)
,_barChangeRate(0,0)
,_percentage(0.0f)
,_sprite(nullptr)
,_vertexDataCount(0)
,_vertexData(nullptr)
,_reverseDirection(false)
{}
ProgressTimer* ProgressTimer::create(Sprite* sp)
{
ProgressTimer *progressTimer = new ProgressTimer();
if (progressTimer->initWithSprite(sp))
{
progressTimer->autorelease();
}
else
{
delete progressTimer;
progressTimer = nullptr;
}
return progressTimer;
}
bool ProgressTimer::initWithSprite(Sprite* sp)
{
setPercentage(0.0f);
_vertexData = nullptr;
_vertexDataCount = 0;
setAnchorPoint(Vector2(0.5f,0.5f));
2013-07-26 17:28:18 +08:00
_type = Type::RADIAL;
_reverseDirection = false;
setMidpoint(Vector2(0.5f, 0.5f));
setBarChangeRate(Vector2(1,1));
setSprite(sp);
2014-05-10 09:39:25 +08:00
// shader state
setGLProgramState(GLProgramState::getWithGLProgramName(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR));
return true;
}
ProgressTimer::~ProgressTimer(void)
{
CC_SAFE_FREE(_vertexData);
CC_SAFE_RELEASE(_sprite);
}
void ProgressTimer::setPercentage(float percentage)
{
if (_percentage != percentage)
{
_percentage = clampf(percentage, 0, 100);
updateProgress();
}
}
void ProgressTimer::setSprite(Sprite *sprite)
{
if (_sprite != sprite)
{
CC_SAFE_RETAIN(sprite);
CC_SAFE_RELEASE(_sprite);
_sprite = sprite;
setContentSize(_sprite->getContentSize());
// Every time we set a new sprite, we free the current vertex data
if (_vertexData)
{
CC_SAFE_FREE(_vertexData);
_vertexDataCount = 0;
}
}
}
void ProgressTimer::setType(Type type)
{
if (type != _type)
{
// release all previous information
if (_vertexData)
{
CC_SAFE_FREE(_vertexData);
_vertexData = nullptr;
_vertexDataCount = 0;
}
_type = type;
}
}
void ProgressTimer::setReverseProgress(bool reverse)
{
if( _reverseDirection != reverse ) {
_reverseDirection = reverse;
// release all previous information
CC_SAFE_FREE(_vertexData);
_vertexDataCount = 0;
}
}
// Interval
///
// @returns the vertex position from the texture coordinate
///
Tex2F ProgressTimer::textureCoordFromAlphaPoint(Vector2 alpha)
{
Tex2F ret(0.0f, 0.0f);
if (!_sprite) {
return ret;
}
V3F_C4B_T2F_Quad quad = _sprite->getQuad();
Vector2 min = Vector2(quad.bl.texCoords.u,quad.bl.texCoords.v);
Vector2 max = Vector2(quad.tr.texCoords.u,quad.tr.texCoords.v);
// Fix bug #1303 so that progress timer handles sprite frame texture rotation
if (_sprite->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);
}
Vector2 ProgressTimer::vertexFromAlphaPoint(Vector2 alpha)
{
2014-04-02 15:25:37 +08:00
Vector2 ret(0.0f, 0.0f);
if (!_sprite) {
return ret;
}
V3F_C4B_T2F_Quad quad = _sprite->getQuad();
Vector2 min = Vector2(quad.bl.vertices.x,quad.bl.vertices.y);
Vector2 max = Vector2(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;
}
void ProgressTimer::updateColor(void)
{
if (!_sprite) {
return;
}
if (_vertexData)
{
Color4B sc = _sprite->getQuad().tl.colors;
for (int i = 0; i < _vertexDataCount; ++i)
{
_vertexData[i].colors = sc;
}
}
}
void ProgressTimer::updateProgress(void)
{
switch (_type)
{
2013-07-26 17:28:18 +08:00
case Type::RADIAL:
updateRadial();
break;
2013-07-26 17:28:18 +08:00
case Type::BAR:
updateBar();
break;
default:
break;
}
}
2014-04-15 16:47:29 +08:00
void ProgressTimer::setAnchorPoint(const Vector2& anchorPoint)
{
Node::setAnchorPoint(anchorPoint);
}
Vector2 ProgressTimer::getMidpoint() const
{
return _midpoint;
}
void ProgressTimer::setColor(const Color3B &color)
{
_sprite->setColor(color);
updateColor();
}
const Color3B& ProgressTimer::getColor() const
{
return _sprite->getColor();
}
void ProgressTimer::setOpacity(GLubyte opacity)
{
_sprite->setOpacity(opacity);
updateColor();
}
GLubyte ProgressTimer::getOpacity() const
{
return _sprite->getOpacity();
}
void ProgressTimer::setMidpoint(const Vector2& midPoint)
{
_midpoint = midPoint.getClampPoint(Vector2::ZERO, Vector2(1, 1));
}
///
// 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.
///
void ProgressTimer::updateRadial(void)
{
if (!_sprite) {
return;
}
float alpha = _percentage / 100.f;
float angle = 2.f*((float)M_PI) * ( _reverseDirection ? alpha : 1.0f - alpha);
// 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
// from that by the progress angle around the _midpoint pivot
Vector2 topMid = Vector2(_midpoint.x, 1.f);
Vector2 percentagePt = topMid.rotateByAngle(_midpoint, angle);
int index = 0;
Vector2 hit = Vector2::ZERO;
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;
Vector2 edgePtA = boundaryTexCoord(i % kProgressTextureCoordsCount);
Vector2 edgePtB = boundaryTexCoord(pIndex);
// 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){
edgePtB = edgePtA.lerp(edgePtB, 1-_midpoint.x);
} else if(i == 4){
edgePtA = edgePtA.lerp(edgePtB, 1-_midpoint.x);
}
// s and t are returned by ccpLineIntersect
float s = 0, t = 0;
if(Vector2::isLineIntersect(edgePtA, edgePtB, _midpoint, percentagePt, &s, &t))
{
// 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
// correct hitpoint from _midpoint to percentagePt.
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
hit = _midpoint+ ((percentagePt - _midpoint) * min_t);
}
// The size of the vertex data is the index from the hitpoint
// the 3 is for the _midpoint, 12 o'clock point and hitpoint position.
bool sameIndexCount = true;
if(_vertexDataCount != index + 3){
sameIndexCount = false;
CC_SAFE_FREE(_vertexData);
_vertexDataCount = 0;
}
if(!_vertexData) {
_vertexDataCount = index + 3;
_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
CCASSERT( _vertexData, "CCProgressTimer. Not enough memory");
}
updateColor();
if (!sameIndexCount) {
// First we populate the array with the _midpoint, then all
// vertices/texcoords/colors of the 12 'o clock start and edges and the hitpoint
_vertexData[0].texCoords = textureCoordFromAlphaPoint(_midpoint);
_vertexData[0].vertices = vertexFromAlphaPoint(_midpoint);
_vertexData[1].texCoords = textureCoordFromAlphaPoint(topMid);
_vertexData[1].vertices = vertexFromAlphaPoint(topMid);
for(int i = 0; i < index; ++i){
Vector2 alphaPoint = boundaryTexCoord(i);
_vertexData[i+2].texCoords = textureCoordFromAlphaPoint(alphaPoint);
_vertexData[i+2].vertices = vertexFromAlphaPoint(alphaPoint);
}
}
// hitpoint will go last
_vertexData[_vertexDataCount - 1].texCoords = textureCoordFromAlphaPoint(hit);
_vertexData[_vertexDataCount - 1].vertices = vertexFromAlphaPoint(hit);
}
///
// 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.
///
void ProgressTimer::updateBar(void)
{
if (!_sprite) {
return;
}
float alpha = _percentage / 100.0f;
Vector2 alphaOffset = Vector2(1.0f * (1.0f - _barChangeRate.x) + alpha * _barChangeRate.x, 1.0f * (1.0f - _barChangeRate.y) + alpha * _barChangeRate.y) * 0.5f;
Vector2 min = _midpoint - alphaOffset;
Vector2 max = _midpoint + alphaOffset;
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;
}
if (!_reverseDirection) {
if(!_vertexData) {
_vertexDataCount = 4;
_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
CCASSERT( _vertexData, "CCProgressTimer. Not enough memory");
}
// TOPLEFT
_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vector2(min.x,max.y));
_vertexData[0].vertices = vertexFromAlphaPoint(Vector2(min.x,max.y));
// BOTLEFT
_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vector2(min.x,min.y));
_vertexData[1].vertices = vertexFromAlphaPoint(Vector2(min.x,min.y));
// TOPRIGHT
_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vector2(max.x,max.y));
_vertexData[2].vertices = vertexFromAlphaPoint(Vector2(max.x,max.y));
// BOTRIGHT
_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vector2(max.x,min.y));
_vertexData[3].vertices = vertexFromAlphaPoint(Vector2(max.x,min.y));
} else {
if(!_vertexData) {
_vertexDataCount = 8;
_vertexData = (V2F_C4B_T2F*)malloc(_vertexDataCount * sizeof(V2F_C4B_T2F));
CCASSERT( _vertexData, "CCProgressTimer. Not enough memory");
// TOPLEFT 1
_vertexData[0].texCoords = textureCoordFromAlphaPoint(Vector2(0,1));
_vertexData[0].vertices = vertexFromAlphaPoint(Vector2(0,1));
// BOTLEFT 1
_vertexData[1].texCoords = textureCoordFromAlphaPoint(Vector2(0,0));
_vertexData[1].vertices = vertexFromAlphaPoint(Vector2(0,0));
// TOPRIGHT 2
_vertexData[6].texCoords = textureCoordFromAlphaPoint(Vector2(1,1));
_vertexData[6].vertices = vertexFromAlphaPoint(Vector2(1,1));
// BOTRIGHT 2
_vertexData[7].texCoords = textureCoordFromAlphaPoint(Vector2(1,0));
_vertexData[7].vertices = vertexFromAlphaPoint(Vector2(1,0));
}
// TOPRIGHT 1
_vertexData[2].texCoords = textureCoordFromAlphaPoint(Vector2(min.x,max.y));
_vertexData[2].vertices = vertexFromAlphaPoint(Vector2(min.x,max.y));
// BOTRIGHT 1
_vertexData[3].texCoords = textureCoordFromAlphaPoint(Vector2(min.x,min.y));
_vertexData[3].vertices = vertexFromAlphaPoint(Vector2(min.x,min.y));
// TOPLEFT 2
_vertexData[4].texCoords = textureCoordFromAlphaPoint(Vector2(max.x,max.y));
_vertexData[4].vertices = vertexFromAlphaPoint(Vector2(max.x,max.y));
// BOTLEFT 2
_vertexData[5].texCoords = textureCoordFromAlphaPoint(Vector2(max.x,min.y));
_vertexData[5].vertices = vertexFromAlphaPoint(Vector2(max.x,min.y));
}
updateColor();
}
Vector2 ProgressTimer::boundaryTexCoord(char index)
{
if (index < kProgressTextureCoordsCount) {
if (_reverseDirection) {
return Vector2((kProgressTextureCoords>>(7-(index<<1)))&1,(kProgressTextureCoords>>(7-((index<<1)+1)))&1);
} else {
return Vector2((kProgressTextureCoords>>((index<<1)+1))&1,(kProgressTextureCoords>>(index<<1))&1);
}
}
return Vector2::ZERO;
}
void ProgressTimer::onDraw(const Matrix &transform, bool transformUpdated)
{
2014-05-09 07:42:36 +08:00
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() );
2013-04-09 12:07:49 +08:00
#ifdef EMSCRIPTEN
setGLBufferData((void*) _vertexData, (_vertexDataCount * sizeof(V2F_C4B_T2F)), 0);
2013-04-09 12:07:49 +08:00
int offset = 0;
glVertexAttribPointer( GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), (GLvoid*)offset);
2013-04-09 12:07:49 +08:00
2014-04-02 15:25:37 +08:00
offset += sizeof(Vector2);
glVertexAttribPointer( GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(V2F_C4B_T2F), (GLvoid*)offset);
2013-04-09 12:07:49 +08:00
offset += sizeof(Color4B);
2014-05-09 03:34:26 +08:00
glVertexAttribPointer( GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), (GLvoid*)offset);
2013-04-09 12:07:49 +08:00
#else
glVertexAttribPointer( GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(_vertexData[0]) , &_vertexData[0].vertices);
2014-05-09 03:34:26 +08:00
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);
2013-04-09 12:07:49 +08:00
#endif // EMSCRIPTEN
2013-07-26 17:28:18 +08:00
if(_type == Type::RADIAL)
{
glDrawArrays(GL_TRIANGLE_FAN, 0, _vertexDataCount);
CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_vertexDataCount);
}
2013-07-26 17:28:18 +08:00
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);
}
}
}
2014-04-08 22:07:35 +08:00
void ProgressTimer::draw(Renderer *renderer, const Matrix &transform, bool transformUpdated)
{
if( ! _vertexData || ! _sprite)
return;
_customCommand.init(_globalZOrder);
_customCommand.func = CC_CALLBACK_0(ProgressTimer::onDraw, this, transform, transformUpdated);
renderer->addCommand(&_customCommand);
}
NS_CC_END