Merge pull request #1194 from moai/feature/community-2.0

Feature/community 2.0

.gitmodules

@@ -4,6 +4,12 @@
 [submodule "3rdparty/kissfft"]
 	path = 3rdparty/kissfft
 	url = https://github.com/itdaniher/kissfft.git
+[submodule "3rdparty/mbedtls"]
+	path = 3rdparty/mbedtls
+	url = https://github.com/ARMmbed/mbedtls.git
+[submodule "3rdparty/curl"]
+	path = 3rdparty/curl
+	url = https://github.com/curl/curl
 [submodule "3rdparty/assimp"]
 	path = 3rdparty/assimp
 	url = https://github.com/assimp/assimp.git

3rdparty/assimp-config/revision.h

@@ -1,7 +1,7 @@
 #ifndef ASSIMP_REVISION_H_INC
 #define ASSIMP_REVISION_H_INC
 
-#define GitVersion 0x9b6de15
+#define GitVersion 0xeb8639d
 #define GitBranch "master"
 
 #endif // ASSIMP_REVISION_H_INC

3rdparty/freetype-2.7/src/gzip/zconf.h

@@ -217,7 +217,6 @@
 
 #if !defined(MACOS) && !defined(TARGET_OS_MAC)
 typedef unsigned char  Byte;  /* 8 bits */
-eregrgrgregr
 #endif
 typedef unsigned int   uInt;  /* 16 bits or more */
 typedef unsigned long  uLong; /* 32 bits or more */

src/moai-assimp/MOAIAssimpAnimation.cpp

