Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Updated some files.

This commit is contained in:
James Chen 2012-04-04 21:58:04 +08:00
parent 2b17a7276c
commit 931c42a621
18 changed files with 1525 additions and 1503 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
cocos2dx/base_nodes/CCAtlasNode.cpp
View File

@ -27,13 +27,13 @@ THE SOFTWARE.
#include "CCAtlasNode.h" #include "CCAtlasNode.h"
#include "CCTextureAtlas.h" #include "CCTextureAtlas.h"
#include "CCDirector.h" #include "CCDirector.h"
#include "CCGLProgram.h" #include "CCGLProgram.h"
#include "CCShaderCache.h" #include "CCShaderCache.h"
#include "ccGLStateCache.h" #include "ccGLStateCache.h"
#include "CCDirector.h" #include "CCDirector.h"
#include "support/TransformUtils.h" #include "support/TransformUtils.h"
// external // external
#include "kazmath/GL/matrix.h" #include "kazmath/GL/matrix.h"
namespace cocos2d { namespace cocos2d {
@ -87,11 +87,11 @@ bool CCAtlasNode::initWithTileFile(const char *tile, unsigned int tileWidth, uns
m_tBlendFunc.src = CC_BLEND_SRC; m_tBlendFunc.src = CC_BLEND_SRC;
m_tBlendFunc.dst = CC_BLEND_DST; m_tBlendFunc.dst = CC_BLEND_DST;
// double retain to avoid the autorelease pool CCTextureAtlas* pNewAtlas= new CCTextureAtlas();
// also, using: self.textureAtlas supports re-initialization without leaking pNewAtlas->initWithFile(tile, itemsToRender);
this->m_pTextureAtlas = new CCTextureAtlas(); setTextureAtlas(pNewAtlas);
m_pTextureAtlas->initWithFile(tile, itemsToRender); pNewAtlas->release();
if (! m_pTextureAtlas) if (! m_pTextureAtlas)
{ {
CCLOG("cocos2d: Could not initialize CCAtlasNode. Invalid Texture."); CCLOG("cocos2d: Could not initialize CCAtlasNode. Invalid Texture.");
@ -106,8 +106,8 @@ bool CCAtlasNode::initWithTileFile(const char *tile, unsigned int tileWidth, uns
m_uQuadsToDraw = itemsToRender; m_uQuadsToDraw = itemsToRender;
// shader stuff // shader stuff
setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTexture_uColor)); setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTexture_uColor));
m_nUniformColor = glGetUniformLocation( getShaderProgram()->getProgram(), "u_color"); m_nUniformColor = glGetUniformLocation( getShaderProgram()->getProgram(), "u_color");
return true; return true;
@ -132,13 +132,13 @@ void CCAtlasNode::updateAtlasValues()
// CCAtlasNode - draw // CCAtlasNode - draw
void CCAtlasNode::draw(void) void CCAtlasNode::draw(void)
{ {
CC_NODE_DRAW_SETUP(); CC_NODE_DRAW_SETUP();
ccGLBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst ); ccGLBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );
GLfloat colors[4] = {m_tColor.r / 255.0f, m_tColor.g / 255.0f, m_tColor.b / 255.0f, m_cOpacity / 255.0f}; GLfloat colors[4] = {m_tColor.r / 255.0f, m_tColor.g / 255.0f, m_tColor.b / 255.0f, m_cOpacity / 255.0f};
getShaderProgram()->setUniformLocationWith4fv(m_nUniformColor, colors, 1); getShaderProgram()->setUniformLocationWith4fv(m_nUniformColor, colors, 1);
m_pTextureAtlas->drawNumberOfQuads(m_uQuadsToDraw, 0); m_pTextureAtlas->drawNumberOfQuads(m_uQuadsToDraw, 0);
} }
@ -234,6 +234,7 @@ void CCAtlasNode::setTextureAtlas(CCTextureAtlas* var)
CC_SAFE_RELEASE(m_pTextureAtlas); CC_SAFE_RELEASE(m_pTextureAtlas);
m_pTextureAtlas = var; m_pTextureAtlas = var;
} }
CCTextureAtlas * CCAtlasNode::getTextureAtlas() CCTextureAtlas * CCAtlasNode::getTextureAtlas()
{ {
return m_pTextureAtlas; return m_pTextureAtlas;

300
cocos2dx/base_nodes/CCNode.cpp
View File

@ -36,7 +36,7 @@ THE SOFTWARE.
#include "CCActionManager.h" #include "CCActionManager.h"
#include "CCScriptSupport.h" #include "CCScriptSupport.h"
#include "CCGLProgram.h" #include "CCGLProgram.h"
// externals // externals
#include "kazmath/GL/matrix.h" #include "kazmath/GL/matrix.h"
#if CC_NODE_RENDER_SUBPIXEL #if CC_NODE_RENDER_SUBPIXEL
@ -47,7 +47,7 @@ THE SOFTWARE.
namespace cocos2d { namespace cocos2d {
// XXX: Yes, nodes might have a sort problem once every 15 days if the game runs at 60 FPS and each frame sprites are reordered. // XXX: Yes, nodes might have a sort problem once every 15 days if the game runs at 60 FPS and each frame sprites are reordered.
static int s_globalOrderOfArrival = 1; static int s_globalOrderOfArrival = 1;
CCNode::CCNode(void) CCNode::CCNode(void)
@ -84,10 +84,10 @@ CCNode::CCNode(void)
, m_glServerState(CC_GL_BLEND) , m_glServerState(CC_GL_BLEND)
, m_bReorderChildDirty(false) , m_bReorderChildDirty(false)
{ {
// set default scheduler and actionManager // set default scheduler and actionManager
CCDirector *director = CCDirector::sharedDirector(); CCDirector *director = CCDirector::sharedDirector();
m_pActionManager = director->getActionManager(); m_pActionManager = director->getActionManager();
m_pActionManager->retain(); m_pActionManager->retain();
m_pScheduler = director->getScheduler(); m_pScheduler = director->getScheduler();
m_pScheduler->retain(); m_pScheduler->retain();
} }
@ -96,7 +96,7 @@ CCNode::~CCNode(void)
{ {
CCLOGINFO( "cocos2d: deallocing" ); CCLOGINFO( "cocos2d: deallocing" );
CC_SAFE_RELEASE(m_pActionManager); CC_SAFE_RELEASE(m_pActionManager);
CC_SAFE_RELEASE(m_pScheduler); CC_SAFE_RELEASE(m_pScheduler);
// attributes // attributes
CC_SAFE_RELEASE(m_pCamera); CC_SAFE_RELEASE(m_pCamera);
@ -162,8 +162,8 @@ void CCNode::_setZOrder(int z)
void CCNode::setZOrder(int z) void CCNode::setZOrder(int z)
{ {
_setZOrder(z); _setZOrder(z);
if (m_pParent) if (m_pParent)
{ {
m_pParent->reorderChild(this, z); m_pParent->reorderChild(this, z);
} }
} }
@ -429,7 +429,7 @@ void CCNode::setUserData(void *var)
CCRect CCNode::boundingBox() CCRect CCNode::boundingBox()
{ {
CCRect rect = CCRectMake(0, 0, m_tContentSize.width, m_tContentSize.height); CCRect rect = CCRectMake(0, 0, m_tContentSize.width, m_tContentSize.height);
return CCRectApplyAffineTransform(rect, nodeToParentTransform()); return CCRectApplyAffineTransform(rect, nodeToParentTransform());
} }
@ -637,34 +637,34 @@ void CCNode::reorderChild(CCNode *child, int zOrder)
child->_setZOrder(zOrder); child->_setZOrder(zOrder);
} }
void CCNode::sortAllChildren() void CCNode::sortAllChildren()
{ {
if (m_bReorderChildDirty) if (m_bReorderChildDirty)
{ {
int i,j,length = m_pChildren->data->num; int i,j,length = m_pChildren->data->num;
CCNode ** x = (CCNode**)m_pChildren->data->arr; CCNode ** x = (CCNode**)m_pChildren->data->arr;
CCNode *tempItem; CCNode *tempItem;
// insertion sort // insertion sort
for(i=1; i<length; i++) for(i=1; i<length; i++)
{ {
tempItem = x[i]; tempItem = x[i];
j = i-1; j = i-1;
//continue moving element downwards while zOrder is smaller or when zOrder is the same but mutatedIndex is smaller //continue moving element downwards while zOrder is smaller or when zOrder is the same but mutatedIndex is smaller
while(j>=0 && ( tempItem->m_nZOrder < x[j]->m_nZOrder || ( tempItem->m_nZOrder== x[j]->m_nZOrder && tempItem->m_nOrderOfArrival < x[j]->m_nOrderOfArrival ) ) ) while(j>=0 && ( tempItem->m_nZOrder < x[j]->m_nZOrder || ( tempItem->m_nZOrder== x[j]->m_nZOrder && tempItem->m_nOrderOfArrival < x[j]->m_nOrderOfArrival ) ) )
{ {
x[j+1] = x[j]; x[j+1] = x[j];
j = j-1; j = j-1;
} }
x[j+1] = tempItem; x[j+1] = tempItem;
} }
//don't need to check children recursively, that's done in visit of each child //don't need to check children recursively, that's done in visit of each child
m_bReorderChildDirty = false; m_bReorderChildDirty = false;
} }
} }
void CCNode::draw() void CCNode::draw()
@ -729,7 +729,7 @@ void CCNode::visit()
this->draw(); this->draw();
} }
// reset for next frame // reset for next frame
m_nOrderOfArrival = 0; m_nOrderOfArrival = 0;
if (m_pGrid && m_pGrid->isActive()) if (m_pGrid && m_pGrid->isActive())
@ -751,30 +751,30 @@ void CCNode::transformAncestors()
void CCNode::transform() void CCNode::transform()
{ {
kmMat4 transfrom4x4; kmMat4 transfrom4x4;
// Convert 3x3 into 4x4 matrix // Convert 3x3 into 4x4 matrix
CCAffineTransform tmpAffine = this->nodeToParentTransform(); CCAffineTransform tmpAffine = this->nodeToParentTransform();
CGAffineToGL(&tmpAffine, transfrom4x4.mat); CGAffineToGL(&tmpAffine, transfrom4x4.mat);
// Update Z vertex manually // Update Z vertex manually
transfrom4x4.mat[14] = m_fVertexZ; transfrom4x4.mat[14] = m_fVertexZ;
kmGLMultMatrix( &transfrom4x4 ); kmGLMultMatrix( &transfrom4x4 );
// XXX: Expensive calls. Camera should be integrated into the cached affine matrix // XXX: Expensive calls. Camera should be integrated into the cached affine matrix
if ( m_pCamera != NULL && !(m_pGrid != NULL && m_pGrid->isActive()) ) if ( m_pCamera != NULL && !(m_pGrid != NULL && m_pGrid->isActive()) )
{ {
bool translate = (m_tAnchorPointInPoints.x != 0.0f || m_tAnchorPointInPoints.y != 0.0f); bool translate = (m_tAnchorPointInPoints.x != 0.0f || m_tAnchorPointInPoints.y != 0.0f);
if( translate ) if( translate )
kmGLTranslatef(RENDER_IN_SUBPIXEL(m_tAnchorPointInPoints.x), RENDER_IN_SUBPIXEL(m_tAnchorPointInPoints.y), 0 ); kmGLTranslatef(RENDER_IN_SUBPIXEL(m_tAnchorPointInPoints.x), RENDER_IN_SUBPIXEL(m_tAnchorPointInPoints.y), 0 );
m_pCamera->locate(); m_pCamera->locate();
if( translate ) if( translate )
kmGLTranslatef(RENDER_IN_SUBPIXEL(-m_tAnchorPointInPoints.x), RENDER_IN_SUBPIXEL(-m_tAnchorPointInPoints.y), 0 ); kmGLTranslatef(RENDER_IN_SUBPIXEL(-m_tAnchorPointInPoints.x), RENDER_IN_SUBPIXEL(-m_tAnchorPointInPoints.y), 0 );
} }
} }
@ -799,9 +799,9 @@ void CCNode::onEnterTransitionDidFinish()
arrayMakeObjectsPerformSelector(m_pChildren, onEnterTransitionDidFinish, CCNode*); arrayMakeObjectsPerformSelector(m_pChildren, onEnterTransitionDidFinish, CCNode*);
} }
void CCNode::onExitTransitionDidStart() void CCNode::onExitTransitionDidStart()
{ {
arrayMakeObjectsPerformSelector(m_pChildren, onExitTransitionDidStart, CCNode*); arrayMakeObjectsPerformSelector(m_pChildren, onExitTransitionDidStart, CCNode*);
} }
void CCNode::onExit() void CCNode::onExit()
@ -835,19 +835,19 @@ void CCNode::unregisterScriptHandler(void)
} }
} }
void CCNode::setActionManager(CCActionManager* actionManager) void CCNode::setActionManager(CCActionManager* actionManager)
{ {
if( actionManager != m_pActionManager ) { if( actionManager != m_pActionManager ) {
this->stopAllActions(); this->stopAllActions();
CC_SAFE_RELEASE(m_pActionManager); CC_SAFE_RETAIN(actionManager);
CC_SAFE_RETAIN(actionManager); CC_SAFE_RELEASE(m_pActionManager);
m_pActionManager = actionManager; m_pActionManager = actionManager;
} }
} }
CCActionManager* CCNode::getActionManager() CCActionManager* CCNode::getActionManager()
{ {
return m_pActionManager; return m_pActionManager;
} }
CCAction * CCNode::runAction(CCAction* action) CCAction * CCNode::runAction(CCAction* action)
@ -886,20 +886,20 @@ unsigned int CCNode::numberOfRunningActions()
// CCNode - Callbacks // CCNode - Callbacks
void CCNode::setScheduler(CCScheduler* scheduler) void CCNode::setScheduler(CCScheduler* scheduler)
{ {
if( scheduler != m_pScheduler ) { if( scheduler != m_pScheduler ) {
this->unscheduleAllSelectors(); this->unscheduleAllSelectors();
CC_SAFE_RELEASE(m_pScheduler); CC_SAFE_RETAIN(scheduler);
CC_SAFE_RETAIN(scheduler); CC_SAFE_RELEASE(m_pScheduler);
m_pScheduler = scheduler; m_pScheduler = scheduler;
} }
} }
CCScheduler* CCNode::getScheduler() CCScheduler* CCNode::getScheduler()
{ {
return m_pScheduler; return m_pScheduler;
} }
void CCNode::scheduleUpdate() void CCNode::scheduleUpdate()
{ {
@ -921,9 +921,9 @@ void CCNode::schedule(SEL_SCHEDULE selector)
this->schedule(selector, 0.0f, kCCRepeatForever, 0.0f); this->schedule(selector, 0.0f, kCCRepeatForever, 0.0f);
} }
void CCNode::schedule(SEL_SCHEDULE selector, ccTime interval) void CCNode::schedule(SEL_SCHEDULE selector, ccTime interval)
{ {
this->schedule(selector, interval, kCCRepeatForever, 0.0f); this->schedule(selector, interval, kCCRepeatForever, 0.0f);
} }
void CCNode::schedule(SEL_SCHEDULE selector, ccTime interval, unsigned int repeat, ccTime delay) void CCNode::schedule(SEL_SCHEDULE selector, ccTime interval, unsigned int repeat, ccTime delay)
@ -934,9 +934,9 @@ void CCNode::schedule(SEL_SCHEDULE selector, ccTime interval, unsigned int repea
m_pScheduler->scheduleSelector(selector, this, interval, !m_bIsRunning, repeat, delay); m_pScheduler->scheduleSelector(selector, this, interval, !m_bIsRunning, repeat, delay);
} }
void CCNode::scheduleOnce(SEL_SCHEDULE selector, ccTime delay) void CCNode::scheduleOnce(SEL_SCHEDULE selector, ccTime delay)
{ {
this->schedule(selector, 0.0f, 0, delay); this->schedule(selector, 0.0f, 0, delay);
} }
void CCNode::unschedule(SEL_SCHEDULE selector) void CCNode::unschedule(SEL_SCHEDULE selector)
@ -967,57 +967,57 @@ void CCNode::pauseSchedulerAndActions()
CCAffineTransform CCNode::nodeToParentTransform(void) CCAffineTransform CCNode::nodeToParentTransform(void)
{ {
if ( m_bIsTransformDirty ) { if ( m_bIsTransformDirty ) {
// Translate values // Translate values
float x = m_tPosition.x; float x = m_tPosition.x;
float y = m_tPosition.y; float y = m_tPosition.y;
if ( !m_bIsRelativeAnchorPoint ) { if ( !m_bIsRelativeAnchorPoint ) {
x += m_tAnchorPointInPoints.x; x += m_tAnchorPointInPoints.x;
y += m_tAnchorPointInPoints.y; y += m_tAnchorPointInPoints.y;
} }
// Rotation values // Rotation values
float c = 1, s = 0; float c = 1, s = 0;
if( m_fRotation ) { if( m_fRotation ) {
float radians = -CC_DEGREES_TO_RADIANS(m_fRotation); float radians = -CC_DEGREES_TO_RADIANS(m_fRotation);
c = cosf(radians); c = cosf(radians);
s = sinf(radians); s = sinf(radians);
} }
bool needsSkewMatrix = ( m_fSkewX || m_fSkewY ); bool needsSkewMatrix = ( m_fSkewX || m_fSkewY );
// optimization: // optimization:
// inline anchor point calculation if skew is not needed // inline anchor point calculation if skew is not needed
if( !needsSkewMatrix && !CCPoint::CCPointEqualToPoint(m_tAnchorPointInPoints, CCPointZero) ) { if( !needsSkewMatrix && !CCPoint::CCPointEqualToPoint(m_tAnchorPointInPoints, CCPointZero) ) {
x += c * -m_tAnchorPointInPoints.x * m_fScaleX + -s * -m_tAnchorPointInPoints.y * m_fScaleY; x += c * -m_tAnchorPointInPoints.x * m_fScaleX + -s * -m_tAnchorPointInPoints.y * m_fScaleY;
y += s * -m_tAnchorPointInPoints.x * m_fScaleX + c * -m_tAnchorPointInPoints.y * m_fScaleY; y += s * -m_tAnchorPointInPoints.x * m_fScaleX + c * -m_tAnchorPointInPoints.y * m_fScaleY;
} }
// Build Transform Matrix // Build Transform Matrix
m_tTransform = CCAffineTransformMake( c * m_fScaleX, s * m_fScaleX, m_tTransform = CCAffineTransformMake( c * m_fScaleX, s * m_fScaleX,
-s * m_fScaleY, c * m_fScaleY, -s * m_fScaleY, c * m_fScaleY,
x, y ); x, y );
// XXX: Try to inline skew // XXX: Try to inline skew
// If skew is needed, apply skew and then anchor point // If skew is needed, apply skew and then anchor point
if( needsSkewMatrix ) { if( needsSkewMatrix ) {
CCAffineTransform skewMatrix = CCAffineTransformMake(1.0f, tanf(CC_DEGREES_TO_RADIANS(m_fSkewY)), CCAffineTransform skewMatrix = CCAffineTransformMake(1.0f, tanf(CC_DEGREES_TO_RADIANS(m_fSkewY)),
tanf(CC_DEGREES_TO_RADIANS(m_fSkewX)), 1.0f, tanf(CC_DEGREES_TO_RADIANS(m_fSkewX)), 1.0f,
0.0f, 0.0f ); 0.0f, 0.0f );
m_tTransform = CCAffineTransformConcat(skewMatrix, m_tTransform); m_tTransform = CCAffineTransformConcat(skewMatrix, m_tTransform);
// adjust anchor point // adjust anchor point
if( ! CCPoint::CCPointEqualToPoint(m_tAnchorPointInPoints, CCPointZero) ) if( ! CCPoint::CCPointEqualToPoint(m_tAnchorPointInPoints, CCPointZero) )
m_tTransform = CCAffineTransformTranslate(m_tTransform, -m_tAnchorPointInPoints.x, -m_tAnchorPointInPoints.y); m_tTransform = CCAffineTransformTranslate(m_tTransform, -m_tAnchorPointInPoints.x, -m_tAnchorPointInPoints.y);
} }
m_bIsTransformDirty = false; m_bIsTransformDirty = false;
} }
return m_tTransform; return m_tTransform;
} }

