Add mult-shape sprites and actors

rcbasic_build/intern_inc/switch_cases.h

@@ -513,6 +513,9 @@ rc_setSpriteColorMod( SETSPRITECOLORMOD_SPRITE,  SETSPRITECOLORMOD_COLOR )
 rc_setSpriteAlpha( SETSPRITEALPHA_SPRITE,  SETSPRITEALPHA_ALPHA )
 rc_getSpriteColorMod( GETSPRITECOLORMOD_SPRITE )
 rc_getSpriteAlpha( GETSPRITEALPHA_SPRITE )
+rc_addSpriteChild( ADDSPRITECHILD_SPRITE,  ADDSPRITECHILD_CHILD_SPRITE,  ADDSPRITECHILD_X,  ADDSPRITECHILD_Y )
+rc_removeSpriteChild( REMOVESPRITECHILD_SPRITE,  REMOVESPRITECHILD_CHILD_INDEX )
+rc_getSpriteChildIndex( GETSPRITECHILDINDEX_SPRITE,  GETSPRITECHILDINDEX_CHILD_SPRITE )
 rc_createSpriteAnimation( CREATESPRITEANIMATION_SPRITE,  CREATESPRITEANIMATION_ANIM_LENGTH,  CREATESPRITEANIMATION_SPEED )
 rc_setSpriteFrame( SETSPRITEFRAME_SPRITE,  SETSPRITEFRAME_FRAME )
 rc_getSpriteFrame( GETSPRITEFRAME_SPRITE )
@@ -736,6 +739,7 @@ rc_addActorShadow( ADDACTORSHADOW_ACTOR )
 rc_removeActorShadow( REMOVEACTORSHADOW_ACTOR )
 rc_actorExists( ACTOREXISTS_ACTOR )
 rc_createProjectorActor(  )
+rc_createCompositeActor(  )
 rc_createActorAnimation( CREATEACTORANIMATION_ACTOR,  CREATEACTORANIMATION_START_FRAME,  CREATEACTORANIMATION_END_FRAME,  CREATEACTORANIMATION_SPEED )
 rc_setActorAnimation( SETACTORANIMATION_ACTOR,  SETACTORANIMATION_ANIMATION,  SETACTORANIMATION_NUM_LOOPS )
 rc_setActorAnimationSpeed( SETACTORANIMATIONSPEED_ACTOR,  SETACTORANIMATIONSPEED_ANIMATION,  SETACTORANIMATIONSPEED_SPEED )

rcbasic_build/intern_lib/actor.bas

@@ -27,3 +27,4 @@ sub AddActorShadow( actor )
 sub RemoveActorShadow( actor )
 function ActorExists( actor )
 Function CreateProjectorActor()
+Function CreateCompositeActor()

rcbasic_build/intern_lib/sprites.bas

@@ -29,3 +29,6 @@ Sub SetSpriteColorMod(sprite, color)
 Sub SetSpriteAlpha(sprite, alpha)
 Function GetSpriteColorMod(sprite)
 Function GetSpriteAlpha(sprite)
+Function AddSpriteChild(sprite, child_sprite, x, y)
+Sub RemoveSpriteChild(sprite, child_index)
+Function GetSpriteChildIndex(sprite, child_sprite)

rcbasic_runtime/rc_base_actor.h

@@ -20,6 +20,9 @@ void setSolidProperties(int actor)
 
 void rc_setActorCollisionShape(int actor_id, int shape_type, double mass, double radius=-1.0)
 {
+    if(rc_actor[actor_id].node_type == RC_NODE_TYPE_COMPOSITE && shape_type != RC_NODE_SHAPE_TYPE_COMPOSITE)
+        return;
+
 	//std::cout << "Start ColShape" << std::endl;
 	if(rc_actor[actor_id].physics.rigid_body)
 	{
@@ -187,6 +190,22 @@ void rc_setActorCollisionShape(int actor_id, int shape_type, double mass, double
 			}
 			break;
 
+        case RC_NODE_SHAPE_TYPE_COMPOSITE:
+			if(rc_actor[actor_id].node_type == RC_NODE_TYPE_COMPOSITE)
+			{
+				rc_actor[actor_id].physics.shape_type = RC_NODE_SHAPE_TYPE_COMPOSITE;
+				ICompoundShape* shape = new ICompoundShape(rc_actor[actor_id].mesh_node, mass, false);
+
+				rc_actor[actor_id].physics.rigid_body = rc_physics3D.world->addRigidBody(shape);
+
+				setSolidProperties(actor_id);
+			}
+			else
+            {
+                std::cout << "SetActorShape Error: Composite Shapes can only be set on Composite Actors" << std::endl;
+            }
+			break;
+
 		default:
 			std::cout << "SetActorShape Error: Invalid shape_type parameter" << std::endl;
 	}
@@ -374,6 +393,60 @@ int rc_createAnimatedActor(int mesh_id)
 }
 
 
