Started adding 3d physics constraints, messing around with gaussian blur, fixed ScreenLine bug, added compound shape support for 3d physics, fixed warning from the mingw pull request

Core/Contents/Include/PolyImage.h

@@ -184,6 +184,14 @@ namespace Polycode {
 			void fastBlurVert(int blurSize);
 			void fastBlurHor(int blurSize);
 			
+			/**
+			* Blurs the image using gaussian blur
+			* @param radius Radius of the blur
+			* @param deviation Standard deviation of the gaussian distribution
+			*/															
+			void gaussianBlur(float radius, float deviation);
+			float* createKernel(float radius, float deviation);
+			
 			// What are these??? I wrote them way too long ago.
 			void darken(Number amt, bool color, bool alpha);
 			void lighten(Number amt, bool color, bool alpha);

Core/Contents/Include/PolySceneEntity.h

@@ -48,6 +48,8 @@ namespace Polycode {
 			*/
 			bool castShadows;
 			
+			int collisionShapeType;	
+			
 		protected:
 
 	};

Core/Contents/Source/PolyImage.cpp

@@ -288,6 +288,160 @@ void Image::lighten(Number amt, bool color, bool alpha) {
 	}
 }
 
+float* Image::createKernel(float radius, float deviation) {
+	int size = 2 * (int)radius + 1;
+	float* kernel = (float*)malloc(sizeof(float) * (size+1));
+	float radiusf = fabs(radius) + 1.0f;
+
+	if(deviation == 0.0f) deviation = sqrtf(
+			-(radiusf * radiusf) / (2.0f * logf(1.0f / 255.0f))
+	);
+
+	kernel[0] = size;
+
+	float value = -radius;
+	float sum   = 0.0f;
+	int i;
+
+	for(i = 0; i < size; i++) {
+			kernel[1 + i] =
+					1.0f / (2.506628275f * deviation) *
+					expf(-((value * value) / (2.0f * (deviation * deviation))));
+
+			sum   += kernel[1 + i];
+			value += 1.0f;
+	}
+
+	for(i = 0; i < size; i++) {
+		kernel[1 + i] /= sum;
+	}
+	return kernel;
+}
+
+void Image::gaussianBlur(float radius, float deviation) {
+
+	char *newData = (char*)malloc(width*height*pixelSize);
+	
+	char *horzBlur;
+	char *vertBlur;
+
+	
+	horzBlur = (char*)malloc(sizeof(float)*pixelSize*width*height);
+	vertBlur = (char*)malloc(sizeof(float)*pixelSize*width*height);
+
+	float *kernel = createKernel(radius, deviation);
+	
+	int i, iY, iX;
+
+        // Horizontal pass.
+        for(iY = 0; iY < height; iY++) {
+                for(iX = 0; iX < width; iX++) {
+						float val[4];
+						memset(val, 0, sizeof(float) * 4);
+												
+                        int offset = ((int)kernel[0]) / -2;
+
+                        for(i = 0; i < ((int)kernel[0]); i++) {
+                                int x = iX + offset;
+
+                                if(x < 0 || x >= width) { offset++; continue; }
+
+                                float kernip1 = kernel[i + 1];
+								
+								if(imageType == IMAGE_FP16) {
+									float *dataPtr = (float*)&imageData[(width * pixelSize * iY) + (pixelSize * x)];
+									for(int c=0; c < 4; c++) {
+										val[c] += kernip1 * dataPtr[c];
+									}				
+									
+								} else {
+									char *dataPtr = &imageData[(width * pixelSize * iY) + (pixelSize * x)];
+									for(int c=0; c < pixelSize; c++) {
+										val[c] += kernip1 * ((float)dataPtr[c]);
+									}				
+								}
+								
+                                offset++;
+                        }										
+
+						if(imageType == IMAGE_FP16) {
+							int baseOffset = (width * 4 * iY) + (4 * iX);
+							for(int c=0; c < 4; c++) {
+								float *f_horzBlur = (float*)horzBlur;
+								f_horzBlur[baseOffset+c] = val[c];
+							}				
+						} else {
+							int baseOffset = (width * pixelSize * iY) + (pixelSize * iX);
+							for(int c=0; c < pixelSize; c++) {	
+								if(val[c] > 255.0) {
+									val[c] = 255.0;
+								}
+								horzBlur[baseOffset+c] = (char)val[c];
+							}				
+						}
+                }
+        }
+
+	// Vertical pass.
+        for(iY = 0; iY < height; iY++) {
+                for(iX = 0; iX < width; iX++) {
+						float val[4];	
+						memset(val, 0, sizeof(float) * 4);					
+                        int offset = ((int)kernel[0]) / -2;
+
+                        for(i = 0; i < ((int)kernel[0]); i++) {
+                                int y = iY + offset;
+
+                                if(y < 0 || y >= height) {
+                                        offset++;
+                                        continue;
+                                }
+
+                                float kernip1 = kernel[i + 1];
+								if(imageType == IMAGE_FP16) {
+									float *dataPtr = (float*)&horzBlur[(width * pixelSize * y) + (pixelSize * iX)];
+									for(int c=0; c < 4; c++) {
+										val[c] += kernip1 * dataPtr[c];
+									}				
+									
+								} else {
+									char *dataPtr = &horzBlur[(width * pixelSize * y) + (pixelSize * iX)];
+									for(int c=0; c < pixelSize; c++) {
+										val[c] += kernip1 * ((float)dataPtr[c]);
+									}				
+								}
+                                offset++;
+                        }
+						
+						if(imageType == IMAGE_FP16) {
+							int baseOffset = (width * 4 * iY) + (4 * iX);
+							for(int c=0; c < 4; c++) {
+								float *f_vertBlur = (float*)vertBlur;
+								f_vertBlur[baseOffset+c] = val[c];
+							}				
+						} else {
+							int baseOffset = (width * pixelSize * iY) + (pixelSize * iX);
+							for(int c=0; c < pixelSize; c++) {
+								if(val[c] > 255.0) {
+									val[c] = 255.0;
+								}							
+								vertBlur[baseOffset+c] = (char)val[c];
+							}				
+						}
+                }
+        }
+
+
+	memcpy(newData, vertBlur, height * width * pixelSize);
+
+	free(horzBlur);
+	free(vertBlur);
+	free(kernel);
+	
+	free(imageData);
+	imageData = newData;
+}
+
 void Image::fastBlurHor(int blurSize) {
 	if(blurSize == 0)
 		return;

Core/Contents/Source/PolyScreenLine.cpp

@@ -36,6 +36,7 @@ ScreenLine::ScreenLine(Vector2* start, Vector2* end) : ScreenMesh(Mesh::LINE_MES
 	startVertex->y = start->y;
 	endVertex->x = end->x;
 	endVertex->y = end->y;
+	lineWidth = 1.0f;
 	mesh->arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;	
 }
 

IDE/Contents/Source/PolycodeScreenEditor.cpp

@@ -61,7 +61,8 @@ PolycodeScreenEditor::PolycodeScreenEditor() : PolycodeEditor(true){
 	baseEntity->addEventListener(this, InputEvent::EVENT_MOUSEUP_OUTSIDE);
 	baseEntity->addEventListener(this, InputEvent::EVENT_MOUSEMOVE);
 	baseEntity->addEventListener(this, InputEvent::EVENT_MOUSEDOWN);
-					
+	baseEntity->processInputEvents = true;
+									
 	screenTransform = new UIBox("screenTransform.png", 16,16,16,16, 100,100);
 	screenTransform->visible = false;
 	addChild(screenTransform);
@@ -139,21 +140,23 @@ void PolycodeScreenEditor::handleEvent(Event *event) {
 			case InputEvent::EVENT_MOUSEUP:
 			case InputEvent::EVENT_MOUSEUP_OUTSIDE:			
 				isDraggingEntity = false;	
-				isScalingEntity = false;		
+				isScalingEntity = false;	
+				if(selectedEntity) 					
+					selectedEntity->stopDrag();
 			break;
 			case InputEvent::EVENT_MOUSEMOVE:
 			{
 				if(isDraggingEntity) {
-					selectedEntity->setPosition(inputEvent->mousePosition.x-baseEntity->getPosition2D().x - dragOffset.x, inputEvent->mousePosition.y-baseEntity->getPosition2D().y  - dragOffset.y);
-					syncTransformToSelected();
+					if(selectedEntity) 
+						syncTransformToSelected();
 				} else if(isScalingEntity) {
-//					Number newScale = Vector2(selectedEntity->getPosition2D().x + baseEntity->getPosition2D().x + dragOffset.x, selectedEntity->getPosition2D().y + baseEntity->getPosition2D().y + dragOffset.y).distance(inputEvent->mousePosition);
-
+/*
 					Vector2 scaleVector = Vector2(selectedEntity->getPosition2D().x + baseEntity->getPosition2D().x, selectedEntity->getPosition2D().y + baseEntity->getPosition2D().y) - inputEvent->mousePosition;
 					
 					scaleVector.x =	scaleVector.x / selectedEntity->getWidth() * 2.0;
 					scaleVector.y =	scaleVector.y / selectedEntity->getHeight() * 2.0;					
 					selectedEntity->setScale(scaleVector.x, scaleVector.y, 0);
+					*/
 					syncTransformToSelected();
 				}
 			}
@@ -165,18 +168,17 @@ void PolycodeScreenEditor::handleEvent(Event *event) {
 	for(int i=0; i < baseEntity->getNumChildren(); i++) {
 		ScreenEntity* childEntity = (ScreenEntity*) baseEntity->getChildAtIndex(i);
 		if(event->getDispatcher() == childEntity) {		
-			screenTransform->visible = true;
-			dragOffset.x = inputEvent->getMousePosition().x - childEntity->getPosition2D().x;
-			dragOffset.y = inputEvent->getMousePosition().y - childEntity->getPosition2D().y;						
+			screenTransform->visible = true;					
 			
 			selectedEntity = childEntity;
 			entityColorBox->setBoxColor(selectedEntity->color);
 			syncTransformToSelected();
 			
 			Number cornerSize = 12;
-			if(dragOffset.x < -(selectedEntity->getWidth()/2.0) + cornerSize && dragOffset.y <  -(selectedEntity->getHeight()/2.0) +  cornerSize) {
+			if(false) {
 				isScalingEntity = true;
 			} else {
+				selectedEntity->startDrag(inputEvent->getMousePosition().x, inputEvent->getMousePosition().y);
 				isDraggingEntity = true;						
 			}
 			

Modules/Contents/3DPhysics/Include/PolyCollisionSceneEntity.h

@@ -41,7 +41,7 @@ namespace Polycode {
 			/**
 			* Main constructor.
 			*/ 
-			CollisionSceneEntity(SceneEntity *entity, int type);
+			CollisionSceneEntity(SceneEntity *entity, int type, bool compoundChildren = false);
 			virtual ~CollisionSceneEntity();
 			
 			/** @name Collision scene entity

Modules/Contents/3DPhysics/Include/PolyPhysicsScene.h

@@ -29,6 +29,8 @@ class btDiscreteDynamicsWorld;
 class btDbvtBroadphase;
 class btSequentialImpulseConstraintSolver;
 class btGhostPairCallback;
+class btTypedConstraint;
+class btHingeConstraint;
 
 namespace Polycode {
 
@@ -54,6 +56,15 @@ namespace Polycode {
 			Vector3 worldNormalOnB;				
 	};
 
+	class _PolyExport PhysicsHingeConstraint  {
+		public:
+		
+			void setLimits(Number minLimit, Number maxLimit);
+			Number getAngle();
+			
+			btHingeConstraint *btConstraint;
+	};
+
 	/**
 	* A scene subclass that simulates physics for its children.
 	*/
@@ -81,19 +92,24 @@ namespace Polycode {
 		void removePhysicsChild(SceneEntity *entity);
 		PhysicsSceneEntity *getPhysicsEntityBySceneEntity(SceneEntity *entity);
 		
-		PhysicsSceneEntity *addPhysicsChild(SceneEntity *newEntity, int type=0, Number mass = 0.0f, Number friction=1, Number restitution=0, int group=1);		
-		PhysicsSceneEntity *trackPhysicsChild(SceneEntity *newEntity, int type=0, Number mass = 0.0f, Number friction=1, Number restitution=0, int group=1);		
+		PhysicsSceneEntity *addPhysicsChild(SceneEntity *newEntity, int type=0, Number mass = 0.0f, Number friction=1, Number restitution=0, int group=1, bool compoundChildren = false);		
+		PhysicsSceneEntity *trackPhysicsChild(SceneEntity *newEntity, int type=0, Number mass = 0.0f, Number friction=1, Number restitution=0, int group=1, bool compoundChildren = false);		
 		
 		PhysicsCharacter *addCharacterChild(SceneEntity *newEntity, Number mass, Number friction, Number stepSize, int group  = 1);
 		void removeCharacterChild(PhysicsCharacter *character);
 		
-		
+		PhysicsHingeConstraint *createHingeConstraint(SceneEntity *entity, Vector3 pivot, Vector3 axis, Number minLimit, Number maxLimit);
+
+		PhysicsHingeConstraint *createHingeJoint(SceneEntity *entity1, SceneEntity *entity2, Vector3 pivot1, Vector3 axis1, Vector3 pivot2, Vector3 axis2, Number minLimit, Number maxLimit);
+				
 		void setVelocity(SceneEntity *entity, Vector3 velocity);
 		void warpEntity(SceneEntity *entity, Vector3 position, bool resetRotation = false);
 		
 		PhysicsVehicle *addVehicleChild(SceneEntity *newEntity, Number mass, Number friction, int group  = 1);
 		
 		void setGravity(Vector3 gravity);
+		
+		void wakeUp(SceneEntity *entity);
 			//@}
 			// ----------------------------------------------------------------------------------------------------------------
 

Modules/Contents/3DPhysics/Include/PolyPhysicsSceneEntity.h

@@ -37,7 +37,7 @@ namespace Polycode {
 	*/
 	class _PolyExport PhysicsSceneEntity : public CollisionSceneEntity {
 	public:
-		PhysicsSceneEntity(SceneEntity *entity, int type, Number mass, Number friction, Number restitution);
+		PhysicsSceneEntity(SceneEntity *entity, int type, Number mass, Number friction, Number restitution, bool compoundChildren = false);
 		virtual ~PhysicsSceneEntity();
 		virtual void Update();
 				

Modules/Contents/3DPhysics/Source/PolyCollisionSceneEntity.cpp

@@ -30,7 +30,7 @@ THE SOFTWARE.
 
 using namespace Polycode;
 
-CollisionSceneEntity::CollisionSceneEntity(SceneEntity *entity, int type) {
+CollisionSceneEntity::CollisionSceneEntity(SceneEntity *entity, int type, bool compoundChildren) {
 	sceneEntity = entity;
 	shape = NULL;
 	
@@ -43,10 +43,34 @@ CollisionSceneEntity::CollisionSceneEntity(SceneEntity *entity, int type) {
 	basisA.setIdentity();
 	
 	collisionObject = new btCollisionObject();
-	collisionObject->getWorldTransform().setBasis(basisA);
+	collisionObject->getWorldTransform().setBasis(basisA);	
 	
+	if(compoundChildren) {
+		 btCompoundShape* compoundShape = new btCompoundShape();
+		 
+		 for(int i=0; i < entity->getNumChildren(); i++) {
+			SceneEntity *child = (SceneEntity*)entity->getChildAtIndex(i);
+			btCollisionShape *childShape = createCollisionShape(child, child->collisionShapeType);
+			btTransform transform;
+			
+			child->rebuildTransformMatrix();
 
-	shape = createCollisionShape(entity, type);;
+			btScalar mat[16];		
+			Matrix4 ent_mat = child->getTransformMatrix();
+	
+			for(int i=0; i < 16; i++) {
+				mat[i] = ent_mat.ml[i];
+			}			
+			
+			transform.setFromOpenGLMatrix(mat);
+			compoundShape->addChildShape(transform, childShape);			
+		 }	
+		 
+		 shape = compoundShape;
+	} else {
+		shape = createCollisionShape(entity, type);	
+	}
+	
 	if(shape) {
 		collisionObject->setCollisionShape(shape);
 	}	

Modules/Contents/3DPhysics/Source/PolyPhysicsScene.cpp

@@ -277,6 +277,60 @@ void PhysicsScene::removeEntity(SceneEntity *entity) {
 	}
 }
 
+void PhysicsHingeConstraint::setLimits(Number minLimit, Number maxLimit) {
+	btConstraint->setLimit(minLimit, maxLimit);
+}
+
+Number PhysicsHingeConstraint::getAngle() {
+	return btConstraint->getHingeAngle();
+}
+
+PhysicsHingeConstraint * PhysicsScene::createHingeConstraint(SceneEntity *entity, Vector3 pivot, Vector3 axis, Number minLimit, Number maxLimit) {
+	PhysicsSceneEntity *pEnt = getPhysicsEntityBySceneEntity(entity);
+	if(!pEnt) {
+		return NULL;
+	}
+	
+	PhysicsHingeConstraint *constraint = new PhysicsHingeConstraint();	
+	btVector3 btPivot = btVector3(pivot.x, pivot.y, pivot.z);
+	btVector3 btAxis = btVector3(axis.x, axis.y, axis.z);
+	
+	btHingeConstraint *hingeConstraint = new btHingeConstraint( *pEnt->rigidBody, btPivot, btAxis );
+	hingeConstraint->setLimit(minLimit, maxLimit);
+	physicsWorld->addConstraint(hingeConstraint);
+	
+	constraint->btConstraint = hingeConstraint;
+	
+	return constraint;
+}
+
+PhysicsHingeConstraint *PhysicsScene::createHingeJoint(SceneEntity *entity1, SceneEntity *entity2, Vector3 pivot1, Vector3 axis1, Vector3 pivot2, Vector3 axis2, Number minLimit, Number maxLimit) {
+	
+	PhysicsSceneEntity *pEnt1 = getPhysicsEntityBySceneEntity(entity1);
+	PhysicsSceneEntity *pEnt2 = getPhysicsEntityBySceneEntity(entity2);
+		
+	if(!pEnt1 || !pEnt2) {
+		return NULL;
+	}
+	
+	PhysicsHingeConstraint *constraint = new PhysicsHingeConstraint();	
+	btVector3 btPivot1 = btVector3(pivot1.x, pivot1.y, pivot1.z);
+	btVector3 btAxis1 = btVector3(axis1.x, axis1.y, axis1.z);
+
+	btVector3 btPivot2 = btVector3(pivot2.x, pivot2.y, pivot2.z);
+	btVector3 btAxis2 = btVector3(axis2.x, axis2.y, axis2.z);
+
+	btHingeConstraint *hingeConstraint = new btHingeConstraint(*pEnt1->rigidBody, *pEnt2->rigidBody, btPivot1, btPivot2, btAxis1, btAxis2 );
+	hingeConstraint->setLimit(minLimit, maxLimit);
+	physicsWorld->addConstraint(hingeConstraint);
+	
+	constraint->btConstraint = hingeConstraint;
+	
+	return constraint;	
+	
+}
+
+
 PhysicsSceneEntity *PhysicsScene::getPhysicsEntityBySceneEntity(SceneEntity *entity) {
 	PhysicsSceneEntity *retEntity = NULL;
 	for(int i=0; i < physicsChildren.size(); i++) {
@@ -287,8 +341,16 @@ PhysicsSceneEntity *PhysicsScene::getPhysicsEntityBySceneEntity(SceneEntity *ent
 	return retEntity;
 }
 
-PhysicsSceneEntity *PhysicsScene::trackPhysicsChild(SceneEntity *newEntity, int type, Number mass, Number friction, Number restitution, int group) {
-	PhysicsSceneEntity *newPhysicsEntity = new PhysicsSceneEntity(newEntity, type, mass, friction,restitution);
+void PhysicsScene::wakeUp(SceneEntity *entity) {
+	PhysicsSceneEntity *pEnt = getPhysicsEntityBySceneEntity(entity);
+	if(!pEnt) {
+		return;
+	}
+	pEnt->rigidBody->setActivationState(DISABLE_DEACTIVATION);
+}
+
+PhysicsSceneEntity *PhysicsScene::trackPhysicsChild(SceneEntity *newEntity, int type, Number mass, Number friction, Number restitution, int group, bool compoundChildren) {
+	PhysicsSceneEntity *newPhysicsEntity = new PhysicsSceneEntity(newEntity, type, mass, friction,restitution, compoundChildren);
 	physicsWorld->addRigidBody(newPhysicsEntity->rigidBody, group,  btBroadphaseProxy::AllFilter); //btBroadphaseProxy::StaticFilter|btBroadphaseProxy::DefaultFilter);	
 //	world->addCollisionObject(newPhysicsEntity->collisionObject, group);	
 	//newPhysicsEntity->rigidBody->setActivationState(ISLAND_SLEEPING);	
@@ -297,7 +359,7 @@ PhysicsSceneEntity *PhysicsScene::trackPhysicsChild(SceneEntity *newEntity, int
 	return newPhysicsEntity;	
 }
 
-PhysicsSceneEntity *PhysicsScene::addPhysicsChild(SceneEntity *newEntity, int type, Number mass, Number friction, Number restitution, int group) {
+PhysicsSceneEntity *PhysicsScene::addPhysicsChild(SceneEntity *newEntity, int type, Number mass, Number friction, Number restitution, int group, bool compoundChildren) {
 	addEntity(newEntity);	
-	return trackPhysicsChild(newEntity, type, mass, friction, restitution, group);	
+	return trackPhysicsChild(newEntity, type, mass, friction, restitution, group, compoundChildren);	
 }

Modules/Contents/3DPhysics/Source/PolyPhysicsSceneEntity.cpp

@@ -181,7 +181,7 @@ PhysicsCharacter::~PhysicsCharacter() {
 	delete ghostObject;	
 }
 
-PhysicsSceneEntity::PhysicsSceneEntity(SceneEntity *entity, int type, Number mass, Number friction, Number restitution) : CollisionSceneEntity(entity, type) {
+PhysicsSceneEntity::PhysicsSceneEntity(SceneEntity *entity, int type, Number mass, Number friction, Number restitution, bool compoundChildren) : CollisionSceneEntity(entity, type, compoundChildren) {
 
 	this->mass = mass;
 	btVector3 localInertia(0,0,0);

Player/Contents/CMakeLists.txt

@@ -283,4 +283,4 @@ ELSE(MSVC OR MINGW)
     INSTALL(FILES "${Polycode_SOURCE_DIR}/Assets/Default\ asset\ pack/hdr.pak" DESTINATION Player)
     INSTALL(FILES "${Polycode_SOURCE_DIR}/Assets/SamplePolyapp/main.polyapp" DESTINATION Player)
     INSTALL(FILES "${Polycode_SOURCE_DIR}/Bindings/Contents/LUA/API/api.pak" DESTINATION Player)
-ENDIF(MSVC)
+ENDIF(MSVC OR MINGW)