7
cocos2dx/kazmath/include/kazmath/aabb.h
View File

@ -26,6 +26,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef KAZMATH_AABB_H_INCLUDED #ifndef KAZMATH_AABB_H_INCLUDED
#define KAZMATH_AABB_H_INCLUDED #define KAZMATH_AABB_H_INCLUDED
#include "CCPlatformMacros.h"
#include "vec3.h" #include "vec3.h"
#include "utility.h" #include "utility.h"
@ -42,9 +43,9 @@ typedef struct kmAABB {
kmVec3 max; /** The min corner of the box */ kmVec3 max; /** The min corner of the box */
} kmAABB; } kmAABB;
const int kmAABBContainsPoint(const kmVec3* pPoint, const kmAABB* pBox); CC_DLL const int kmAABBContainsPoint(const kmVec3* pPoint, const kmAABB* pBox);
kmAABB* const kmAABBAssign(kmAABB* pOut, const kmAABB* pIn); CC_DLL kmAABB* const kmAABBAssign(kmAABB* pOut, const kmAABB* pIn);
kmAABB* const kmAABBScale(kmAABB* pOut, const kmAABB* pIn, kmScalar s); CC_DLL kmAABB* const kmAABBScale(kmAABB* pOut, const kmAABB* pIn, kmScalar s);
#ifdef __cplusplus #ifdef __cplusplus
} }