+//add mesh actor to scene
+int rc_createCompositeActor()
+{
+    int actor_id = -1;
+
+    irr::scene::ISceneNode* node;
+
+    rc_scene_node actor;
+
+    actor.node_type = RC_NODE_TYPE_COMPOSITE; //STATIC MESH NODE
+
+    node = SceneManager->addSceneNode("composite");
+
+    actor.mesh_node = node;
+
+    actor.shadow = NULL;
+    actor.transition = false;
+    actor.transition_time = 0;
+    actor.material_ref_index = -1;
+
+    if(!node)
+        return -1;
+
+    for(int i = 0; i < rc_actor.size(); i++)
+    {
+        if(!rc_actor[i].mesh_node)
+        {
+            actor_id = i;
+            break;
+        }
+    }
+
+    if(actor_id < 0)
+    {
+        actor_id = rc_actor.size();
+        rc_actor.push_back(actor);
+    }
+    else
+    {
+        rc_actor[actor_id] = actor;
+    }
+
+
+    //Actor RigidBody
+    rc_actor[actor_id].physics.shape_type = RC_NODE_SHAPE_TYPE_COMPOSITE;
+    rc_actor[actor_id].physics.rigid_body = NULL;
+    rc_actor[actor_id].physics.isSolid = false;
+
+    rc_setActorCollisionShape(actor_id, RC_NODE_SHAPE_TYPE_COMPOSITE, 1);
+
+    return actor_id;
+}
+
+
 //add mesh actor to scene
 int rc_createOctreeActor(int mesh_id)
 {
@@ -866,6 +939,24 @@ void rc_deleteActor(int actor_id)
         }
     }
 
+
+    for(int i = 0; i < rc_actor[actor_id].child_actors.size(); i++)
+    {
+        int child_id = rc_actor[actor_id].child_actors[i];
+
+        if(child_id < 0 || child_id >= rc_actor.size())
+            continue;
+
+        if(rc_actor[child_id].mesh_node == NULL)
+            continue;
+
+        rc_actor[actor_id].mesh_node->removeChild(rc_actor[child_id].mesh_node);
+        rc_deleteActor(child_id);
+    }
+
+    rc_actor[actor_id].child_actors.clear();
+
+
 	if(rc_actor[actor_id].physics.rigid_body)
         rc_physics3D.world->removeCollisionObject(rc_actor[actor_id].physics.rigid_body, false);
 
@@ -1112,6 +1203,349 @@ void rc_getActorRotation(int actor, double* x, double* y, double* z)
 	}
 }
 
