Sync latest axmol

Author: halx99

AttachmentVertices.h

@@ -38,11 +38,11 @@ namespace spine {
 
 class SP_API AttachmentVertices {
 	public:
-		AttachmentVertices(cocos2d::Texture2D *texture, int verticesCount, unsigned short *triangles, int trianglesCount);
+		AttachmentVertices(ax::Texture2D *texture, int verticesCount, unsigned short *triangles, int trianglesCount);
 		virtual ~AttachmentVertices();
 
-		cocos2d::Texture2D *_texture;
-		cocos2d::TrianglesCommand::Triangles *_triangles;
+		ax::Texture2D *_texture;
+		ax::TrianglesCommand::Triangles *_triangles;
 	};
 
 }// namespace spine

SkeletonAnimation.cpp

@@ -142,7 +142,7 @@ namespace spine {
 		if (_postUpdateListener) _postUpdateListener(this);
 	}
 
-	void SkeletonAnimation::draw(cocos2d::Renderer *renderer, const cocos2d::Mat4 &transform, uint32_t transformFlags) {
+	void SkeletonAnimation::draw(ax::Renderer *renderer, const ax::Mat4 &transform, uint32_t transformFlags) {
 		if (_firstDraw) {
 			_firstDraw = false;
 			update(0);

SkeletonAnimation.h

@@ -67,7 +67,7 @@ class SP_API SkeletonAnimation: public SkeletonRenderer {
 		}
 
 		virtual void update(float deltaTime) override;
-		virtual void draw(cocos2d::Renderer *renderer, const cocos2d::Mat4 &transform, uint32_t transformFlags) override;
+		virtual void draw(ax::Renderer *renderer, const ax::Mat4 &transform, uint32_t transformFlags) override;
 
 		void setAnimationStateData(AnimationStateData *stateData);
 		void setMix(const std::string &fromAnimation, const std::string &toAnimation, float duration);

SkeletonBatch.cpp

@@ -114,19 +114,19 @@ void SkeletonBatch::update (float delta) {
 	reset();
 }
 
-cocos2d::V3F_C4B_T2F* SkeletonBatch::allocateVertices(uint32_t numVertices) {
+ax::V3F_C4B_T2F* SkeletonBatch::allocateVertices(uint32_t numVertices) {
 	if (_vertices.size() - _numVertices < numVertices) {
-		cocos2d::V3F_C4B_T2F* oldData = _vertices.data();
+		ax::V3F_C4B_T2F* oldData = _vertices.data();
 		_vertices.resize((_vertices.size() + numVertices) * 2 + 1);
-		cocos2d::V3F_C4B_T2F* newData = _vertices.data();
+		ax::V3F_C4B_T2F* newData = _vertices.data();
 		for (uint32_t i = 0; i < this->_nextFreeCommand; i++) {
 			SkeletonCommand* command = _commandsPool[i];
 			SkeletonCommand::Triangles& triangles = (SkeletonCommand::Triangles&)command->getTriangles();
 			triangles.verts = newData + (triangles.verts - oldData);
 		}
 	}
 
-	cocos2d::V3F_C4B_T2F* vertices = _vertices.data() + _numVertices;
+	ax::V3F_C4B_T2F* vertices = _vertices.data() + _numVertices;
 	_numVertices += numVertices;
 	return vertices;
 }
@@ -161,9 +161,9 @@ void SkeletonBatch::deallocateIndices(uint32_t numIndices) {
 }
 
 
-cocos2d::TrianglesCommand* SkeletonBatch::addCommand(cocos2d::Renderer* renderer, float globalOrder, cocos2d::Texture2D* texture, backend::ProgramState* programState, cocos2d::BlendFunc blendType, const cocos2d::TrianglesCommand::Triangles& triangles, const cocos2d::Mat4& mv, uint32_t flags) {
+ax::TrianglesCommand* SkeletonBatch::addCommand(ax::Renderer* renderer, float globalOrder, ax::Texture2D* texture, backend::ProgramState* programState, ax::BlendFunc blendType, const ax::TrianglesCommand::Triangles& triangles, const ax::Mat4& mv, uint32_t flags) {
 	SkeletonCommand* command = nextFreeCommand();
-    const cocos2d::Mat4& projectionMat = Director::getInstance()->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);    
+    const ax::Mat4& projectionMat = Director::getInstance()->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);    
 
 	if (programState == nullptr)
 		programState = _programState;

SkeletonBatch.h

@@ -39,9 +39,9 @@
 
 namespace spine {
 
-	struct SkeletonCommand : public cocos2d::TrianglesCommand {
-		cocos2d::backend::UniformLocation _locMVP;
-		cocos2d::backend::UniformLocation _locTexture;
+	struct SkeletonCommand : public ax::TrianglesCommand {
+		ax::backend::UniformLocation _locMVP;
+		ax::backend::UniformLocation _locTexture;
 	};
 
     class SP_API SkeletonBatch {
@@ -52,13 +52,13 @@ namespace spine {
 
         void update (float delta);
 
-		cocos2d::V3F_C4B_T2F* allocateVertices(uint32_t numVertices);
+		ax::V3F_C4B_T2F* allocateVertices(uint32_t numVertices);
 		void deallocateVertices(uint32_t numVertices);
 		unsigned short* allocateIndices(uint32_t numIndices);
 		void deallocateIndices(uint32_t numVertices);
-		cocos2d::TrianglesCommand* addCommand(cocos2d::Renderer* renderer, float globalOrder, cocos2d::Texture2D* texture, cocos2d::backend::ProgramState* programState, cocos2d::BlendFunc blendType, const cocos2d::TrianglesCommand::Triangles& triangles, const cocos2d::Mat4& mv, uint32_t flags);
+		ax::TrianglesCommand* addCommand(ax::Renderer* renderer, float globalOrder, ax::Texture2D* texture, ax::backend::ProgramState* programState, ax::BlendFunc blendType, const ax::TrianglesCommand::Triangles& triangles, const ax::Mat4& mv, uint32_t flags);
 
-		cocos2d::backend::ProgramState* updateCommandPipelinePS(SkeletonCommand* command, cocos2d::backend::ProgramState* programState);
+		ax::backend::ProgramState* updateCommandPipelinePS(SkeletonCommand* command, ax::backend::ProgramState* programState);
 
     protected:
 		SkeletonBatch ();
@@ -70,14 +70,14 @@ namespace spine {
 
 		SkeletonCommand* newCommand();
 
-		cocos2d::backend::ProgramState*                     _programState; // The default program state
+		ax::backend::ProgramState*                     _programState; // The default program state
 
 		// pool of commands
 		std::vector<SkeletonCommand*>                       _commandsPool;
 		uint32_t                                            _nextFreeCommand;
 
 		// pool of vertices
-		std::vector<cocos2d::V3F_C4B_T2F>                   _vertices;
+		std::vector<ax::V3F_C4B_T2F>                   _vertices;
 		uint32_t                                            _numVertices;
 
 		// pool of indices

SkeletonRenderer.cpp

@@ -40,11 +40,11 @@ namespace spine {
 		Cocos2dTextureLoader textureLoader;
 
 		int computeTotalCoordCount(Skeleton &skeleton, int startSlotIndex, int endSlotIndex);
-		cocos2d::Rect computeBoundingRect(const float *coords, int vertexCount);
+		ax::Rect computeBoundingRect(const float *coords, int vertexCount);
 		void interleaveCoordinates(float *dst, const float *src, int vertexCount, int dstStride);
 		BlendFunc makeBlendFunc(BlendMode blendMode, bool premultipliedAlpha);
 		void transformWorldVertices(float *dstCoord, int coordCount, Skeleton &skeleton, int startSlotIndex, int endSlotIndex);
-		bool cullRectangle(Renderer *renderer, const Mat4 &transform, const cocos2d::Rect &rect);
+		bool cullRectangle(Renderer *renderer, const Mat4 &transform, const ax::Rect &rect);
 		Color4B ColorToColor4B(const Color &color);
 		bool slotIsOutRange(Slot &slot, int startSlotIndex, int endSlotIndex);
 		bool nothingToDraw(Slot &slot, int startSlotIndex, int endSlotIndex);
@@ -268,7 +268,7 @@ namespace spine {
 		transformWorldVertices(worldCoords, coordCount, *_skeleton, _startSlotIndex, _endSlotIndex);
 
 #if CC_USE_CULLING
-		const cocos2d::Rect bb = computeBoundingRect(worldCoords, coordCount / 2);
+		const ax::Rect bb = computeBoundingRect(worldCoords, coordCount / 2);
 
 		if (cullRectangle(renderer, transform, bb)) {
 			VLA_FREE(worldCoords);
@@ -306,7 +306,7 @@ namespace spine {
 				continue;
 			}
 
-			cocos2d::TrianglesCommand::Triangles triangles;
+			ax::TrianglesCommand::Triangles triangles;
 			TwoColorTriangles trianglesTwoColor;
 
 			if (slot->getAttachment()->getRTTI().isExactly(RegionAttachment::rtti)) {
@@ -321,7 +321,7 @@ namespace spine {
 					triangles.verts = batch->allocateVertices(attachmentVertices->_triangles->vertCount);
 					triangles.vertCount = attachmentVertices->_triangles->vertCount;
 					assert(triangles.vertCount == 4);
-					memcpy(triangles.verts, attachmentVertices->_triangles->verts, sizeof(cocos2d::V3F_C4B_T2F) * attachmentVertices->_triangles->vertCount);
+					memcpy(triangles.verts, attachmentVertices->_triangles->verts, sizeof(ax::V3F_C4B_T2F) * attachmentVertices->_triangles->vertCount);
 					dstStride = sizeof(V3F_C4B_T2F) / sizeof(float);
 					dstTriangleVertices = reinterpret_cast<float *>(triangles.verts);
 				} else {
@@ -353,7 +353,7 @@ namespace spine {
 					triangles.indexCount = attachmentVertices->_triangles->indexCount;
 					triangles.verts = batch->allocateVertices(attachmentVertices->_triangles->vertCount);
 					triangles.vertCount = attachmentVertices->_triangles->vertCount;
-					memcpy(triangles.verts, attachmentVertices->_triangles->verts, sizeof(cocos2d::V3F_C4B_T2F) * attachmentVertices->_triangles->vertCount);
+					memcpy(triangles.verts, attachmentVertices->_triangles->verts, sizeof(ax::V3F_C4B_T2F) * attachmentVertices->_triangles->vertCount);
 					dstTriangleVertices = (float *) triangles.verts;
 					dstStride = sizeof(V3F_C4B_T2F) / sizeof(float);
 					dstVertexCount = triangles.vertCount;
@@ -408,14 +408,14 @@ namespace spine {
 				color.b *= color.a;
 			}
 
-			const cocos2d::Color4B color4B = ColorToColor4B(color);
-			const cocos2d::Color4B darkColor4B = ColorToColor4B(darkColor);
+			const ax::Color4B color4B = ColorToColor4B(color);
+			const ax::Color4B darkColor4B = ColorToColor4B(darkColor);
 			const BlendFunc blendFunc = makeBlendFunc(slot->getData().getBlendMode(), attachmentVertices->_texture->hasPremultipliedAlpha());
 			_blendFunc = blendFunc;
 
 			if (hasSingleTint) {
 				if (_clipper->isClipping()) {
-					_clipper->clipTriangles((float *) &triangles.verts[0].vertices, triangles.indices, triangles.indexCount, (float *) &triangles.verts[0].texCoords, sizeof(cocos2d::V3F_C4B_T2F) / 4);
+					_clipper->clipTriangles((float *) &triangles.verts[0].vertices, triangles.indices, triangles.indexCount, (float *) &triangles.verts[0].texCoords, sizeof(ax::V3F_C4B_T2F) / 4);
 					batch->deallocateVertices(triangles.vertCount);
 
 					if (_clipper->getClippedTriangles().size() == 0) {
@@ -431,9 +431,9 @@ namespace spine {
 					memcpy(triangles.indices, _clipper->getClippedTriangles().buffer(), sizeof(unsigned short) * _clipper->getClippedTriangles().size());
 
 #if COCOS2D_VERSION < 0x00040000
-					cocos2d::TrianglesCommand *batchedTriangles = batch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture, _glProgramState, blendFunc, triangles, transform, transformFlags);
+					ax::TrianglesCommand *batchedTriangles = batch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture, _glProgramState, blendFunc, triangles, transform, transformFlags);
 #else
-					cocos2d::TrianglesCommand *batchedTriangles = batch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture, _programState, blendFunc, triangles, transform, transformFlags);
+					ax::TrianglesCommand *batchedTriangles = batch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture, _programState, blendFunc, triangles, transform, transformFlags);
 #endif
 
 					const float *verts = _clipper->getClippedVertices().buffer();
@@ -463,9 +463,9 @@ namespace spine {
 				} else {
 					// Not clipping.
 #if COCOS2D_VERSION < 0x00040000
-					cocos2d::TrianglesCommand *batchedTriangles = batch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture, _glProgramState, blendFunc, triangles, transform, transformFlags);
+					ax::TrianglesCommand *batchedTriangles = batch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture, _glProgramState, blendFunc, triangles, transform, transformFlags);
 #else
-					cocos2d::TrianglesCommand *batchedTriangles = batch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture, _programState, blendFunc, triangles, transform, transformFlags);
+					ax::TrianglesCommand *batchedTriangles = batch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture, _programState, blendFunc, triangles, transform, transformFlags);
 #endif
 
 					if (_effect) {
@@ -574,7 +574,7 @@ namespace spine {
 			if (!parent || parent->getChildrenCount() > 100 || getChildrenCount() != 0) {
 				lastTwoColorTrianglesCommand->setForceFlush(true);
 			} else {
-				const cocos2d::Vector<Node *> &children = parent->getChildren();
+				const ax::Vector<Node *> &children = parent->getChildren();
 				Node *sibling = nullptr;
 				for (ssize_t i = 0; i < children.size(); i++) {
 					if (children.at(i) == this) {
@@ -626,7 +626,7 @@ namespace spine {
 #else
 			drawNode->setLineWidth(2.0f);
 #endif
-			const cocos2d::Rect brect = getBoundingBox();
+			const ax::Rect brect = getBoundingBox();
 			const Vec2 points[4] =
 					{
 							brect.origin,
@@ -728,12 +728,12 @@ namespace spine {
 #endif
 	}
 
-	cocos2d::Rect SkeletonRenderer::getBoundingBox() const {
+	ax::Rect SkeletonRenderer::getBoundingBox() const {
 		const int coordCount = computeTotalCoordCount(*_skeleton, _startSlotIndex, _endSlotIndex);
 		if (coordCount == 0) return {0, 0, 0, 0};
 		VLA(float, worldCoords, coordCount);
 		transformWorldVertices(worldCoords, coordCount, *_skeleton, _startSlotIndex, _endSlotIndex);
-		const cocos2d::Rect bb = computeBoundingRect(worldCoords, coordCount / 2);
+		const ax::Rect bb = computeBoundingRect(worldCoords, coordCount / 2);
 		VLA_FREE(worldCoords);
 		return bb;
 	}
@@ -882,7 +882,7 @@ namespace spine {
 	}
 
 	namespace {
-		cocos2d::Rect computeBoundingRect(const float *coords, int vertexCount) {
+		ax::Rect computeBoundingRect(const float *coords, int vertexCount) {
 			assert(coords);
 			assert(vertexCount > 0);
 
@@ -1033,7 +1033,7 @@ namespace spine {
 		}
 
 
-		bool cullRectangle(Renderer *renderer, const Mat4 &transform, const cocos2d::Rect &rect) {
+		bool cullRectangle(Renderer *renderer, const Mat4 &transform, const ax::Rect &rect) {
 			if (Camera::getVisitingCamera() == nullptr)
 				return false;
 

SkeletonRenderer.h

@@ -38,7 +38,7 @@ namespace spine {
 	class AttachmentVertices;
 
 	/* Draws a skeleton. */
-	class SP_API SkeletonRenderer: public cocos2d::Node, public cocos2d::BlendProtocol {
+	class SP_API SkeletonRenderer: public ax::Node, public ax::BlendProtocol {
 	public:
 		CREATE_FUNC(SkeletonRenderer);
 		static SkeletonRenderer *createWithSkeleton(Skeleton *skeleton, bool ownsSkeleton = false, bool ownsSkeletonData = false);
@@ -47,8 +47,8 @@ namespace spine {
 		static SkeletonRenderer *createWithFile(const std::string &skeletonDataFile, const std::string &atlasFile, float scale = 1);
 
 		void update(float deltaTime) override;
-		void draw(cocos2d::Renderer *renderer, const cocos2d::Mat4 &transform, uint32_t transformFlags) override;
-		cocos2d::Rect getBoundingBox() const override;
+		void draw(ax::Renderer *renderer, const ax::Mat4 &transform, uint32_t transformFlags) override;
+		ax::Rect getBoundingBox() const override;
 		void onEnter() override;
 		void onExit() override;
 
@@ -109,8 +109,8 @@ namespace spine {
 		void setSlotsRange(int startSlotIndex, int endSlotIndex);
 
 		// --- BlendProtocol
-		void setBlendFunc(const cocos2d::BlendFunc &blendFunc) override;
-		const cocos2d::BlendFunc &getBlendFunc() const override;
+		void setBlendFunc(const ax::BlendFunc &blendFunc) override;
+		const ax::BlendFunc &getBlendFunc() const override;
 		void setOpacityModifyRGB(bool value) override;
 		bool isOpacityModifyRGB() const override;
 
@@ -134,15 +134,15 @@ namespace spine {
 	protected:
 		void setSkeletonData(SkeletonData *skeletonData, bool ownsSkeletonData);
 		void setupGLProgramState(bool twoColorTintEnabled);
-		virtual void drawDebug(cocos2d::Renderer *renderer, const cocos2d::Mat4 &transform, uint32_t transformFlags);
+		virtual void drawDebug(ax::Renderer *renderer, const ax::Mat4 &transform, uint32_t transformFlags);
 
 		bool _ownsSkeletonData;
 		bool _ownsSkeleton;
 		bool _ownsAtlas = false;
 		Atlas *_atlas;
 		AttachmentLoader *_attachmentLoader;
-		cocos2d::CustomCommand _debugCommand;
-		cocos2d::BlendFunc _blendFunc;
+		ax::CustomCommand _debugCommand;
+		ax::BlendFunc _blendFunc;
 		bool _premultipliedAlpha;
 		Skeleton *_skeleton;
 		float _timeScale;
@@ -152,7 +152,7 @@ namespace spine {
 		bool _debugBoundingRect;
 		SkeletonClipping *_clipper;
 		VertexEffect *_effect;
-		cocos2d::Rect _boundingRect;
+		ax::Rect _boundingRect;
 
 		int _startSlotIndex;
 		int _endSlotIndex;

SkeletonTwoColorBatch.cpp

@@ -136,10 +136,10 @@ namespace spine {
 		_type = RenderCommand::Type::CUSTOM_COMMAND;
 	}
 
-	void TwoColorTrianglesCommand::init(float globalOrder, cocos2d::Texture2D *texture, cocos2d::backend::ProgramState *programState, BlendFunc blendType, const TwoColorTriangles &triangles, const Mat4 &mv, uint32_t flags) {
+	void TwoColorTrianglesCommand::init(float globalOrder, ax::Texture2D *texture, ax::backend::ProgramState *programState, BlendFunc blendType, const TwoColorTriangles &triangles, const Mat4 &mv, uint32_t flags) {
 
 		updateCommandPipelineDescriptor(programState);
-		const cocos2d::Mat4 &projectionMat = Director::getInstance()->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
+		const ax::Mat4 &projectionMat = Director::getInstance()->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
 
 		auto finalMatrix = projectionMat * mv;
 
@@ -175,7 +175,7 @@ namespace spine {
 	}
 
 
-	void TwoColorTrianglesCommand::updateCommandPipelineDescriptor(cocos2d::backend::ProgramState *programState) {
+	void TwoColorTrianglesCommand::updateCommandPipelineDescriptor(ax::backend::ProgramState *programState) {
 		// OPTIMIZE ME: all commands belong a same Node should share a same programState like SkeletonBatch
 		if (!__twoColorProgramState) {
 			initTwoColorProgramState();
@@ -342,15 +342,15 @@ namespace spine {
 		_indices.setSize(_indices.size() - numIndices, 0);
 	}
 
-	TwoColorTrianglesCommand *SkeletonTwoColorBatch::addCommand(cocos2d::Renderer *renderer, float globalOrder, cocos2d::Texture2D *texture, backend::ProgramState *programState, cocos2d::BlendFunc blendType, const TwoColorTriangles &triangles, const cocos2d::Mat4 &mv, uint32_t flags) {
+	TwoColorTrianglesCommand *SkeletonTwoColorBatch::addCommand(ax::Renderer *renderer, float globalOrder, ax::Texture2D *texture, backend::ProgramState *programState, ax::BlendFunc blendType, const TwoColorTriangles &triangles, const ax::Mat4 &mv, uint32_t flags) {
 		TwoColorTrianglesCommand *command = nextFreeCommand();
 		command->init(globalOrder, texture, programState, blendType, triangles, mv, flags);
 		command->updateVertexAndIndexBuffer(renderer, triangles.verts, triangles.vertCount, triangles.indices, triangles.indexCount);
 		renderer->addCommand(command);
 		return command;
 	}
 
-	void SkeletonTwoColorBatch::batch(cocos2d::Renderer *renderer, TwoColorTrianglesCommand *command) {
+	void SkeletonTwoColorBatch::batch(ax::Renderer *renderer, TwoColorTrianglesCommand *command) {
 		if (_numVerticesBuffer + command->getTriangles().vertCount >= MAX_VERTICES || _numIndicesBuffer + command->getTriangles().indexCount >= MAX_INDICES) {
 			flush(renderer, _lastCommand);
 		}
@@ -381,7 +381,7 @@ namespace spine {
 		_lastCommand = command;
 	}
 
-	void SkeletonTwoColorBatch::flush(cocos2d::Renderer *renderer, TwoColorTrianglesCommand *materialCommand) {
+	void SkeletonTwoColorBatch::flush(ax::Renderer *renderer, TwoColorTrianglesCommand *materialCommand) {
 		if (!materialCommand)
 			return;