45
cocos2dx/kazmath/include/kazmath/mat3.h
View File

@ -27,6 +27,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef MAT3_H_INCLUDED #ifndef MAT3_H_INCLUDED
#define MAT3_H_INCLUDED #define MAT3_H_INCLUDED
#include "CCPlatformMacros.h"
#include "utility.h" #include "utility.h"
struct kmVec3; struct kmVec3;
@ -40,33 +41,33 @@ typedef struct kmMat3{
extern "C" { extern "C" {
#endif #endif
kmMat3* const kmMat3Fill(kmMat3* pOut, const kmScalar* pMat); CC_DLL kmMat3* const kmMat3Fill(kmMat3* pOut, const kmScalar* pMat);
kmMat3* const kmMat3Adjugate(kmMat3* pOut, const kmMat3* pIn); CC_DLL kmMat3* const kmMat3Adjugate(kmMat3* pOut, const kmMat3* pIn);
kmMat3* const kmMat3Identity(kmMat3* pOut); CC_DLL kmMat3* const kmMat3Identity(kmMat3* pOut);
kmMat3* const kmMat3Inverse(kmMat3* pOut, const kmScalar pDeterminate, const kmMat3* pM); CC_DLL kmMat3* const kmMat3Inverse(kmMat3* pOut, const kmScalar pDeterminate, const kmMat3* pM);
const int kmMat3IsIdentity(const kmMat3* pIn); CC_DLL const int kmMat3IsIdentity(const kmMat3* pIn);
kmMat3* const kmMat3Transpose(kmMat3* pOut, const kmMat3* pIn); CC_DLL kmMat3* const kmMat3Transpose(kmMat3* pOut, const kmMat3* pIn);
const kmScalar kmMat3Determinant(const kmMat3* pIn); CC_DLL const kmScalar kmMat3Determinant(const kmMat3* pIn);
kmMat3* const kmMat3Multiply(kmMat3* pOut, const kmMat3* pM1, const kmMat3* pM2); CC_DLL kmMat3* const kmMat3Multiply(kmMat3* pOut, const kmMat3* pM1, const kmMat3* pM2);
kmMat3* const kmMat3ScalarMultiply(kmMat3* pOut, const kmMat3* pM, const kmScalar pFactor); CC_DLL kmMat3* const kmMat3ScalarMultiply(kmMat3* pOut, const kmMat3* pM, const kmScalar pFactor);
kmMat3* const kmMat3RotationAxisAngle(kmMat3* pOut, const struct kmVec3* axis, kmScalar radians); CC_DLL kmMat3* const kmMat3RotationAxisAngle(kmMat3* pOut, const struct kmVec3* axis, kmScalar radians);
struct kmVec3* const kmMat3RotationToAxisAngle(struct kmVec3* pAxis, kmScalar* radians, const kmMat3* pIn); CC_DLL struct kmVec3* const kmMat3RotationToAxisAngle(struct kmVec3* pAxis, kmScalar* radians, const kmMat3* pIn);
kmMat3* const kmMat3Assign(kmMat3* pOut, const kmMat3* pIn); CC_DLL kmMat3* const kmMat3Assign(kmMat3* pOut, const kmMat3* pIn);
const int kmMat3AreEqual(const kmMat3* pM1, const kmMat3* pM2); CC_DLL const int kmMat3AreEqual(const kmMat3* pM1, const kmMat3* pM2);
kmMat3* const kmMat3RotationX(kmMat3* pOut, const kmScalar radians); CC_DLL kmMat3* const kmMat3RotationX(kmMat3* pOut, const kmScalar radians);
kmMat3* const kmMat3RotationY(kmMat3* pOut, const kmScalar radians); CC_DLL kmMat3* const kmMat3RotationY(kmMat3* pOut, const kmScalar radians);
kmMat3* const kmMat3RotationZ(kmMat3* pOut, const kmScalar radians); CC_DLL kmMat3* const kmMat3RotationZ(kmMat3* pOut, const kmScalar radians);
kmMat3* const kmMat3Rotation(kmMat3* pOut, const kmScalar radians); CC_DLL kmMat3* const kmMat3Rotation(kmMat3* pOut, const kmScalar radians);
kmMat3* const kmMat3Scaling(kmMat3* pOut, const kmScalar x, const kmScalar y); CC_DLL kmMat3* const kmMat3Scaling(kmMat3* pOut, const kmScalar x, const kmScalar y);
kmMat3* const kmMat3Translation(kmMat3* pOut, const kmScalar x, const kmScalar y); CC_DLL kmMat3* const kmMat3Translation(kmMat3* pOut, const kmScalar x, const kmScalar y);
kmMat3* const kmMat3RotationQuaternion(kmMat3* pOut, const struct kmQuaternion* pIn); CC_DLL kmMat3* const kmMat3RotationQuaternion(kmMat3* pOut, const struct kmQuaternion* pIn);
kmMat3* const kmMat3RotationAxisAngle(kmMat3* pOut, const struct kmVec3* axis, kmScalar radians); CC_DLL kmMat3* const kmMat3RotationAxisAngle(kmMat3* pOut, const struct kmVec3* axis, kmScalar radians);
struct kmVec3* const kmMat3RotationToAxisAngle(struct kmVec3* pAxis, kmScalar* radians, const kmMat3* pIn); CC_DLL struct kmVec3* const kmMat3RotationToAxisAngle(struct kmVec3* pAxis, kmScalar* radians, const kmMat3* pIn);
#ifdef __cplusplus #ifdef __cplusplus
} }

53
cocos2dx/kazmath/include/kazmath/mat4.h
View File

@ -26,6 +26,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef MAT4_H_INCLUDED #ifndef MAT4_H_INCLUDED
#define MAT4_H_INCLUDED #define MAT4_H_INCLUDED
#include "CCPlatformMacros.h"
#include "utility.h" #include "utility.h"
struct kmVec3; struct kmVec3;
@ -50,43 +51,43 @@ typedef struct kmMat4 {
kmScalar mat[16]; kmScalar mat[16];
} kmMat4; } kmMat4;
kmMat4* const kmMat4Fill(kmMat4* pOut, const kmScalar* pMat); CC_DLL kmMat4* const kmMat4Fill(kmMat4* pOut, const kmScalar* pMat);
kmMat4* const kmMat4Identity(kmMat4* pOut); CC_DLL kmMat4* const kmMat4Identity(kmMat4* pOut);
kmMat4* const kmMat4Inverse(kmMat4* pOut, const kmMat4* pM); CC_DLL kmMat4* const kmMat4Inverse(kmMat4* pOut, const kmMat4* pM);
const int kmMat4IsIdentity(const kmMat4* pIn); CC_DLL const int kmMat4IsIdentity(const kmMat4* pIn);
kmMat4* const kmMat4Transpose(kmMat4* pOut, const kmMat4* pIn); CC_DLL kmMat4* const kmMat4Transpose(kmMat4* pOut, const kmMat4* pIn);
kmMat4* const kmMat4Multiply(kmMat4* pOut, const kmMat4* pM1, const kmMat4* pM2); CC_DLL kmMat4* const kmMat4Multiply(kmMat4* pOut, const kmMat4* pM1, const kmMat4* pM2);
kmMat4* const kmMat4Assign(kmMat4* pOut, const kmMat4* pIn); CC_DLL kmMat4* const kmMat4Assign(kmMat4* pOut, const kmMat4* pIn);
const int kmMat4AreEqual(const kmMat4* pM1, const kmMat4* pM2); CC_DLL const int kmMat4AreEqual(const kmMat4* pM1, const kmMat4* pM2);
kmMat4* const kmMat4RotationX(kmMat4* pOut, const kmScalar radians); CC_DLL kmMat4* const kmMat4RotationX(kmMat4* pOut, const kmScalar radians);
kmMat4* const kmMat4RotationY(kmMat4* pOut, const kmScalar radians); CC_DLL kmMat4* const kmMat4RotationY(kmMat4* pOut, const kmScalar radians);
kmMat4* const kmMat4RotationZ(kmMat4* pOut, const kmScalar radians); CC_DLL kmMat4* const kmMat4RotationZ(kmMat4* pOut, const kmScalar radians);
kmMat4* const kmMat4RotationPitchYawRoll(kmMat4* pOut, const kmScalar pitch, const kmScalar yaw, const kmScalar roll); CC_DLL kmMat4* const kmMat4RotationPitchYawRoll(kmMat4* pOut, const kmScalar pitch, const kmScalar yaw, const kmScalar roll);
kmMat4* const kmMat4RotationQuaternion(kmMat4* pOut, const struct kmQuaternion* pQ); CC_DLL kmMat4* const kmMat4RotationQuaternion(kmMat4* pOut, const struct kmQuaternion* pQ);
kmMat4* const kmMat4RotationTranslation(kmMat4* pOut, const struct kmMat3* rotation, const struct kmVec3* translation); CC_DLL kmMat4* const kmMat4RotationTranslation(kmMat4* pOut, const struct kmMat3* rotation, const struct kmVec3* translation);
kmMat4* const kmMat4Scaling(kmMat4* pOut, const kmScalar x, const kmScalar y, const kmScalar z); CC_DLL kmMat4* const kmMat4Scaling(kmMat4* pOut, const kmScalar x, const kmScalar y, const kmScalar z);
kmMat4* const kmMat4Translation(kmMat4* pOut, const kmScalar x, const kmScalar y, const kmScalar z); CC_DLL kmMat4* const kmMat4Translation(kmMat4* pOut, const kmScalar x, const kmScalar y, const kmScalar z);
struct kmVec3* const kmMat4GetUpVec3(struct kmVec3* pOut, const kmMat4* pIn); CC_DLL struct kmVec3* const kmMat4GetUpVec3(struct kmVec3* pOut, const kmMat4* pIn);
struct kmVec3* const kmMat4GetRightVec3(struct kmVec3* pOut, const kmMat4* pIn); CC_DLL struct kmVec3* const kmMat4GetRightVec3(struct kmVec3* pOut, const kmMat4* pIn);
struct kmVec3* const kmMat4GetForwardVec3(struct kmVec3* pOut, const kmMat4* pIn); CC_DLL struct kmVec3* const kmMat4GetForwardVec3(struct kmVec3* pOut, const kmMat4* pIn);
kmMat4* const kmMat4PerspectiveProjection(kmMat4* pOut, kmScalar fovY, kmScalar aspect, kmScalar zNear, kmScalar zFar); CC_DLL kmMat4* const kmMat4PerspectiveProjection(kmMat4* pOut, kmScalar fovY, kmScalar aspect, kmScalar zNear, kmScalar zFar);
kmMat4* const kmMat4OrthographicProjection(kmMat4* pOut, kmScalar left, kmScalar right, kmScalar bottom, kmScalar top, kmScalar nearVal, kmScalar farVal); CC_DLL kmMat4* const kmMat4OrthographicProjection(kmMat4* pOut, kmScalar left, kmScalar right, kmScalar bottom, kmScalar top, kmScalar nearVal, kmScalar farVal);
kmMat4* const kmMat4LookAt(kmMat4* pOut, const struct kmVec3* pEye, const struct kmVec3* pCenter, const struct kmVec3* pUp); CC_DLL kmMat4* const kmMat4LookAt(kmMat4* pOut, const struct kmVec3* pEye, const struct kmVec3* pCenter, const struct kmVec3* pUp);
kmMat4* const kmMat4RotationAxisAngle(kmMat4* pOut, const struct kmVec3* axis, kmScalar radians); CC_DLL kmMat4* const kmMat4RotationAxisAngle(kmMat4* pOut, const struct kmVec3* axis, kmScalar radians);
struct kmMat3* const kmMat4ExtractRotation(struct kmMat3* pOut, const kmMat4* pIn); CC_DLL struct kmMat3* const kmMat4ExtractRotation(struct kmMat3* pOut, const kmMat4* pIn);
struct kmPlane* const kmMat4ExtractPlane(struct kmPlane* pOut, const kmMat4* pIn, const kmEnum plane); CC_DLL struct kmPlane* const kmMat4ExtractPlane(struct kmPlane* pOut, const kmMat4* pIn, const kmEnum plane);
struct kmVec3* const kmMat4RotationToAxisAngle(struct kmVec3* pAxis, kmScalar* radians, const kmMat4* pIn); CC_DLL struct kmVec3* const kmMat4RotationToAxisAngle(struct kmVec3* pAxis, kmScalar* radians, const kmMat4* pIn);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