+// --------------COMPOSITE STUFF-------------------
+//Function AddCompositeChild(actor, child_actor, t_matrix)
+int rc_addCompositeChild(int actor, int child_actor, int t_matrix)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return -1;
+
+    if(child_actor < 0 || child_actor >= rc_actor.size())
+        return -1;
+
+    if(t_matrix < 0 || t_matrix >= rc_matrix.size())
+        return -1;
+
+    int index = -1;
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                ICompoundShape* parent_shape = (ICompoundShape*)rc_actor[actor].physics.rigid_body->getCollisionShape();
+                ICollisionShape* child_shape = rc_actor[child_actor].physics.rigid_body->getCollisionShape();
+
+                irr::core::matrix4 irr_mat = rc_convertToIrrMatrix(t_matrix);
+
+                index = parent_shape->addChildShape(irr_mat, child_shape);
+
+                rc_actor[actor].mesh_node->addChild(rc_actor[child_actor].mesh_node);
+
+                rc_actor[actor].child_actors.push_back(child_actor);
+            }
+            break;
+    }
+
+    return index;
+}
+
+
+//Function GetCompositeChildCount(actor)
+int rc_getCompositeChildCount(int actor)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return 0;
+
+    int child_count = 0;
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                child_count = rc_actor[actor].child_actors.size();
+            }
+            break;
+    }
+
+    return child_count;
+}
+
+
+//Function GetCompositeChild(actor, child_index)
+int rc_getCompositeChild(int actor, int child_index)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return -1;
+
+    if(child_index < 0 || child_index >= rc_actor[actor].child_actors.size())
+        return -1;
+
+    int child_id = -1;
+
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                child_id = rc_actor[actor].child_actors[child_index];
+            }
+            break;
+    }
+
+    return child_id;
+}
+
+
+//Function GetCompositeChildIndex(actor, child_actor)
+int rc_getCompositeChildIndex(int actor, int child_actor)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return -1;
+
+    if(child_actor < 0 || child_actor >= rc_actor.size())
+        return -1;
+
+    int child_index = -1;
+
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                for(int i = 0; i < rc_actor[actor].child_actors.size(); i++)
+                {
+                    if(rc_actor[actor].child_actors[i] == child_actor)
+                    {
+                        child_index = i;
+                        break;
+                    }
+                }
+            }
+            break;
+    }
+
+    return child_index;
+}
+
+
+//Sub RemoveCompositeChild(actor, child_index)
+void rc_removeCompositeChild(int actor, int child_index)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return;
+
+    if(child_index < 0 || child_index >= rc_actor[actor].child_actors.size())
+        return;
+
+    int child_actor = rc_actor[actor].child_actors[child_index];
+
+    if(rc_actor[child_actor].mesh_node == NULL)
+        return;
+
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                ICompoundShape* parent_shape = (ICompoundShape*)rc_actor[actor].physics.rigid_body->getCollisionShape();
+
+                ICollisionShape* child_shape = rc_actor[child_actor].physics.rigid_body->getCollisionShape();
+
+                parent_shape->removeChildShape(child_shape);
+
+                int child_actor = rc_actor[actor].child_actors[child_index];
+
+                if(rc_actor[actor].mesh_node != NULL && rc_actor[child_actor].mesh_node != NULL)
+                    rc_actor[actor].mesh_node->removeChild(rc_actor[child_actor].mesh_node);
+
+                rc_actor[actor].child_actors.erase(child_index);
+            }
+            break;
+    }
+
+    return;
+}
+
+
+//Function GetCompositeChildTransform(actor, child_index, t_matrix)
+bool rc_getCompositeChildTransform(int actor, int child_index, int t_matrix)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return false;
+
+    if(child_index < 0 || child_index >= rc_actor[actor].child_actors.size())
+        return false;
+
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                ICompoundShape* parent_shape = (ICompoundShape*)rc_actor[actor].physics.rigid_body->getCollisionShape();
+                rc_convertFromIrrMatrix(parent_shape->getChildTransform(child_index), t_matrix);
+            }
+            break;
+    }
+
+    return true;
+}
+
+
+//Function GetCompositeAABB(actor, t_matrix, ByRef min_x, ByRef min_y, ByRef min_z, ByRef max_x, ByRef max_y, ByRef max_z)
+bool rc_getCompositeAABB(int actor, int t_matrix, double* min_x, double* min_y, double* min_z, double* max_x, double* max_y, double* max_z)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return false;
+
+    if(t_matrix < 0 || t_matrix >= rc_matrix.size())
+        return false;
+
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                ICompoundShape* parent_shape = (ICompoundShape*)rc_actor[actor].physics.rigid_body->getCollisionShape();
+                irr::core::matrix4 irr_mat;
+                irr::core::vector3df aabb_min(0.0f, 0.0f, 0.0f);
+                irr::core::vector3df aabb_max(0.0f, 0.0f, 0.0f);
+                parent_shape->getAabb(irr_mat, aabb_min, aabb_max);
+                rc_convertFromIrrMatrix(irr_mat, t_matrix);
+
+                *min_x = (double)aabb_min.X;
+                *min_y = (double)aabb_min.Y;
+                *min_z = (double)aabb_min.Z;
+
+                *max_x = (double)aabb_max.X;
+                *max_y = (double)aabb_max.Y;
+                *max_z = (double)aabb_max.Z;
+            }
+            break;
+    }
+
+    return true;
+}
+
+
+//Sub RecalculateCompositeAABB(actor)
+void rc_recalculateCompositeAABB(int actor)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return;
+
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                ICompoundShape* parent_shape = (ICompoundShape*)rc_actor[actor].physics.rigid_body->getCollisionShape();
+                parent_shape->recalculateLocalAabb();
+            }
+            break;
+    }
+
+    return;
+}
+
+
+//Sub GenerateCompositeAABBFromChildren(actor)
+void rc_generateCompositeAABBFromChildren(int actor)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return;
+
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                ICompoundShape* parent_shape = (ICompoundShape*)rc_actor[actor].physics.rigid_body->getCollisionShape();
+                parent_shape->createAabbTreeFromChildren();
+            }
+            break;
+    }
+
+    return;
+}
+
+
+//Sub CalculateCompositePrincipalTransform(actor, ByRef masses, principal_matrix, ByRef x, ByRef y, ByRef z)
+void rc_calculateCompositePrincipalTransform(int actor, double* masses, int principal_matrix, double* x, double* y, double* z)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return;
+
+    if(principal_matrix < 0 || principal_matrix >= rc_matrix.size())
+        return;
+
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                ICompoundShape* parent_shape = (ICompoundShape*)rc_actor[actor].physics.rigid_body->getCollisionShape();
+
+                irr::core::matrix4 irr_mat = rc_convertToIrrMatrix(principal_matrix);
+
+                int num_children = rc_actor[actor].child_actors.size();
+                float f_mass[num_children];
+                for(int i = 0; i < num_children; i++)
+                    f_mass[i] = (float)masses[i];
+
+                irr::core::vector3df inertia(x[0], y[0], z[0]);
+
+                parent_shape->calculatePrincipalAxisTransform(f_mass, irr_mat, inertia);
+
+                *x = inertia.X;
+                *y = inertia.Y;
+                *z = inertia.Z;
+
+                for(int i = 0; i < num_children; i++)
+                    masses[i] = f_mass[i];
+
+                rc_convertFromIrrMatrix(irr_mat, principal_matrix);
+            }
+            break;
+    }
+
+    return;
+}
+
+
+//Sub UpdateCompositeChildTransform(actor, child_index, t_matrix, recalc_flag)
+void rc_updateCompositeChildTransform(int actor, int child_index, int t_matrix, bool recalc_flag)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return;
+
+    if(child_index < 0 || child_index >= rc_actor[actor].child_actors.size())
+        return;
+
+    if(t_matrix < 0 || t_matrix >= rc_matrix.size())
+        return;
+
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                ICompoundShape* parent_shape = (ICompoundShape*)rc_actor[actor].physics.rigid_body->getCollisionShape();
+
+                irr::core::matrix4 irr_mat = rc_convertToIrrMatrix(t_matrix);
+
+                parent_shape->updateChildTransform(child_index, irr_mat, recalc_flag);
+
+                rc_convertFromIrrMatrix(irr_mat, t_matrix);
+            }
+            break;
+    }
+
+    return;
+}
+
+
+//Function GetCompositeUpdateRevision(actor)
+int rc_getCompositeUpdateRevision(int actor)
+{
+	if(actor < 0 || actor >= rc_actor.size())
+        return -1;
+
+    int update_rev = -1;
+
+    switch(rc_actor[actor].node_type)
+    {
+        case RC_NODE_TYPE_COMPOSITE:
+            {
+                ICompoundShape* parent_shape = (ICompoundShape*)rc_actor[actor].physics.rigid_body->getCollisionShape();
+                update_rev = parent_shape->getUpdateRevision();
+            }
+            break;
+    }
+
+    return update_rev;
+}
+
+
+
 //---------------PROPERTIES------------------------
 
 void rc_setActorAutoCulling(int actor, int cull_type)