@@ -159,50 +159,50 @@ MOAIAnimCurveBone* MOAIAssimpAnimation::GetAnimCurve ( u32 channel ) {
 
 		if ( posKey ) {
 
-			p0 = ZLVec3D ( posKey->mValue.x, posKey->mValue.y, posKey->mValue.z );
+			p0 = ZLVec3D ( (float) posKey->mValue.x, (float) posKey->mValue.y, (float) posKey->mValue.z );
 
 			if ( t == posKey->mTime ) {
 				iPos++;
 			}
 			else {
 				ZLVec3D p1 = p0;
 				const aiVectorKey& posKeyPrev = nodeAnim->mPositionKeys [ iPos > 0 ? iPos - 1 : 0 ];
-				p0 = ZLVec3D ( posKeyPrev.mValue.x, posKeyPrev.mValue.y, posKeyPrev.mValue.z );
-				p0.Lerp ( p1, ( t - posKeyPrev.mTime ) / ( posKey->mTime - posKeyPrev.mTime ));
+				p0 = ZLVec3D ((float) posKeyPrev.mValue.x, (float) posKeyPrev.mValue.y, (float) posKeyPrev.mValue.z );
+				p0.Lerp ( p1, (float) (( t - posKeyPrev.mTime ) / ( posKey->mTime - posKeyPrev.mTime )));
 			}
 		}
 
 		if ( rotKey ) {
 
-			q0 = ZLQuaternion ( rotKey->mValue.w, rotKey->mValue.x, rotKey->mValue.y, rotKey->mValue.z );
+			q0 = ZLQuaternion ((float) rotKey->mValue.w, (float) rotKey->mValue.x, (float)rotKey->mValue.y, (float) rotKey->mValue.z );
 
 			if ( t == posKey->mTime ) {
 				iRot++;
 			}
 			else {
 				ZLQuaternion q1 = q0;
 				const aiQuatKey& rotKeyPrev = nodeAnim->mRotationKeys [ iRot > 0 ? iRot - 1 : 0 ];
-				q0 = ZLQuaternion ( rotKeyPrev.mValue.w, rotKeyPrev.mValue.x, rotKeyPrev.mValue.y, rotKeyPrev.mValue.z );
-				q0.Slerp ( q0, q1, ( t - rotKeyPrev.mTime ) / ( rotKey->mTime - rotKeyPrev.mTime ));
+				q0 = ZLQuaternion ((float) rotKeyPrev.mValue.w, (float) rotKeyPrev.mValue.x, (float) rotKeyPrev.mValue.y, (float) rotKeyPrev.mValue.z );
+				q0.Slerp ( q0, q1, (float) (( t - rotKeyPrev.mTime ) / ( rotKey->mTime - rotKeyPrev.mTime )));
 			}
 		}
 
 		if ( sclKey ) {
 
-			s0 = ZLVec3D ( sclKey->mValue.x, sclKey->mValue.y, sclKey->mValue.z );
+			s0 = ZLVec3D ((float) sclKey->mValue.x, (float) sclKey->mValue.y, (float) sclKey->mValue.z );
 
 			if ( t == posKey->mTime ) {
 				iScl++;
 			}
 			else {
 				ZLVec3D s1 = s0;
 				const aiVectorKey& sclKeyPrev = nodeAnim->mScalingKeys [ iScl > 0 ? iScl - 1 : 0 ];
-				s0 = ZLVec3D ( sclKeyPrev.mValue.x, sclKeyPrev.mValue.y, sclKeyPrev.mValue.z );
-				s0.Lerp ( s1, ( t - sclKeyPrev.mTime ) / ( sclKey->mTime - sclKeyPrev.mTime ));
+				s0 = ZLVec3D ((float) sclKeyPrev.mValue.x, (float) sclKeyPrev.mValue.y, (float) sclKeyPrev.mValue.z );
+				s0.Lerp ( s1, (float) (( t - sclKeyPrev.mTime ) / ( sclKey->mTime - sclKeyPrev.mTime )));
 			}
 		}
 
-		curve->SetKey (( u32 )i, t / this->mAssimpAnimation->mTicksPerSecond, ZLInterpolate::kLinear );
+		curve->SetKey (( u32 )i, (float) ( t / this->mAssimpAnimation->mTicksPerSecond ), ZLInterpolate::kLinear );
 		curve->SetSamplePosition (( u32 )i, p0.mX, p0.mY, p0.mZ );
 		curve->SetSampleRotation (( u32 )i, q0.mV.mX, q0.mV.mY, q0.mV.mZ, q0.mS );
 		curve->SetSampleScale (( u32 )i, s0.mX, s0.mY, s0.mZ );

src/moai-assimp/MOAIAssimpCamera.cpp

@@ -158,21 +158,21 @@ int MOAIAssimpCamera::_getYawAngle ( lua_State *L ) {
 
 //----------------------------------------------------------------//
 float MOAIAssimpCamera::CalculatePitch(aiQuaternion quaternion) {
-	return asin ( 2.0f * quaternion.z * quaternion.y + 2.0f * quaternion.x * quaternion. w );
+	return (float) asin ( 2.0f * quaternion.z * quaternion.y + 2.0f * quaternion.x * quaternion. w );
 }
 
 //----------------------------------------------------------------//
 float MOAIAssimpCamera::CalculateRoll ( aiQuaternion quaternion ) {
-	float x2 = quaternion.x * quaternion.x;
-	float z2 = quaternion.z * quaternion.z;
-	return atan2 ( 2.0f * quaternion.z * quaternion.w - 2.0f * quaternion.y * quaternion.x, 1.0f- 2.0f * z2 - 2.0f * x2 );
+	float x2 = (float) quaternion.x * (float) quaternion.x;
+	float z2 = (float) quaternion.z * (float) quaternion.z;
+	return (float) atan2 ( 2.0f * quaternion.z * quaternion.w - 2.0f * quaternion.y * quaternion.x, 1.0f- 2.0f * z2 - 2.0f * x2 );
 }
 
 //----------------------------------------------------------------//
 float MOAIAssimpCamera::CalculateYaw ( aiQuaternion quaternion ) {
-	float x2 = quaternion.x * quaternion.x;
-	float y2 = quaternion.y * quaternion.y;
-	return atan2 ( 2.0f * quaternion.y * quaternion.w - 2.0f * quaternion.z * quaternion.x , 1.0f - 2.0f * x2 - 2.0f * y2 );
+	float x2 = (float) quaternion.x * (float) quaternion.x;
+	float y2 = (float) quaternion.y * (float) quaternion.y;
+	return (float) atan2 ( 2.0f * quaternion.y * quaternion.w - 2.0f * quaternion.z * quaternion.x , 1.0f - 2.0f * x2 - 2.0f * y2 );
 }
 
 //----------------------------------------------------------------//
@@ -228,8 +228,8 @@ void MOAIAssimpCamera::SetCamera ( aiCamera *assimpCamera ) {
 
 	transform.Decompose ( this->mScaling, this->mRotation, this->mPosition );
 	this->mMoaiCamera = new MOAICamera ();
-	this->mMoaiCamera->SetLoc ( this->mPosition.x , this->mPosition.y , this->mPosition.z );
-	this->mMoaiCamera->SetScl ( this->mScaling.x , this->mScaling.y , this->mScaling.z );
+	this->mMoaiCamera->SetLoc ((float) this->mPosition.x , (float) this->mPosition.y , (float) this->mPosition.z );
+	this->mMoaiCamera->SetScl ((float) this->mScaling.x , (float) this->mScaling.y , (float) this->mScaling.z );
 	this->mMoaiCamera->SetRot (
 		( float )( this->CalculatePitch ( this->mRotation) * R2D ),
 		( float )( this->CalculateYaw ( this->mRotation) * R2D ),

src/moai-assimp/MOAIAssimpMesh.cpp

@@ -490,19 +490,19 @@ u32 MOAIAssimpMesh::ReadVertices ( const MOAIVertexFormat& format, ZLStream& str
 			format.SeekVertex ( stream, base, i );
 
 			aiVector3D vertex = mesh->mVertices [ i ];
-			format.WriteCoord ( stream, 0, vertex.x, vertex.y, vertex.z, 1.0f );
+			format.WriteCoord ( stream, 0, (float) vertex.x, (float) vertex.y, (float) vertex.z, 1.0f );
 
 			if ( mesh->HasVertexColors ( 0 )) {
 				aiColor4D color = mesh->mColors [ 0 ][ i ];
-				format.WriteColor ( stream, 0, color.r, color.g, color.b, color.a );
+				format.WriteColor ( stream, 0, (float) color.r, (float) color.g, (float) color.b, (float) color.a );
 			}
 			else {
 				format.WriteColor ( stream, 0, 0xffffffff );
 			}
 
 			if ( mesh->HasTextureCoords ( 0 )) {
 				aiVector3D uvw = mesh->mTextureCoords [ 0 ][ i ];
-				format.WriteUV ( stream, 0, uvw.x, uvw.y, uvw.z );
+				format.WriteUV ( stream, 0, (float) uvw.x, (float) uvw.y, (float) uvw.z );
 			}
 
 			if ( boneBuffer ) {

src/moai-assimp/MOAIAssimpUtil.cpp

@@ -174,6 +174,7 @@ void MOAIAssimpUtil::PushNode ( lua_State* L, const aiNode* node ) {
 
 	int stackOK = lua_checkstack ( L, 4 );
 	assert ( stackOK );
+	UNUSED(stackOK);
 
 	if ( !node ) return;
 
@@ -232,7 +233,7 @@ void MOAIAssimpUtil::PushNode ( lua_State* L, const aiNode* node ) {
 					state.Push ( *( bool* )value.mData );
 					break;
 
-				case AI_INT:
+				case AI_INT32:
 					state.Push ( *( int* )value.mData );
 					break;
 
@@ -296,7 +297,7 @@ void MOAIAssimpUtil::PushTexture ( lua_State* L, aiMaterial* material, aiTexture
 	aiString path;
 	aiTextureMapping mapping;
 	uint uvindex;
-	float blend;
+	double blend;
 	aiTextureOp op;
 	aiTextureMapMode mapmode [ 3 ];
 

src/moai-box2d/MOAIBox2DDebugDraw.cpp

@@ -74,7 +74,7 @@ void MOAIBox2DDebugDraw::DrawCircle ( const b2Vec2& center, float32 radius, cons
 
 	gfxMgr.mGfxState.SetPenColor ( color.r, color.g, color.b, 1.0f );
 
-	const float32 k_segments = 16.0f;
+	const u32 k_segments = 16;
 	const float32 k_increment = 2.0f * b2_pi / k_segments;
 
 	gfxMgr.mVertexCache.BeginPrim ( ZGL_PRIM_LINE_LOOP, k_segments );
@@ -95,7 +95,7 @@ void MOAIBox2DDebugDraw::DrawSolidCircle ( const b2Vec2& center, float32 radius,
 	gfxMgr.mGfxState.SetBlendMode ( ZGL_BLEND_FACTOR_SRC_ALPHA, ZGL_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA );
 	gfxMgr.mGfxState.SetPenColor ( 0.5f * color.r, 0.5f * color.g, 0.5f * color.b, 0.5f );
 
-	const float32 k_segments = 16.0f;
+	const u32 k_segments = 16;
 	const float32 k_increment = 2.0f * b2_pi / k_segments;
 
 	gfxMgr.mVertexCache.BeginPrim ( ZGL_PRIM_TRIANGLE_FAN, k_segments );

src/moai-core/host.cpp

@@ -97,6 +97,7 @@ int _loadFuncFromBuffer ( MOAIDataBuffer& buffer, cc8* chunkname, int compressed
 
 	MOAIDataBufferScopedLock lock ( buffer, ( void** )&data, &size  );
 
+	#ifndef MOAI_WITH_LUAJIT
 	MOAILuaHeader header;
 	header.Read ( data, size );
 
@@ -114,6 +115,10 @@ int _loadFuncFromBuffer ( MOAIDataBuffer& buffer, cc8* chunkname, int compressed
 		// trim trailing nulls from non-bytecode
 		while (( size > 1 ) && ( data [ size - 1 ] == 0 )) --size;
 	}
+	#else
+		// trim trailing nulls from non-bytecode
+		while (( size > 1 ) && ( data [ size - 1 ] == 0 )) --size;
+	#endif
 
 	MOAIScopedLuaState state = MOAILuaRuntime::Get ().State ();
 

src/moai-core/moai_version.h

@@ -4,8 +4,8 @@
 	// DO NOT EVER MODIFY THIS FILE
 	// this file should *only* be touched by the build server
 
-	#define MOAI_SDK_VERSION_MAJOR			1		// int
-	#define MOAI_SDK_VERSION_MINOR			8		// int
+	#define MOAI_SDK_VERSION_MAJOR			2		// int
+	#define MOAI_SDK_VERSION_MINOR			0		// int
 	#define MOAI_SDK_VERSION_REVISION		0		// int
 
 #endif

src/moai-sim/MOAICamera.cpp

@@ -498,7 +498,7 @@ void MOAICamera::RegisterLuaClass ( MOAILuaState& state ) {
 
 	MOAIDebugLinesMgr::Get ().ReserveStyleSet < MOAICamera >( TOTAL_DEBUG_LINE_STYLES );
 
-	state.SetField ( -1, "DEBUG_DRAW_CAMERA_MASTER",			MOAIDebugLinesMgr::Pack < MOAICamera >( -1 ));
+	state.SetField ( -1, "DEBUG_DRAW_CAMERA_MASTER",			MOAIDebugLinesMgr::Pack < MOAICamera >( (u32) -1 ));
 	state.SetField ( -1, "DEBUG_DRAW_FRAME",					MOAIDebugLinesMgr::Pack < MOAICamera >( DEBUG_DRAW_FRAME ));
 	state.SetField ( -1, "DEBUG_DRAW_RETICLE",					MOAIDebugLinesMgr::Pack < MOAICamera >( DEBUG_DRAW_RETICLE ));
 

src/moai-sim/MOAICollisionPrim.cpp

@@ -56,15 +56,15 @@ void MOAICollisionPrimVisitor::Process ( MOAICollisionProp& prop0, MOAICollision
 	}
 	else {
 
-		MOAIOverlapBox shape0;
-		shape0.mShape = prop0.GetModelBounds ();
-		shape0.mBounds = shape0.mShape;
+		MOAIOverlapBox oshape0;
+		oshape0.mShape = prop0.GetModelBounds ();
+		oshape0.mBounds = oshape0.mShape;
 
-		MOAIOverlapBox shape1;
-		shape1.mShape = prop1.GetModelBounds ();
-		shape1.mBounds = shape1.mShape;
+		MOAIOverlapBox oshape1;
+		oshape1.mShape = prop1.GetModelBounds ();
+		oshape1.mBounds = oshape1.mShape;
 
-		this->Process ( shape0, shape1, t0, t1 );
+		this->Process ( oshape0, oshape1, t0, t1 );
 	}
 }
 

src/moai-sim/MOAICollisionProp.cpp

@@ -272,9 +272,9 @@ void MOAICollisionProp::Move ( ZLVec3D move, u32 detach, u32 maxSteps ) {
 			u32 nContacts = contactAccumulator.Top ();
 			u32 nPushContacts = 0;
 
-			for ( u32 i = 0; i < nContacts; ++i ) {
+			for ( u32 j = 0; j < nContacts; ++j ) {
 
-				const MOAIMoveConstraint2D& contact = contacts [ i ];
+				const MOAIMoveConstraint2D& contact = contacts [ j ];
 
 				// ignore corner contacts if they are behind the move
 				if ( contact.mType == MOAIMoveConstraint2D::CORNER ) {
@@ -411,7 +411,7 @@ void MOAICollisionProp::RegisterLuaClass ( MOAILuaState& state ) {
 
 	MOAIDebugLinesMgr::Get ().ReserveStyleSet < MOAICollisionProp >( TOTAL_DEBUG_LINE_STYLES );
 
-	state.SetField ( -1, "DEBUG_DRAW_COLLISION_PROP_MASTER",						MOAIDebugLinesMgr::Pack < MOAICollisionProp >( -1 ));
+	state.SetField ( -1, "DEBUG_DRAW_COLLISION_PROP_MASTER",						MOAIDebugLinesMgr::Pack < MOAICollisionProp >( (u32) -1 ));
 	state.SetField ( -1, "DEBUG_DRAW_COLLISION_ACTIVE_PROP_BOUNDS",					MOAIDebugLinesMgr::Pack < MOAICollisionProp >( DEBUG_DRAW_COLLISION_ACTIVE_PROP_BOUNDS ));
 	state.SetField ( -1, "DEBUG_DRAW_COLLISION_ACTIVE_OVERLAP_PROP_BOUNDS",			MOAIDebugLinesMgr::Pack < MOAICollisionProp >( DEBUG_DRAW_COLLISION_ACTIVE_OVERLAP_PROP_BOUNDS ));
 	state.SetField ( -1, "DEBUG_DRAW_COLLISION_ACTIVE_TOUCHED_PROP_BOUNDS",			MOAIDebugLinesMgr::Pack < MOAICollisionProp >( DEBUG_DRAW_COLLISION_ACTIVE_TOUCHED_PROP_BOUNDS ));
@@ -529,7 +529,7 @@ void MOAICollisionProp::MOAIDrawable_DrawDebug ( int subPrimID ) {
 
 	if ( visible ) {
 
-		MOAICollisionShape* shape = this->GetCollisionShape ();
+		shape = this->GetCollisionShape ();
 
 		if ( shape ) {
 			const ZLAffine3D& localToWorldMtx = this->GetLocalToWorldMtx ();

src/moai-sim/MOAIDeck.cpp

@@ -90,7 +90,7 @@ void MOAIDeck::Draw ( u32 idx ) {
 ZLBounds MOAIDeck::GetBounds () {
 
 	return this->GetBounds ( 0 );
-
+	/*
 	if ( this->mBoundsDirty ) {
 	
 		this->mMaxBounds = this->MOAIDeck_ComputeMaxBounds ();
@@ -103,7 +103,7 @@ ZLBounds MOAIDeck::GetBounds () {
 		//this->mMaxBounds.Grow ( bounds );
 		this->mBoundsDirty = false;
 	}
-	return this->mMaxBounds;
+	return this->mMaxBounds;*/
 }
 
 //----------------------------------------------------------------//
@@ -134,14 +134,9 @@ MOAIDeck::~MOAIDeck () {
 //----------------------------------------------------------------//
 bool MOAIDeck::Overlap ( u32 idx, const ZLVec2D& vec, u32 granularity, ZLBounds* result ) {
 
-	return this->Overlap ( idx, vec, granularity, result );
+	return this->MOAIDeck_Overlap ( idx, vec, granularity, result );
 }
 
-//----------------------------------------------------------------//
-bool MOAIDeck::Overlap ( u32 idx, const ZLVec3D& vec, u32 granularity, ZLBounds* result ) {
-
-	return this->Overlap ( idx, vec, granularity, result );
-}
 
 //----------------------------------------------------------------//
 void MOAIDeck::RegisterLuaClass ( MOAILuaState& state ) {

src/moai-sim/MOAIDeck.h

@@ -64,7 +64,6 @@ class MOAIDeck :
 							MOAIDeck						();
 							~MOAIDeck						();
 	bool					Overlap							( u32 idx, const ZLVec2D& vec, u32 granularity, ZLBounds* result = 0 );
-	bool					Overlap							( u32 idx, const ZLVec3D& vec, u32 granularity, ZLBounds* result = 0 );
 	void					RegisterLuaClass				( MOAILuaState& state );
 	void					RegisterLuaFuncs				( MOAILuaState& state );
 };

src/moai-sim/MOAIDraw.cpp

@@ -1050,7 +1050,7 @@ int MOAIDraw::_setScissorRect ( lua_State* L ) {
 	}
 	else {
 		ZLRect rect;
-		rect.Init ( 0, 0, gfxMgr.mGfxState.GetBufferWidth (), gfxMgr.mGfxState.GetBufferHeight ());
+		rect.Init ( 0.0, 0.0, (float) gfxMgr.mGfxState.GetBufferWidth (), (float) gfxMgr.mGfxState.GetBufferHeight ());
 		rect = state.GetValue < ZLRect >( 1, rect );
 		gfxMgr.mGfxState.SetScissorRect ( rect );
 	}
@@ -1085,7 +1085,7 @@ int MOAIDraw::_setViewRect ( lua_State* L ) {
 	}
 	else {
 		ZLRect rect;
-		rect.Init ( 0, 0, gfxMgr.mGfxState.GetBufferWidth (), gfxMgr.mGfxState.GetBufferHeight ());
+		rect.Init ( 0.0, 0.0, (float) gfxMgr.mGfxState.GetBufferWidth (), (float) gfxMgr.mGfxState.GetBufferHeight ());
 		rect = state.GetValue < ZLRect >( 1, rect );
 		gfxMgr.mGfxState.SetViewRect ( rect );
 	}
@@ -1210,7 +1210,6 @@ void MOAIDraw::DrawAxisGrid ( ZLVec2D loc, ZLVec2D vec, float size ) {
 //----------------------------------------------------------------//
 void MOAIDraw::DrawBezierCurve ( const ZLCubicBezier2D& bezier ) {
 
-	MOAIGfxMgr& gfxMgr = MOAIGfxMgr::Get ();
 	MOAIDrawVertexLineStripWriter2D writer;
 
 	writer.Begin ();

src/moai-sim/MOAIDrawDeck.cpp

@@ -143,7 +143,7 @@ ZLBounds MOAIDrawDeck::MOAIDeck_GetBounds ( u32 idx ) {
 
 		MOAIScopedLuaState state = MOAILuaRuntime::Get ().State ();
 
-		int top = state.GetTop ();
+	//	int top = state.GetTop ();
 
 		this->mOnBounds.PushRef ( state );
 

src/moai-sim/MOAIDrawShape.cpp

@@ -164,13 +164,13 @@ void MOAIDrawShape::DrawLine ( float x0, float y0, float z0, float x1, float y1,
 //----------------------------------------------------------------//
 void MOAIDrawShape::DrawPoint ( const ZLVec2D& loc ) {
 
-	this->DrawPoint ( loc.mX, loc.mY );
+	this->MOAIDrawShape_DrawPoint ( loc.mX, loc.mY );
 }
 
 //----------------------------------------------------------------//
 void MOAIDrawShape::DrawPoint ( float x, float y, float z ) {
 
-	this->DrawPoint ( x, y, z );
+	this->MOAIDrawShape_DrawPoint ( x, y, z );
 }
 
 //----------------------------------------------------------------//

src/moai-sim/MOAIDrawShapeImmediate.cpp

@@ -44,7 +44,7 @@ void MOAIDrawShapeImmediate::MOAIDrawShape_DrawLine ( float x0, float y0, float
 void MOAIDrawShapeImmediate::MOAIDrawShape_DrawPoint ( float x, float y, float z ) {
 
 	MOAIGfxMgr& gfxMgr = MOAIGfxMgr::Get ();
-
+	UNUSED(z);
 	gfxMgr.mVertexCache.BeginPrim ( ZGL_PRIM_POINTS, 1 );
 		gfxMgr.mVertexCache.WriteVtx ( x, y, 0.0f );
 		gfxMgr.mVertexCache.WritePenColor4b ();