19
cocos2dx/kazmath/include/kazmath/plane.h
View File

@ -33,6 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define KM_PLANE_NEAR 4 #define KM_PLANE_NEAR 4
#define KM_PLANE_FAR 5 #define KM_PLANE_FAR 5
#include "CCPlatformMacros.h"
#include "utility.h" #include "utility.h"
struct kmVec3; struct kmVec3;
@ -53,15 +54,15 @@ typedef enum POINT_CLASSIFICATION {
POINT_ON_PLANE, POINT_ON_PLANE,
} POINT_CLASSIFICATION; } POINT_CLASSIFICATION;
const kmScalar kmPlaneDot(const kmPlane* pP, const struct kmVec4* pV); CC_DLL const kmScalar kmPlaneDot(const kmPlane* pP, const struct kmVec4* pV);
const kmScalar kmPlaneDotCoord(const kmPlane* pP, const struct kmVec3* pV); CC_DLL const kmScalar kmPlaneDotCoord(const kmPlane* pP, const struct kmVec3* pV);
const kmScalar kmPlaneDotNormal(const kmPlane* pP, const struct kmVec3* pV); CC_DLL const kmScalar kmPlaneDotNormal(const kmPlane* pP, const struct kmVec3* pV);
kmPlane* const kmPlaneFromPointNormal(kmPlane* pOut, const struct kmVec3* pPoint, const struct kmVec3* pNormal); CC_DLL kmPlane* const kmPlaneFromPointNormal(kmPlane* pOut, const struct kmVec3* pPoint, const struct kmVec3* pNormal);
kmPlane* const kmPlaneFromPoints(kmPlane* pOut, const struct kmVec3* p1, const struct kmVec3* p2, const struct kmVec3* p3); CC_DLL kmPlane* const kmPlaneFromPoints(kmPlane* pOut, const struct kmVec3* p1, const struct kmVec3* p2, const struct kmVec3* p3);
kmVec3* const kmPlaneIntersectLine(struct kmVec3* pOut, const kmPlane* pP, const struct kmVec3* pV1, const struct kmVec3* pV2); CC_DLL kmVec3* const kmPlaneIntersectLine(struct kmVec3* pOut, const kmPlane* pP, const struct kmVec3* pV1, const struct kmVec3* pV2);
kmPlane* const kmPlaneNormalize(kmPlane* pOut, const kmPlane* pP); CC_DLL kmPlane* const kmPlaneNormalize(kmPlane* pOut, const kmPlane* pP);
kmPlane* const kmPlaneScale(kmPlane* pOut, const kmPlane* pP, kmScalar s); CC_DLL kmPlane* const kmPlaneScale(kmPlane* pOut, const kmPlane* pP, kmScalar s);
const POINT_CLASSIFICATION kmPlaneClassifyPoint(const kmPlane* pIn, const kmVec3* pP); /** Classifys a point against a plane */ CC_DLL const POINT_CLASSIFICATION kmPlaneClassifyPoint(const kmPlane* pIn, const kmVec3* pP); /** Classifys a point against a plane */
#ifdef __cplusplus #ifdef __cplusplus
} }