rcbasic_runtime/rc_gfx_core.h

@@ -524,6 +524,7 @@ irr::core::array<rc_an8_obj> rc_an8;
 #define RC_NODE_TYPE_PARTICLE	7
 #define RC_NODE_TYPE_STMESH   	8
 #define RC_NODE_TYPE_PROJECTOR	9
+#define RC_NODE_TYPE_COMPOSITE	10
 
 
 #define RC_NODE_SHAPE_TYPE_NONE			0
@@ -535,6 +536,7 @@ irr::core::array<rc_an8_obj> rc_an8;
 #define RC_NODE_SHAPE_TYPE_CONVEXHULL	6
 #define RC_NODE_SHAPE_TYPE_TRIMESH		7
 #define RC_NODE_SHAPE_TYPE_HEIGHTFIELD	8
+#define RC_NODE_SHAPE_TYPE_COMPOSITE    9
 
 struct rc_node_physics_collision
 {
@@ -638,6 +640,8 @@ struct rc_scene_node
 	bool isPlaying;
     irr::core::array<int> deleted_animation;
     irr::core::array<rc_actor_animation_obj> animation;
+
+    irr::core::array<int> child_actors; // Only used for composite actor types
 };
 
 irr::core::array<rc_scene_node> rc_actor;

rcbasic_runtime/rc_sprite2D.h

@@ -13,8 +13,12 @@ struct rc_sprite2D_physics_obj
 {
 	b2Body* body;
 	b2Fixture* fixture;
+	b2FixtureDef fixture_def;
 	b2Shape* shape;
 
+	int fixture_offset_x;
+	int fixture_offset_y;
+
 	int shape_type;
 
 	int offset_x;
@@ -82,6 +86,9 @@ struct rc_sprite2D_obj
 	int parent_canvas = -1;
 
 	double z;
+
+	int parent_sprite;
+	irr::core::array<int> child_sprites;
 };
 
 irr::core::array<rc_sprite2D_obj> rc_sprite;

rcbasic_runtime/rc_spritelib.h

@@ -360,6 +360,8 @@ int rc_createSprite(int img_id, double w, double h)
 	else
 		rc_sprite[spr_id].image_id = -1;
 
+    rc_sprite[spr_id].parent_sprite = -1;
+
 	b2BodyDef sprBodyDef;
 	sprBodyDef.type = b2_dynamicBody;
 	sprBodyDef.position.Set(w/2, h/2);
@@ -377,6 +379,7 @@ int rc_createSprite(int img_id, double w, double h)
 	sprFixtureDef.shape = rc_sprite[spr_id].physics.shape;
 	sprFixtureDef.isSensor = true;
 	sprFixtureDef.density = 1;
+	rc_sprite[spr_id].physics.fixture_def = sprFixtureDef;
 	rc_sprite[spr_id].physics.fixture = rc_sprite[spr_id].physics.body->CreateFixture(&sprFixtureDef);
 
 	rc_sprite[spr_id].physics.body->SetTransform(b2Vec2(w/2, h/2), 0);
@@ -429,10 +432,18 @@ void rc_deleteSprite(int spr_id)
 
 	if(rc_sprite[spr_id].physics.body)
 	{
-		if(rc_sprite[spr_id].parent_canvas >= 0 && rc_sprite[spr_id].parent_canvas < rc_canvas.size())
+	    for(int i = 0; i < rc_sprite[spr_id].child_sprites.size(); i++)
+        {
+            rc_deleteSprite(rc_sprite[spr_id].child_sprites[i]);
+        }
+
+		if(rc_sprite[spr_id].parent_sprite < 0)
 		{
-			if(rc_canvas[rc_sprite[spr_id].parent_canvas].physics2D.world)
-				rc_canvas[rc_sprite[spr_id].parent_canvas].physics2D.world->DestroyBody(rc_sprite[spr_id].physics.body);
+		    if(rc_sprite[spr_id].parent_canvas >= 0 && rc_sprite[spr_id].parent_canvas < rc_canvas.size())
+            {
+                if(rc_canvas[rc_sprite[spr_id].parent_canvas].physics2D.world)
+                    rc_canvas[rc_sprite[spr_id].parent_canvas].physics2D.world->DestroyBody(rc_sprite[spr_id].physics.body);
+            }
 		}
 		rc_sprite[spr_id].physics.body = NULL;
 	}
@@ -442,6 +453,8 @@ void rc_deleteSprite(int spr_id)
 	rc_sprite[spr_id].active = false;
 	rc_sprite[spr_id].parent_canvas = -1;
 	rc_sprite[spr_id].animation.clear();
+	rc_sprite[spr_id].child_sprites.clear();
+	rc_sprite[spr_id].parent_sprite = -1;
 
 	//std::cout << "DEBUG: Clear " << spr_id << " From " << parent_canvas << std::endl;
 
@@ -461,6 +474,210 @@ void rc_deleteSprite(int spr_id)
 	}
 }
 