43
cocos2dx/kazmath/include/kazmath/quaternion.h
View File

@ -30,6 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
extern "C" { extern "C" {
#endif #endif
#include "CCPlatformMacros.h"
#include "utility.h" #include "utility.h"
struct kmMat4; struct kmMat4;
@ -43,68 +44,68 @@ typedef struct kmQuaternion {
kmScalar w; kmScalar w;
} kmQuaternion; } kmQuaternion;
kmQuaternion* const kmQuaternionConjugate(kmQuaternion* pOut, const kmQuaternion* pIn); ///< Returns pOut, sets pOut to the conjugate of pIn CC_DLL kmQuaternion* const kmQuaternionConjugate(kmQuaternion* pOut, const kmQuaternion* pIn); ///< Returns pOut, sets pOut to the conjugate of pIn
const kmScalar kmQuaternionDot(const kmQuaternion* q1, const kmQuaternion* q2); ///< Returns the dot product of the 2 quaternions CC_DLL const kmScalar kmQuaternionDot(const kmQuaternion* q1, const kmQuaternion* q2); ///< Returns the dot product of the 2 quaternions
kmQuaternion* kmQuaternionExp(kmQuaternion* pOut, const kmQuaternion* pIn); ///< Returns the exponential of the quaternion CC_DLL kmQuaternion* kmQuaternionExp(kmQuaternion* pOut, const kmQuaternion* pIn); ///< Returns the exponential of the quaternion
///< Makes the passed quaternion an identity quaternion ///< Makes the passed quaternion an identity quaternion
kmQuaternion* kmQuaternionIdentity(kmQuaternion* pOut); CC_DLL kmQuaternion* kmQuaternionIdentity(kmQuaternion* pOut);
///< Returns the inverse of the passed Quaternion ///< Returns the inverse of the passed Quaternion
kmQuaternion* kmQuaternionInverse(kmQuaternion* pOut, CC_DLL kmQuaternion* kmQuaternionInverse(kmQuaternion* pOut,
const kmQuaternion* pIn); const kmQuaternion* pIn);
///< Returns true if the quaternion is an identity quaternion ///< Returns true if the quaternion is an identity quaternion
int kmQuaternionIsIdentity(const kmQuaternion* pIn); CC_DLL int kmQuaternionIsIdentity(const kmQuaternion* pIn);
///< Returns the length of the quaternion ///< Returns the length of the quaternion
kmScalar kmQuaternionLength(const kmQuaternion* pIn); CC_DLL kmScalar kmQuaternionLength(const kmQuaternion* pIn);
///< Returns the length of the quaternion squared (prevents a sqrt) ///< Returns the length of the quaternion squared (prevents a sqrt)
kmScalar kmQuaternionLengthSq(const kmQuaternion* pIn); CC_DLL kmScalar kmQuaternionLengthSq(const kmQuaternion* pIn);
///< Returns the natural logarithm ///< Returns the natural logarithm
kmQuaternion* kmQuaternionLn(kmQuaternion* pOut, const kmQuaternion* pIn); CC_DLL kmQuaternion* kmQuaternionLn(kmQuaternion* pOut, const kmQuaternion* pIn);
///< Multiplies 2 quaternions together ///< Multiplies 2 quaternions together
kmQuaternion* kmQuaternionMultiply(kmQuaternion* pOut, const kmQuaternion* q1, const kmQuaternion* q2); CC_DLL kmQuaternion* kmQuaternionMultiply(kmQuaternion* pOut, const kmQuaternion* q1, const kmQuaternion* q2);
///< Normalizes a quaternion ///< Normalizes a quaternion
kmQuaternion* kmQuaternionNormalize(kmQuaternion* pOut, const kmQuaternion* pIn); CC_DLL kmQuaternion* kmQuaternionNormalize(kmQuaternion* pOut, const kmQuaternion* pIn);
///< Rotates a quaternion around an axis ///< Rotates a quaternion around an axis
kmQuaternion* kmQuaternionRotationAxis(kmQuaternion* pOut, const struct kmVec3* pV, kmScalar angle); CC_DLL kmQuaternion* kmQuaternionRotationAxis(kmQuaternion* pOut, const struct kmVec3* pV, kmScalar angle);
///< Creates a quaternion from a rotation matrix ///< Creates a quaternion from a rotation matrix
kmQuaternion* kmQuaternionRotationMatrix(kmQuaternion* pOut, const struct kmMat3* pIn); CC_DLL kmQuaternion* kmQuaternionRotationMatrix(kmQuaternion* pOut, const struct kmMat3* pIn);
///< Create a quaternion from yaw, pitch and roll ///< Create a quaternion from yaw, pitch and roll
kmQuaternion* kmQuaternionRotationYawPitchRoll(kmQuaternion* pOut, kmScalar yaw, kmScalar pitch, kmScalar roll); CC_DLL kmQuaternion* kmQuaternionRotationYawPitchRoll(kmQuaternion* pOut, kmScalar yaw, kmScalar pitch, kmScalar roll);
///< Interpolate between 2 quaternions ///< Interpolate between 2 quaternions
kmQuaternion* kmQuaternionSlerp(kmQuaternion* pOut, const kmQuaternion* q1, const kmQuaternion* q2, kmScalar t); CC_DLL kmQuaternion* kmQuaternionSlerp(kmQuaternion* pOut, const kmQuaternion* q1, const kmQuaternion* q2, kmScalar t);
///< Get the axis and angle of rotation from a quaternion ///< Get the axis and angle of rotation from a quaternion
void kmQuaternionToAxisAngle(const kmQuaternion* pIn, struct kmVec3* pVector, kmScalar* pAngle); CC_DLL void kmQuaternionToAxisAngle(const kmQuaternion* pIn, struct kmVec3* pVector, kmScalar* pAngle);
///< Scale a quaternion ///< Scale a quaternion
kmQuaternion* kmQuaternionScale(kmQuaternion* pOut, const kmQuaternion* pIn, kmScalar s); CC_DLL kmQuaternion* kmQuaternionScale(kmQuaternion* pOut, const kmQuaternion* pIn, kmScalar s);
kmQuaternion* kmQuaternionAssign(kmQuaternion* pOut, const kmQuaternion* pIn); CC_DLL kmQuaternion* kmQuaternionAssign(kmQuaternion* pOut, const kmQuaternion* pIn);
kmQuaternion* kmQuaternionAdd(kmQuaternion* pOut, const kmQuaternion* pQ1, const kmQuaternion* pQ2); CC_DLL kmQuaternion* kmQuaternionAdd(kmQuaternion* pOut, const kmQuaternion* pQ1, const kmQuaternion* pQ2);
kmQuaternion* kmQuaternionRotationBetweenVec3(kmQuaternion* pOut, const struct kmVec3* vec1, const struct kmVec3* vec2, const struct kmVec3* fallback); CC_DLL kmQuaternion* kmQuaternionRotationBetweenVec3(kmQuaternion* pOut, const struct kmVec3* vec1, const struct kmVec3* vec2, const struct kmVec3* fallback);
struct kmVec3* kmQuaternionMultiplyVec3(struct kmVec3* pOut, const kmQuaternion* q, const struct kmVec3* v); CC_DLL struct kmVec3* kmQuaternionMultiplyVec3(struct kmVec3* pOut, const kmQuaternion* q, const struct kmVec3* v);
#ifdef __cplusplus #ifdef __cplusplus
} }

9
cocos2dx/kazmath/include/kazmath/ray2.h
View File

@ -26,6 +26,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef RAY_2_H #ifndef RAY_2_H
#define RAY_2_H #define RAY_2_H
#include "CCPlatformMacros.h"
#include "utility.h" #include "utility.h"
#include "vec2.h" #include "vec2.h"
@ -38,10 +39,10 @@ typedef struct kmRay2 {
kmVec2 dir; kmVec2 dir;
} kmRay2; } kmRay2;
void kmRay2Fill(kmRay2* ray, kmScalar px, kmScalar py, kmScalar vx, kmScalar vy); CC_DLL void kmRay2Fill(kmRay2* ray, kmScalar px, kmScalar py, kmScalar vx, kmScalar vy);
kmBool kmRay2IntersectLineSegment(const kmRay2* ray, const kmVec2* p1, const kmVec2* p2, kmVec2* intersection); CC_DLL kmBool kmRay2IntersectLineSegment(const kmRay2* ray, const kmVec2* p1, const kmVec2* p2, kmVec2* intersection);
kmBool kmRay2IntersectTriangle(const kmRay2* ray, const kmVec2* p1, const kmVec2* p2, const kmVec2* p3, kmVec2* intersection, kmVec2* normal_out); CC_DLL kmBool kmRay2IntersectTriangle(const kmRay2* ray, const kmVec2* p1, const kmVec2* p2, const kmVec2* p3, kmVec2* intersection, kmVec2* normal_out);
kmBool kmRay2IntersectCircle(const kmRay2* ray, const kmVec2 centre, const kmScalar radius, kmVec2* intersection); CC_DLL kmBool kmRay2IntersectCircle(const kmRay2* ray, const kmVec2 centre, const kmScalar radius, kmVec2* intersection);
#ifdef __cplusplus #ifdef __cplusplus
} }

13
cocos2dx/kazmath/include/kazmath/utility.h
View File

@ -26,6 +26,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef UTILITY_H_INCLUDED #ifndef UTILITY_H_INCLUDED
#define UTILITY_H_INCLUDED #define UTILITY_H_INCLUDED
#include "CCPlatformMacros.h"
#include <math.h> #include <math.h>
#ifndef kmScalar #ifndef kmScalar
@ -59,13 +60,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
extern "C" { extern "C" {
#endif #endif
extern kmScalar kmSQR(kmScalar s); CC_DLL kmScalar kmSQR(kmScalar s);
extern kmScalar kmDegreesToRadians(kmScalar degrees); CC_DLL kmScalar kmDegreesToRadians(kmScalar degrees);
extern kmScalar kmRadiansToDegrees(kmScalar radians); CC_DLL kmScalar kmRadiansToDegrees(kmScalar radians);
extern kmScalar kmMin(kmScalar lhs, kmScalar rhs); CC_DLL kmScalar kmMin(kmScalar lhs, kmScalar rhs);
extern kmScalar kmMax(kmScalar lhs, kmScalar rhs); CC_DLL kmScalar kmMax(kmScalar lhs, kmScalar rhs);
extern kmBool kmAlmostEqual(kmScalar lhs, kmScalar rhs); CC_DLL kmBool kmAlmostEqual(kmScalar lhs, kmScalar rhs);
#ifdef __cplusplus #ifdef __cplusplus
} }

24
cocos2dx/kazmath/include/kazmath/vec2.h
View File

@ -26,6 +26,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef VEC2_H_INCLUDED #ifndef VEC2_H_INCLUDED
#define VEC2_H_INCLUDED #define VEC2_H_INCLUDED
#include "CCPlatformMacros.h"
struct kmMat3; struct kmMat3;
#ifndef kmScalar #ifndef kmScalar
@ -44,17 +46,17 @@ typedef struct kmVec2 {
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
kmVec2* kmVec2Fill(kmVec2* pOut, kmScalar x, kmScalar y); CC_DLL kmVec2* kmVec2Fill(kmVec2* pOut, kmScalar x, kmScalar y);
kmScalar kmVec2Length(const kmVec2* pIn); ///< Returns the length of the vector CC_DLL kmScalar kmVec2Length(const kmVec2* pIn); ///< Returns the length of the vector
kmScalar kmVec2LengthSq(const kmVec2* pIn); ///< Returns the square of the length of the vector CC_DLL kmScalar kmVec2LengthSq(const kmVec2* pIn); ///< Returns the square of the length of the vector
kmVec2* kmVec2Normalize(kmVec2* pOut, const kmVec2* pIn); ///< Returns the vector passed in set to unit length CC_DLL kmVec2* kmVec2Normalize(kmVec2* pOut, const kmVec2* pIn); ///< Returns the vector passed in set to unit length
kmVec2* kmVec2Add(kmVec2* pOut, const kmVec2* pV1, const kmVec2* pV2); ///< Adds 2 vectors and returns the result CC_DLL kmVec2* kmVec2Add(kmVec2* pOut, const kmVec2* pV1, const kmVec2* pV2); ///< Adds 2 vectors and returns the result
kmScalar kmVec2Dot(const kmVec2* pV1, const kmVec2* pV2); /** Returns the Dot product which is the cosine of the angle between the two vectors multiplied by their lengths */ CC_DLL kmScalar kmVec2Dot(const kmVec2* pV1, const kmVec2* pV2); /** Returns the Dot product which is the cosine of the angle between the two vectors multiplied by their lengths */
kmVec2* kmVec2Subtract(kmVec2* pOut, const kmVec2* pV1, const kmVec2* pV2); ///< Subtracts 2 vectors and returns the result CC_DLL kmVec2* kmVec2Subtract(kmVec2* pOut, const kmVec2* pV1, const kmVec2* pV2); ///< Subtracts 2 vectors and returns the result
kmVec2* kmVec2Transform(kmVec2* pOut, const kmVec2* pV1, const struct kmMat3* pM); /** Transform the Vector */ CC_DLL kmVec2* kmVec2Transform(kmVec2* pOut, const kmVec2* pV1, const struct kmMat3* pM); /** Transform the Vector */
kmVec2* kmVec2TransformCoord(kmVec2* pOut, const kmVec2* pV, const struct kmMat3* pM); ///<Transforms a 2D vector by a given matrix, projecting the result back into w = 1. CC_DLL kmVec2* kmVec2TransformCoord(kmVec2* pOut, const kmVec2* pV, const struct kmMat3* pM); ///<Transforms a 2D vector by a given matrix, projecting the result back into w = 1.
kmVec2* kmVec2Scale(kmVec2* pOut, const kmVec2* pIn, const kmScalar s); ///< Scales a vector to length s CC_DLL kmVec2* kmVec2Scale(kmVec2* pOut, const kmVec2* pIn, const kmScalar s); ///< Scales a vector to length s
int kmVec2AreEqual(const kmVec2* p1, const kmVec2* p2); ///< Returns 1 if both vectors are equal CC_DLL int kmVec2AreEqual(const kmVec2* p1, const kmVec2* p2); ///< Returns 1 if both vectors are equal
#ifdef __cplusplus #ifdef __cplusplus
} }

35
cocos2dx/kazmath/include/kazmath/vec3.h
View File