+
+int rc_addSpriteChild(int spr_id, int child_sprite_id, double x, double y)
+{
+	if(spr_id < 0 || spr_id >= rc_sprite.size())
+		return -1;
+
+	if(!rc_sprite[spr_id].active)
+		return -1;
+
+    if(child_sprite_id < 0 || child_sprite_id >= rc_sprite.size())
+		return -1;
+
+	if(!rc_sprite[child_sprite_id].active)
+		return -1;
+
+	b2FixtureDef childFixtureDef = rc_sprite[child_sprite_id].physics.fixture_def;
+
+	switch(childFixtureDef.shape->GetType())
+	{
+        case b2Shape::e_polygon:
+        {
+            b2PolygonShape* shape = new b2PolygonShape();
+            childFixtureDef.shape = shape;
+
+            b2Transform t(b2Vec2((float)x, (float)y), b2Rot(0));
+
+            int v_count = rc_sprite[child_sprite_id].physics.vertices.size();
+            b2Vec2 vert[v_count];
+
+            for(int i = 0; i < v_count; i++)
+            {
+                vert[i] = b2Mul(t, rc_sprite[child_sprite_id].physics.vertices[i]);
+            }
+        }
+        break;
+
+        case b2Shape::e_chain:
+        {
+            b2ChainShape* shape = new b2ChainShape();
+            childFixtureDef.shape = shape;
+
+            b2Transform t(b2Vec2((float)x, (float)y), b2Rot(0));
+
+            int v_count = rc_sprite[child_sprite_id].physics.vertices.size();
+            b2Vec2 vert[v_count];
+
+            for(int i = 0; i < v_count; i++)
+            {
+                vert[i] = b2Mul(t, rc_sprite[child_sprite_id].physics.vertices[i]);
+            }
+
+            b2Vec2 prev_vert = b2Mul(t, rc_sprite[child_sprite_id].physics.prev_vertex);
+            b2Vec2 next_vert = b2Mul(t, rc_sprite[child_sprite_id].physics.next_vertex);
+
+            shape->CreateChain(vert, v_count, prev_vert, next_vert);
+        }
+        break;
+
+        case b2Shape::e_circle:
+        {
+            b2CircleShape* shape = new b2CircleShape();
+            childFixtureDef.shape = shape;
+
+            shape->m_p.Set((float)x, (float)y);
+            shape->m_radius = rc_sprite[child_sprite_id].physics.radius;
+        }
+        break;
+	}
+
+	rc_sprite[child_sprite_id].physics.fixture = rc_sprite[spr_id].physics.body->CreateFixture(&childFixtureDef);
+
+	rc_sprite[child_sprite_id].physics.fixture_def = childFixtureDef;
+
+	if(rc_sprite[child_sprite_id].physics.body)
+	{
+		if(rc_sprite[child_sprite_id].parent_canvas >= 0 && rc_sprite[child_sprite_id].parent_canvas < rc_canvas.size())
+		{
+			if(rc_canvas[rc_sprite[child_sprite_id].parent_canvas].physics2D.world)
+				rc_canvas[rc_sprite[child_sprite_id].parent_canvas].physics2D.world->DestroyBody(rc_sprite[child_sprite_id].physics.body);
+		}
+	}
+
+	rc_sprite[child_sprite_id].physics.body = rc_sprite[spr_id].physics.body;
+
+
+	rc_sprite[child_sprite_id].isSolid = rc_sprite[spr_id].isSolid;
+
+	int index = rc_sprite[spr_id].child_sprites.size();
+	rc_sprite[spr_id].child_sprites.push_back(child_sprite_id);
+	rc_sprite[child_sprite_id].parent_sprite = spr_id;
+
+	return spr_id;
+}
+
+
+void rc_removeSpriteChild(int spr_id, int child_index)
+{
+	if(spr_id < 0 || spr_id >= rc_sprite.size())
+		return;
+
+	if(!rc_sprite[spr_id].active)
+		return;
+
+    if(child_index < 0 || child_index >= rc_sprite[spr_id].child_sprites.size())
+        return;
+
+    int child_sprite_id = rc_sprite[spr_id].child_sprites[child_index];
+
+    if(child_sprite_id < 0 || child_sprite_id >= rc_sprite.size())
+        return;
+
+    if(!rc_sprite[child_sprite_id].active)
+		return;
+
+	b2FixtureDef childFixtureDef = rc_sprite[child_sprite_id].physics.fixture_def;
+	int shape_type = childFixtureDef.shape->GetType();
+
+	int off_x = rc_sprite[child_sprite_id].physics.fixture_offset_x;
+	int off_y = rc_sprite[child_sprite_id].physics.fixture_offset_y;
+	float angle = rc_sprite[child_sprite_id].physics.body->GetAngle();
+
+	switch(shape_type)
+	{
+        case b2Shape::e_polygon:
+        {
+            b2PolygonShape* shape = new b2PolygonShape();
+
+            int v_count = rc_sprite[child_sprite_id].physics.vertices.size();
+            b2Vec2 vert[v_count];
+
+            for(int i = 0; i < v_count; i++)
+            {
+                vert[i] = rc_sprite[child_sprite_id].physics.vertices[i];
+            }
+
+            shape->Set(vert, v_count);
+            childFixtureDef.shape = shape;
+        }
+        break;
+
+        case b2Shape::e_chain:
+        {
+            b2ChainShape* shape = new b2ChainShape();
+
+            int v_count = rc_sprite[child_sprite_id].physics.vertices.size();
+            b2Vec2 vert[v_count];
+
+            b2Vec2 prev_vert = rc_sprite[child_sprite_id].physics.prev_vertex;
+            b2Vec2 next_vert = rc_sprite[child_sprite_id].physics.next_vertex;
+
+            for(int i = 0; i < v_count; i++)
+            {
+                vert[i] = rc_sprite[child_sprite_id].physics.vertices[i];
+            }
+
+            shape->CreateChain(vert, v_count, prev_vert, next_vert);
+            childFixtureDef.shape = shape;
+        }
+        break;
+
+        case b2Shape::e_circle:
+        {
+            b2CircleShape* shape = new b2CircleShape();
+            shape->m_radius = rc_sprite[child_sprite_id].physics.radius;
+
+            childFixtureDef.shape = shape;
+        }
+        break;
+	}
+
+
+	b2BodyDef sprBodyDef;
+
+	int frame_w = rc_sprite[child_sprite_id].frame_size.Width;
+	int frame_h = rc_sprite[child_sprite_id].frame_size.Height;
+
+	float body_x = rc_sprite[child_sprite_id].physics.body->GetPosition().x;
+	float body_y = rc_sprite[child_sprite_id].physics.body->GetPosition().y;
+
+	int x = body_x + rc_sprite[child_sprite_id].physics.fixture_offset_x;
+	int y = body_y + rc_sprite[child_sprite_id].physics.fixture_offset_y;
+
+	rc_sprite[spr_id].physics.body->DestroyFixture(rc_sprite[child_sprite_id].physics.fixture);
+
+
+	sprBodyDef.type = b2_dynamicBody;
+	sprBodyDef.position.Set(x, y);
+	sprBodyDef.angle = angle;
+	sprBodyDef.userData.pointer = child_sprite_id;
+	rc_sprite[child_sprite_id].physics.body = rc_canvas[rc_active_canvas].physics2D.world->CreateBody(&sprBodyDef);
+
+	rc_sprite[child_sprite_id].isSolid = rc_sprite[spr_id].isSolid;
+	childFixtureDef.isSensor = !rc_sprite[child_sprite_id].isSolid;
+
+	rc_sprite[child_sprite_id].physics.shape = (b2Shape*)childFixtureDef.shape;
+	rc_sprite[child_sprite_id].physics.fixture_def = childFixtureDef;
+	rc_sprite[child_sprite_id].physics.fixture = rc_sprite[child_sprite_id].physics.body->CreateFixture(&childFixtureDef);
+
+	rc_sprite[child_sprite_id].parent_sprite = -1;
+
+	rc_sprite[spr_id].child_sprites.erase(child_index);
+}
+
+
 void rc_setSpriteSource(int spr_id, int img_id)
 {
 	if(spr_id < 0 || spr_id >= rc_sprite.size())
@@ -635,6 +852,8 @@ void rc_setSpriteCollisionShape(int spr_id, int sprite_shape)
 		}
 		break;
 	}
+
+	rc_sprite[spr_id].physics.fixture_def = sprFixtureDef;
 }
 
 int rc_getSpriteCollisionShape(int spr_id)
@@ -678,6 +897,8 @@ void rc_setSpriteRadius(int spr_id, double radius)
 		sprFixtureDef.density = density;
 		rc_sprite[spr_id].physics.fixture = rc_sprite[spr_id].physics.body->CreateFixture(&sprFixtureDef);
 
+		rc_sprite[spr_id].physics.fixture_def = sprFixtureDef;
+
 		//NOTE: Changing the radius doesn't move its position so a new transform is not necessary
 	}
 }
@@ -755,6 +976,8 @@ void rc_setSpriteBox(int spr_id, int w, int h)
 		//rc_setSpritePosition(spr_id, bx, by);
 		//std::cout << "Box At: " << bx << ", " << by << std::endl;
 		rc_sprite[spr_id].physics.body->SetTransform(b2Vec2(bx + off_x, by + off_y), rc_sprite[spr_id].physics.body->GetAngle());
+
+		rc_sprite[spr_id].physics.fixture_def = sprFixtureDef;
 	}
 }
 
@@ -856,6 +1079,8 @@ void rc_setSpriteChain(int spr_id, double* vx, double* vy, int v_count, double p
 		//rc_setSpritePosition(spr_id, bx, by);
 		//std::cout << "Box At: " << bx << ", " << by << std::endl;
 		rc_sprite[spr_id].physics.body->SetTransform(b2Vec2(bx + off_x, by + off_y), rc_sprite[spr_id].physics.body->GetAngle());
+
+		rc_sprite[spr_id].physics.fixture_def = sprFixtureDef;
 	}
 }
 
@@ -932,6 +1157,8 @@ void rc_setSpriteChainLoop(int spr_id, double* vx, double* vy, int v_count)
 		//rc_setSpritePosition(spr_id, bx, by);
 		//std::cout << "Box At: " << bx << ", " << by << std::endl;
 		rc_sprite[spr_id].physics.body->SetTransform(b2Vec2(bx + off_x, by + off_y), rc_sprite[spr_id].physics.body->GetAngle());
+
+		rc_sprite[spr_id].physics.fixture_def = sprFixtureDef;
 	}
 }
 
@@ -1010,6 +1237,8 @@ void rc_setSpritePolygon(int spr_id, double* vx, double* vy, int v_count)
 		//rc_setSpritePosition(spr_id, bx, by);
 		//std::cout << "Box At: " << bx << ", " << by << std::endl;
 		rc_sprite[spr_id].physics.body->SetTransform(b2Vec2(bx + off_x, by + off_y), rc_sprite[spr_id].physics.body->GetAngle());
+
+		rc_sprite[spr_id].physics.fixture_def = sprFixtureDef;
 	}
 }
 
@@ -1943,6 +2172,12 @@ void drawSprites(int canvas_id)
 			y = (int)(sprite->physics.body->GetWorldCenter().y - sprite->physics.offset_y - offset_y);
 		}
 
+		if(rc_sprite[spr_id].parent_sprite >= 0 && rc_sprite[spr_id].parent_sprite < rc_sprite.size())
+        {
+            x += rc_sprite[spr_id].physics.fixture_offset_x;
+            y += rc_sprite[spr_id].physics.fixture_offset_y;
+        }
+
 		int frame_offset_x =  sprite->physics.user_offset_x;
 		int frame_offset_y =  sprite->physics.user_offset_y;
 
@@ -2057,7 +2292,15 @@ void drawSprites(int canvas_id)
 
 		scale.set(sprite->scale.X, sprite->scale.Y);
 