@ -26,6 +26,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef VEC3_H_INCLUDED #ifndef VEC3_H_INCLUDED
#define VEC3_H_INCLUDED #define VEC3_H_INCLUDED
#include "CCPlatformMacros.h"
#include <assert.h> #include <assert.h>
#ifndef kmScalar #ifndef kmScalar
@ -44,23 +45,23 @@ typedef struct kmVec3 {
extern "C" { extern "C" {
#endif #endif
kmVec3* kmVec3Fill(kmVec3* pOut, kmScalar x, kmScalar y, kmScalar z); CC_DLL kmVec3* kmVec3Fill(kmVec3* pOut, kmScalar x, kmScalar y, kmScalar z);
kmScalar kmVec3Length(const kmVec3* pIn); /** Returns the length of the vector */ CC_DLL kmScalar kmVec3Length(const kmVec3* pIn); /** Returns the length of the vector */
kmScalar kmVec3LengthSq(const kmVec3* pIn); /** Returns the square of the length of the vector */ CC_DLL kmScalar kmVec3LengthSq(const kmVec3* pIn); /** Returns the square of the length of the vector */
kmVec3* kmVec3Normalize(kmVec3* pOut, const kmVec3* pIn); /** Returns the vector passed in set to unit length */ CC_DLL kmVec3* kmVec3Normalize(kmVec3* pOut, const kmVec3* pIn); /** Returns the vector passed in set to unit length */
kmVec3* kmVec3Cross(kmVec3* pOut, const kmVec3* pV1, const kmVec3* pV2); /** Returns a vector perpendicular to 2 other vectors */ CC_DLL kmVec3* kmVec3Cross(kmVec3* pOut, const kmVec3* pV1, const kmVec3* pV2); /** Returns a vector perpendicular to 2 other vectors */
kmScalar kmVec3Dot(const kmVec3* pV1, const kmVec3* pV2); /** Returns the cosine of the angle between 2 vectors */ CC_DLL kmScalar kmVec3Dot(const kmVec3* pV1, const kmVec3* pV2); /** Returns the cosine of the angle between 2 vectors */
kmVec3* kmVec3Add(kmVec3* pOut, const kmVec3* pV1, const kmVec3* pV2); /** Adds 2 vectors and returns the result */ CC_DLL kmVec3* kmVec3Add(kmVec3* pOut, const kmVec3* pV1, const kmVec3* pV2); /** Adds 2 vectors and returns the result */
kmVec3* kmVec3Subtract(kmVec3* pOut, const kmVec3* pV1, const kmVec3* pV2); /** Subtracts 2 vectors and returns the result */ CC_DLL kmVec3* kmVec3Subtract(kmVec3* pOut, const kmVec3* pV1, const kmVec3* pV2); /** Subtracts 2 vectors and returns the result */
kmVec3* kmVec3Transform(kmVec3* pOut, const kmVec3* pV1, const struct kmMat4* pM); /** Transforms a vector (assuming w=1) by a given matrix */ CC_DLL kmVec3* kmVec3Transform(kmVec3* pOut, const kmVec3* pV1, const struct kmMat4* pM); /** Transforms a vector (assuming w=1) by a given matrix */
kmVec3* kmVec3TransformNormal(kmVec3* pOut, const kmVec3* pV, const struct kmMat4* pM);/**Transforms a 3D normal by a given matrix */ CC_DLL kmVec3* kmVec3TransformNormal(kmVec3* pOut, const kmVec3* pV, const struct kmMat4* pM);/**Transforms a 3D normal by a given matrix */
kmVec3* kmVec3TransformCoord(kmVec3* pOut, const kmVec3* pV, const struct kmMat4* pM); /**Transforms a 3D vector by a given matrix, projecting the result back into w = 1. */ CC_DLL kmVec3* kmVec3TransformCoord(kmVec3* pOut, const kmVec3* pV, const struct kmMat4* pM); /**Transforms a 3D vector by a given matrix, projecting the result back into w = 1. */
kmVec3* kmVec3Scale(kmVec3* pOut, const kmVec3* pIn, const kmScalar s); /** Scales a vector to length s */ CC_DLL kmVec3* kmVec3Scale(kmVec3* pOut, const kmVec3* pIn, const kmScalar s); /** Scales a vector to length s */
int kmVec3AreEqual(const kmVec3* p1, const kmVec3* p2); CC_DLL int kmVec3AreEqual(const kmVec3* p1, const kmVec3* p2);
kmVec3* kmVec3InverseTransform(kmVec3* pOut, const kmVec3* pV, const struct kmMat4* pM); CC_DLL kmVec3* kmVec3InverseTransform(kmVec3* pOut, const kmVec3* pV, const struct kmMat4* pM);
kmVec3* kmVec3InverseTransformNormal(kmVec3* pOut, const kmVec3* pVect, const struct kmMat4* pM); CC_DLL kmVec3* kmVec3InverseTransformNormal(kmVec3* pOut, const kmVec3* pVect, const struct kmMat4* pM);
kmVec3* kmVec3Assign(kmVec3* pOut, const kmVec3* pIn); CC_DLL kmVec3* kmVec3Assign(kmVec3* pOut, const kmVec3* pIn);
kmVec3* kmVec3Zero(kmVec3* pOut); CC_DLL kmVec3* kmVec3Zero(kmVec3* pOut);
#ifdef __cplusplus #ifdef __cplusplus
} }

27
cocos2dx/kazmath/include/kazmath/vec4.h
View File

@ -26,6 +26,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef VEC4_H_INCLUDED #ifndef VEC4_H_INCLUDED
#define VEC4_H_INCLUDED #define VEC4_H_INCLUDED
#include "CCPlatformMacros.h"
#include "utility.h" #include "utility.h"
struct kmMat4; struct kmMat4;
@ -46,20 +47,20 @@ typedef struct kmVec4 {
extern "C" { extern "C" {
#endif #endif
kmVec4* kmVec4Fill(kmVec4* pOut, kmScalar x, kmScalar y, kmScalar z, kmScalar w); CC_DLL kmVec4* kmVec4Fill(kmVec4* pOut, kmScalar x, kmScalar y, kmScalar z, kmScalar w);
kmVec4* kmVec4Add(kmVec4* pOut, const kmVec4* pV1, const kmVec4* pV2); CC_DLL kmVec4* kmVec4Add(kmVec4* pOut, const kmVec4* pV1, const kmVec4* pV2);
kmScalar kmVec4Dot(const kmVec4* pV1, const kmVec4* pV2); CC_DLL kmScalar kmVec4Dot(const kmVec4* pV1, const kmVec4* pV2);
kmScalar kmVec4Length(const kmVec4* pIn); CC_DLL kmScalar kmVec4Length(const kmVec4* pIn);
kmScalar kmVec4LengthSq(const kmVec4* pIn); CC_DLL kmScalar kmVec4LengthSq(const kmVec4* pIn);
kmVec4* kmVec4Lerp(kmVec4* pOut, const kmVec4* pV1, const kmVec4* pV2, kmScalar t); CC_DLL kmVec4* kmVec4Lerp(kmVec4* pOut, const kmVec4* pV1, const kmVec4* pV2, kmScalar t);
kmVec4* kmVec4Normalize(kmVec4* pOut, const kmVec4* pIn); CC_DLL kmVec4* kmVec4Normalize(kmVec4* pOut, const kmVec4* pIn);
kmVec4* kmVec4Scale(kmVec4* pOut, const kmVec4* pIn, const kmScalar s); ///< Scales a vector to length s CC_DLL kmVec4* kmVec4Scale(kmVec4* pOut, const kmVec4* pIn, const kmScalar s); ///< Scales a vector to length s
kmVec4* kmVec4Subtract(kmVec4* pOut, const kmVec4* pV1, const kmVec4* pV2); CC_DLL kmVec4* kmVec4Subtract(kmVec4* pOut, const kmVec4* pV1, const kmVec4* pV2);
kmVec4* kmVec4Transform(kmVec4* pOut, const kmVec4* pV, const struct kmMat4* pM); CC_DLL kmVec4* kmVec4Transform(kmVec4* pOut, const kmVec4* pV, const struct kmMat4* pM);
kmVec4* kmVec4TransformArray(kmVec4* pOut, unsigned int outStride, CC_DLL kmVec4* kmVec4TransformArray(kmVec4* pOut, unsigned int outStride,
const kmVec4* pV, unsigned int vStride, const struct kmMat4* pM, unsigned int count); const kmVec4* pV, unsigned int vStride, const struct kmMat4* pM, unsigned int count);
int kmVec4AreEqual(const kmVec4* p1, const kmVec4* p2); CC_DLL int kmVec4AreEqual(const kmVec4* p1, const kmVec4* p2);
kmVec4* kmVec4Assign(kmVec4* pOut, const kmVec4* pIn); CC_DLL kmVec4* kmVec4Assign(kmVec4* pOut, const kmVec4* pIn);
#ifdef __cplusplus #ifdef __cplusplus
} }

2
cocos2dx/particle_nodes/CCParticleBatchNode.cpp
View File

@ -481,7 +481,9 @@ void CCParticleBatchNode::insertChild(CCParticleSystem* pSystem, unsigned int in
// make room for quads, not necessary for last child // make room for quads, not necessary for last child
if (pSystem->getAtlasIndex() + pSystem->getTotalParticles() != m_pTextureAtlas->getTotalQuads()) if (pSystem->getAtlasIndex() + pSystem->getTotalParticles() != m_pTextureAtlas->getTotalQuads())
{
m_pTextureAtlas->moveQuadsFromIndex(index, index+pSystem->getTotalParticles()); m_pTextureAtlas->moveQuadsFromIndex(index, index+pSystem->getTotalParticles());
}
// increase totalParticles here for new particles, update method of particlesystem will fill the quads // increase totalParticles here for new particles, update method of particlesystem will fill the quads
m_pTextureAtlas->increaseTotalQuadsWith(pSystem->getTotalParticles()); m_pTextureAtlas->increaseTotalQuadsWith(pSystem->getTotalParticles());

4
cocos2dx/particle_nodes/CCParticleSystemQuad.cpp
View File

@ -301,8 +301,12 @@ void CCParticleSystemQuad::draw()
glBindVertexArray( m_uVAOname ); glBindVertexArray( m_uVAOname );
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_pBuffersVBO[1]);
glDrawElements(GL_TRIANGLES, (GLsizei) m_uParticleIdx*6, GL_UNSIGNED_SHORT, 0); glDrawElements(GL_TRIANGLES, (GLsizei) m_uParticleIdx*6, GL_UNSIGNED_SHORT, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindVertexArray( 0 ); glBindVertexArray( 0 );
CC_INCREMENT_GL_DRAWS(1); CC_INCREMENT_GL_DRAWS(1);

18
cocos2dx/textures/CCTextureAtlas.cpp
View File

@ -486,8 +486,9 @@ void CCTextureAtlas::moveQuadsFromIndex(unsigned int oldIndex, unsigned int amou
CCAssert(oldIndex < m_uTotalQuads, "insertQuadFromIndex:atIndex: Invalid index"); CCAssert(oldIndex < m_uTotalQuads, "insertQuadFromIndex:atIndex: Invalid index");
if( oldIndex == newIndex ) if( oldIndex == newIndex )
{
return; return;
}
//create buffer //create buffer
size_t quadSize = sizeof(ccV3F_C4B_T2F_Quad); size_t quadSize = sizeof(ccV3F_C4B_T2F_Quad);
ccV3F_C4B_T2F_Quad* tempQuads = (ccV3F_C4B_T2F_Quad*)malloc( quadSize * amount); ccV3F_C4B_T2F_Quad* tempQuads = (ccV3F_C4B_T2F_Quad*)malloc( quadSize * amount);
@ -519,12 +520,13 @@ void CCTextureAtlas::moveQuadsFromIndex(unsigned int index, unsigned int newInde
void CCTextureAtlas::fillWithEmptyQuadsFromIndex(unsigned int index, unsigned int amount) void CCTextureAtlas::fillWithEmptyQuadsFromIndex(unsigned int index, unsigned int amount)
{ {
ccV3F_C4B_T2F_Quad* quad = (ccV3F_C4B_T2F_Quad*)calloc(1,sizeof(ccV3F_C4B_T2F_Quad)); ccV3F_C4B_T2F_Quad quad;
memset(&quad, 0, sizeof(quad));
unsigned int to = index + amount; unsigned int to = index + amount;
for (int i = index ; i < to ; i++) for (int i = index ; i < to ; i++)
{ {
m_pQuads[i] = *quad; m_pQuads[i] = quad;
} }
} }
@ -552,25 +554,25 @@ void CCTextureAtlas::drawNumberOfQuads(unsigned int n, unsigned int start)
// //
// XXX: update is done in draw... perhaps it should be done in a timer // XXX: update is done in draw... perhaps it should be done in a timer
if (m_bDirty) { if (m_bDirty)
{
glBindBuffer(GL_ARRAY_BUFFER, m_pBuffersVBO[0]); glBindBuffer(GL_ARRAY_BUFFER, m_pBuffersVBO[0]);
glBufferSubData(GL_ARRAY_BUFFER, sizeof(m_pQuads[0])*start, sizeof(m_pQuads[0]) * n , &m_pQuads[start] ); glBufferSubData(GL_ARRAY_BUFFER, sizeof(m_pQuads[0])*start, sizeof(m_pQuads[0]) * n , &m_pQuads[start] );
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
m_bDirty = false; m_bDirty = false;
} }
glBindVertexArray( m_uVAOname ); glBindVertexArray( m_uVAOname );
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_pBuffersVBO[1]);
CHECK_GL_ERROR_DEBUG();
#if CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP #if CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP
glDrawElements(GL_TRIANGLE_STRIP, (GLsizei) n*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6*sizeof(m_pIndices[0])) ); glDrawElements(GL_TRIANGLE_STRIP, (GLsizei) n*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6*sizeof(m_pIndices[0])) );
#else #else
glDrawElements(GL_TRIANGLES, (GLsizei) n*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6*sizeof(m_pIndices[0])) ); glDrawElements(GL_TRIANGLES, (GLsizei) n*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6*sizeof(m_pIndices[0])) );
#endif // CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP #endif // CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindVertexArray(0); glBindVertexArray(0);
#else // ! CC_TEXTURE_ATLAS_USE_VAO #else // ! CC_TEXTURE_ATLAS_USE_VAO