-		rotationPoint.set(x + (src_size.Width/2)*scale.X - sprite->physics.user_offset_x, y + (src_size.Height/2)*scale.Y - sprite->physics.user_offset_y); //TODO: need to account for offset once that is implemented
+		if(rc_sprite[spr_id].parent_sprite >= 0 && rc_sprite[spr_id].parent_sprite < rc_sprite.size())
+        {
+            rotationPoint.set(x + (src_size.Width/2)*scale.X - sprite->physics.fixture_offset_x, y + (src_size.Height/2)*scale.Y - sprite->physics.fixture_offset_y);
+        }
+        else
+		{
+		    rotationPoint.set(x + (src_size.Width/2)*scale.X - sprite->physics.user_offset_x, y + (src_size.Height/2)*scale.Y - sprite->physics.user_offset_y); //TODO: need to account for offset once that is implemented
+		}
+
 		rotation = -1 * (sprite->physics.body->GetAngle() * RAD_TO_DEG); //convert Box2D radians to degrees
 
 		color.set(sprite->alpha,

rcbasic_runtime/rcbasic_runtime.cbp

@@ -57,6 +57,7 @@
 		<Unit filename="../../irrBullet/include/irrBulletCollisionShape.h" />
 		<Unit filename="../../irrBullet/include/irrBulletCommon.h" />
 		<Unit filename="../../irrBullet/include/irrBulletCompileConfig.h" />
+		<Unit filename="../../irrBullet/include/irrBulletCompoundShape.h" />
 		<Unit filename="../../irrBullet/include/irrBulletConeShape.h" />
 		<Unit filename="../../irrBullet/include/irrBulletConvexHullShape.h" />
 		<Unit filename="../../irrBullet/include/irrBulletCylinderShape.h" />
@@ -82,6 +83,7 @@
 		<Unit filename="../../irrBullet/src/irrBulletCollisionObjectAffectorAttract.cpp" />
 		<Unit filename="../../irrBullet/src/irrBulletCollisionObjectAffectorDelete.cpp" />
 		<Unit filename="../../irrBullet/src/irrBulletCollisionShape.cpp" />
+		<Unit filename="../../irrBullet/src/irrBulletCompoundShape.cpp" />
 		<Unit filename="../../irrBullet/src/irrBulletConeShape.cpp" />
 		<Unit filename="../../irrBullet/src/irrBulletConvexHullShape.cpp" />
 		<Unit filename="../../irrBullet/src/irrBulletCylinderShape.cpp" />

rcbasic_runtime/rcbasic_runtime.depend

@@ -1,5 +1,5 @@
 # depslib dependency file v1.0
-1764140917 source:/home/n00b/Projects/RCBASIC4/rcbasic_runtime/main.cpp
+1769580220 source:/home/n00b/Projects/RCBASIC4/rcbasic_runtime/main.cpp
 	"rc_os_defines.h"
 	<emscripten.h>
 	<sys/param.h>
@@ -37,7 +37,7 @@
 1763959134 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_os_defines.h
 	<TargetConditionals.h>
 
-1764140917 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_defines.h
+1769580609 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_defines.h
 
 1764140917 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_stdlib.h
 	"rc_os_defines.h"
@@ -1249,7 +1249,7 @@
 1734372058 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/RealisticWater.h
 	<irrlicht.h>
 
-1769130613 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_gfx.h
+1769579622 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_gfx.h
 	"SDL.h"
 	<SDL2/SDL.h>
 	<irrlicht.h>
@@ -1275,7 +1275,7 @@
 	"rc_post_fx.h"
 	<irrtheora.h>
 
-1769129955 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_gfx_core.h
+1771041726 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_gfx_core.h
 	"SDL.h"
 	"btBulletDynamicsCommon.h"
 	"BulletSoftBody/btSoftRigidDynamicsWorld.h"
@@ -1310,7 +1310,7 @@
 	<irrlicht.h>
 	<iostream>
 
-1758412944 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_sprite2D.h
+1771199261 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_sprite2D.h
 	<irrlicht.h>
 	<box2d/box2d.h>
 
@@ -1584,7 +1584,7 @@
 	"LinearMath/btAlignedAllocator.h"
 	"LinearMath/btTransformUtil.h"
 
-1760243468 /home/n00b/Projects/irrBullet/include/irrBullet.h
+1771044021 /home/n00b/Projects/irrBullet/include/irrBullet.h
 	"irrBulletCompileConfig.h"
 	<btBulletDynamicsCommon.h>
 	<btBulletCollisionCommon.h>
@@ -1599,6 +1599,7 @@
 	"irrBulletGImpactMeshShape.h"
 	"irrBulletBvhTriangleMeshShape.h"
 	"irrBulletConvexHullShape.h"
+	"irrBulletCompoundShape.h"
 	"irrBulletMotionState.h"
 	"irrBulletRayCastVehicle.h"
 	"irrBulletCollisionObjectAffector.h"
@@ -2074,7 +2075,7 @@
 	<IAttributes.h>
 	<vector>
 
-1760243468 /home/n00b/Projects/irrBullet/include/irrBulletCollisionShape.h
+1770929897 /home/n00b/Projects/irrBullet/include/irrBulletCollisionShape.h
 	<BulletCollision/CollisionShapes/btCollisionShape.h>
 	<vector3d.h>
 	<irrTypes.h>
@@ -2280,7 +2281,7 @@
 	"rc_gfx_core.h"
 	<irrtheora.h>
 
-1764140917 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_func130_cases.h
+1769580609 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_func130_cases.h
 
 1760243468 source:/home/n00b/Projects/irrBullet/src/irrBullet.cpp
 	"irrBullet.h"
@@ -2502,7 +2503,7 @@
 	<SDL.h>
 	<SDL2/SDL.h>
 
-1758412946 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_spritelib.h
+1771231655 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_spritelib.h
 	"SDL.h"
 	<SDL2/SDL.h>
 	"rc_sprite2D.h"
@@ -2532,7 +2533,7 @@
 1758412944 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_physics3D_base.h
 	"rc_gfx_core.h"
 
-1769134196 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_base_actor.h
+1771135335 /home/n00b/Projects/RCBASIC4/rcbasic_runtime/rc_base_actor.h
 	"ProjectiveTextures.h"
 	"rc_matrix.h"
 
@@ -2758,3 +2759,13 @@
 	<cstdlib>
 	"rc_gfx_core.h"
 
+1771135300 /home/n00b/Projects/irrBullet/include/irrBulletCompoundShape.h
+	"irrBulletCollisionShape.h"
+	<vector>
+
+1771135300 source:/home/n00b/Projects/irrBullet/src/irrBulletCompoundShape.cpp
+	<ISceneNode.h>
+	"btBulletDynamicsCommon.h"
+	"btBulletCollisionCommon.h"
+	"irrBulletCompoundShape.h"
+