4
tests/test.android/build_native.sh
View File

@ -1,7 +1,7 @@
#!/bin/bash #!/bin/bash
# set params # set params
NDK_ROOT_LOCAL=/cygdrive/d/programe/android/ndk/android-ndk-r7b NDK_ROOT_LOCAL=/cygdrive/e/android/android-ndk-r7b
COCOS2DX_ROOT_LOCAL=/cygdrive/e/cocos2d-x COCOS2DX_ROOT_LOCAL=/cygdrive/f/Project/dumganhar/cocos2d-x
# try to get global variable # try to get global variable
if [ $NDK_ROOT"aaa" != "aaa" ]; then if [ $NDK_ROOT"aaa" != "aaa" ]; then

2272
tests/tests/ParticleTest/ParticleTest.cpp
View File

File diff suppressed because it is too large Load Diff

110
tests/tests/ParticleTest/ParticleTest.h
View File

@ -1,28 +1,28 @@
#ifndef _PARTICLE_TEST_H_ #ifndef _PARTICLE_TEST_H_
#define _PARTICLE_TEST_H_ #define _PARTICLE_TEST_H_
#include "../testBasic.h" #include "../testBasic.h"
////----#include "cocos2d.h" ////----#include "cocos2d.h"
// #include "touch_dispatcher/CCTouch.h" // #include "touch_dispatcher/CCTouch.h"
// #include "CCParticleExample.h" // #include "CCParticleExample.h"
class ParticleTestScene : public TestScene class ParticleTestScene : public TestScene
{ {
public: public:
virtual void runThisTest(); virtual void runThisTest();
}; };
class ParticleDemo : public CCLayerColor class ParticleDemo : public CCLayerColor
{ {
protected: protected:
CCParticleSystem* m_emitter; CCParticleSystem* m_emitter;
CCSprite* m_background; CCSprite* m_background;
public: public:
ParticleDemo(void); ParticleDemo(void);
~ParticleDemo(void); ~ParticleDemo(void);
virtual void onEnter(void); virtual void onEnter(void);
virtual std::string title(); virtual std::string title();
@ -152,19 +152,19 @@ public:
virtual std::string title(); virtual std::string title();
}; };
class DemoParticleFromFile : public ParticleDemo class DemoParticleFromFile : public ParticleDemo
{ {
public: public:
std::string m_title; std::string m_title;
DemoParticleFromFile(const char *file) DemoParticleFromFile(const char *file)
{ {
m_title = file; m_title = file;
} }
virtual void onEnter(); virtual void onEnter();
virtual std::string title() virtual std::string title()
{ {
return m_title; return m_title;
} }
}; };
class RadiusMode1 : public ParticleDemo class RadiusMode1 : public ParticleDemo
@ -173,22 +173,22 @@ public:
virtual void onEnter(); virtual void onEnter();
virtual std::string title(); virtual std::string title();
}; };
class RadiusMode2 : public ParticleDemo class RadiusMode2 : public ParticleDemo
{ {
public: public:
virtual void onEnter(); virtual void onEnter();
virtual std::string title(); virtual std::string title();
}; };
class Issue704 : public ParticleDemo class Issue704 : public ParticleDemo
{ {
public: public:
virtual void onEnter(); virtual void onEnter();
virtual std::string title(); virtual std::string title();
virtual std::string subtitle(); virtual std::string subtitle();
}; };
class Issue870 : public ParticleDemo class Issue870 : public ParticleDemo
{ {
public: public:
@ -199,16 +199,16 @@ public:
private: private:
int m_nIndex; int m_nIndex;
}; };
class Issue1201 : public ParticleDemo class Issue1201 : public ParticleDemo
{ {
public: public:
virtual void onEnter(); virtual void onEnter();
virtual std::string title(); virtual std::string title();
virtual std::string subtitle(); virtual std::string subtitle();
}; };
class ParticleBatchHybrid : public ParticleDemo class ParticleBatchHybrid : public ParticleDemo
{ {
public: public:
@ -217,18 +217,18 @@ public:
virtual std::string title(); virtual std::string title();
virtual std::string subtitle(); virtual std::string subtitle();
private: private:
CCNode* m_pParent1; CCNode* m_pParent1;
CCNode* m_pParent2; CCNode* m_pParent2;
}; };
class ParticleBatchMultipleEmitters : public ParticleDemo class ParticleBatchMultipleEmitters : public ParticleDemo
{ {
public: public:
virtual void onEnter(); virtual void onEnter();
virtual std::string title(); virtual std::string title();
virtual std::string subtitle(); virtual std::string subtitle();
}; };
class ParticleReorder : public ParticleDemo class ParticleReorder : public ParticleDemo
{ {
public: public:
@ -238,8 +238,8 @@ public:
virtual std::string subtitle(); virtual std::string subtitle();
private: private:
unsigned int m_nOrder; unsigned int m_nOrder;
}; };
class MultipleParticleSystems : public ParticleDemo class MultipleParticleSystems : public ParticleDemo
{ {
public: public:
@ -247,8 +247,8 @@ public:
virtual std::string title(); virtual std::string title();
virtual std::string subtitle(); virtual std::string subtitle();
virtual void update(ccTime dt); virtual void update(ccTime dt);
}; };
class MultipleParticleSystemsBatched : public ParticleDemo class MultipleParticleSystemsBatched : public ParticleDemo
{ {
public: public:
@ -258,8 +258,8 @@ public:
virtual std::string subtitle(); virtual std::string subtitle();
private: private:
CCParticleBatchNode* m_pBatchNode; CCParticleBatchNode* m_pBatchNode;
}; };
class AddAndDeleteParticleSystems : public ParticleDemo class AddAndDeleteParticleSystems : public ParticleDemo
{ {
public: public:
@ -270,8 +270,8 @@ public:
virtual std::string subtitle(); virtual std::string subtitle();
private: private:
CCParticleBatchNode* m_pBatchNode; CCParticleBatchNode* m_pBatchNode;
}; };
class ReorderParticleSystems : public ParticleDemo class ReorderParticleSystems : public ParticleDemo
{ {
public: public:
@ -282,6 +282,6 @@ public:
virtual std::string subtitle(); virtual std::string subtitle();
private: private:
CCParticleBatchNode* m_pBatchNode; CCParticleBatchNode* m_pBatchNode;
}; };
#endif #endif