Fixed physics entity transforms not being set correctly

Assets/Default asset pack/hdr/fxaa.frag

@@ -0,0 +1,153 @@
+// FXAA shader, GLSL code adapted from:
+
+// http://horde3d.org/wiki/index.php5?title=Shading_Technique_-_FXAA
+
+// Whitepaper describing the technique:
+
+// http://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf
+
+
+
+uniform sampler2D textureSampler;
+
+
+
+// The inverse of the texture dimensions along X and Y
+
+
+vec3 rgb2hsv(vec3 c)
+
+{
+
+    vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+
+    vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+
+    vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+
+
+
+    float d = q.x - min(q.w, q.y);
+
+    float e = 1.0e-10;
+
+    return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+
+}
+
+
+
+vec3 hsv2rgb(vec3 c)
+
+{
+
+    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+
+    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+
+    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+
+}
+
+
+
+void main() {
+
+  // The parameters are hardcoded for now, but could be
+
+  // made into uniforms to control fromt he program.
+
+  float FXAA_SPAN_MAX = 8.0;
+
+  float FXAA_REDUCE_MUL = 1.0/8.0;
+
+  float FXAA_REDUCE_MIN = (1.0/128.0);
+
+  vec2 texcoordOffset = vec2(0.0005, 0.0005);
+
+
+  vec3 rgbNW = texture2D(textureSampler, gl_TexCoord[0].st + (vec2(-1.0, -1.0) * texcoordOffset)).xyz;
+
+  vec3 rgbNE = texture2D(textureSampler, gl_TexCoord[0].st + (vec2(+1.0, -1.0) * texcoordOffset)).xyz;
+
+  vec3 rgbSW = texture2D(textureSampler, gl_TexCoord[0].st + (vec2(-1.0, +1.0) * texcoordOffset)).xyz;
+
+  vec3 rgbSE = texture2D(textureSampler, gl_TexCoord[0].st + (vec2(+1.0, +1.0) * texcoordOffset)).xyz;
+
+  vec3 rgbM  = texture2D(textureSampler, gl_TexCoord[0].st).xyz;
+
+
+  vec3 luma = vec3(0.299, 0.587, 0.114);
+
+  float lumaNW = dot(rgbNW, luma);
+
+  float lumaNE = dot(rgbNE, luma);
+
+  float lumaSW = dot(rgbSW, luma);
+
+  float lumaSE = dot(rgbSE, luma);
+
+  float lumaM  = dot( rgbM, luma);
+
+
+  float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
+
+  float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));
+
+
+  vec2 dir;
+
+  dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
+
+  dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));
+
+
+  float dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL), FXAA_REDUCE_MIN);
+
+ 
+
+  float rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce);
+
+
+  dir = min(vec2(FXAA_SPAN_MAX,  FXAA_SPAN_MAX), 
+
+        max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX), dir * rcpDirMin)) * texcoordOffset;
+
+
+  vec3 rgbA = (1.0/2.0) * (
+
+              texture2D(textureSampler, gl_TexCoord[0].st + dir * (1.0/3.0 - 0.5)).xyz +
+
+              texture2D(textureSampler, gl_TexCoord[0].st + dir * (2.0/3.0 - 0.5)).xyz);
+
+  vec3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * (
+
+              texture2D(textureSampler, gl_TexCoord[0].st + dir * (0.0/3.0 - 0.5)).xyz +
+
+              texture2D(textureSampler, gl_TexCoord[0].st + dir * (3.0/3.0 - 0.5)).xyz);
+
+  float lumaB = dot(rgbB, luma);
+
+
+
+  if((lumaB < lumaMin) || (lumaB > lumaMax)){
+
+    gl_FragColor.xyz=rgbA;
+
+  } else {
+
+    gl_FragColor.xyz=rgbB;
+
+  }
+
+
+
+  vec3 hsv = rgb2hsv(gl_FragColor.xyz);
+
+  hsv.y += 0.1 * (1.0 - hsv.y);
+
+  gl_FragColor = vec4(hsv2rgb(hsv), texture2D(textureSampler, gl_TexCoord[0].st).a);
+
+
+
+}

Assets/Default asset pack/hdr/hdr.mat

@@ -28,7 +28,11 @@
 		<shader type="glsl" name="ExtractBloom" screen="true">
 			<vp source="default/ScreenShader.vert"/>
 			<fp source="hdr/ExtractBloom.frag"/>
-		</shader>							
+		</shader>	
+		<shader type="glsl" name="FXAA" screen="true">
+			<vp source="default/ScreenShader.vert"/>
+			<fp source="hdr/fxaa.frag"/>
+		</shader>	
 	</shaders>
 	<materials>
 		<material name="DefaultHDR">
@@ -43,11 +47,48 @@
 			<shader name="HDRProcessShader">
 			</shader>
 		</material>	
+		<material name="HDRProcessBloomFXAA" screen="true">
+			<rendertargets type="rgba_fp16">
+				<rendertarget id="bloomtarget"  sizeMode="pixels" width="1024" height="1024"/>
+				<rendertarget id="bloomtarget2"  sizeMode="pixels" width="1024" height="1024"/>				
+				<rendertarget id="bloomtarget_final"  sizeMode="pixels" width="1024" height="1024"/>
+			</rendertargets>											
+			<shader name="ExtractBloom">
+				<targettextures>			
+					<targettexture mode="in" name="screenColorBuffer" id="bloomtarget2"/>
+					<targettexture mode="out" id="bloomtarget"/>
+				</targettextures>
+			</shader>									
+			<shader name="HDRBloomH">
+				<targettextures>
+					<targettexture mode="in" name="screenTexture" id="bloomtarget"/>				
+					<targettexture mode="out" id="bloomtarget2"/>
+				</targettextures>
+			</shader>		
+			<shader name="HDRBloomV">
+				<targettextures>
+					<targettexture mode="in" name="screenTexture" id="bloomtarget2"/>
+					<targettexture mode="out" id="bloomtarget_final"/>					
+				</targettextures>													
+			</shader>
+			<shader name="HDRProcessShaderBloom">
+				<targettextures>
+					<targettexture mode="color" name="baseTexture"/>								
+					<targettexture mode="in" name="bloomTexture" id="bloomtarget_final"/>	
+					<targettexture mode="out" id="bloomtarget"/>
+				</targettextures>													
+			</shader>
+			<shader name="FXAA">
+				<targettextures>			
+					<targettexture mode="in" name="textureSampler" id="bloomtarget"/>
+				</targettextures>
+			</shader>	
+		</material>	
 		<material name="HDRProcessBloom" screen="true">
 			<rendertargets type="rgba_fp16">
-				<rendertarget id="bloomtarget"  sizeMode="pixels" width="512" height="512"/>
-				<rendertarget id="bloomtarget2"  sizeMode="pixels" width="512" height="512"/>				
-				<rendertarget id="bloomtarget_final"  sizeMode="pixels" width="512" height="512"/>
+				<rendertarget id="bloomtarget"  sizeMode="pixels" width="1024" height="1024"/>
+				<rendertarget id="bloomtarget2"  sizeMode="pixels" width="1024" height="1024"/>				
+				<rendertarget id="bloomtarget_final"  sizeMode="pixels" width="1024" height="1024"/>
 			</rendertargets>
 			<shader name="ExtractBloom">
 				<targettextures>			

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

@@ -145,6 +145,7 @@ namespace Polycode {
 	
 			void setWalkDirection(Vector3 direction);
 			void jump();
+            void setVelocityForTime(const Vector3 &velocity, Number time);
 			
 			void warpCharacter(Vector3 position);
 			void setJumpSpeed(Number jumpSpeed);

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

@@ -138,6 +138,12 @@ PhysicsCharacter::PhysicsCharacter(Entity *entity, Number mass, Number friction,
 	
 }
 
+void PhysicsCharacter::setVelocityForTime(const Vector3 &velocity, Number time) {
+ 
+    btVector3 vel(velocity.x, velocity.y, velocity.z);
+    character->setVelocityForTimeInterval(vel, time);
+}
+
 
 void PhysicsCharacter::setWalkDirection(Vector3 direction) {
 	character->setWalkDirection(btVector3(direction.x, direction.y, direction.z));	
@@ -168,7 +174,6 @@ bool PhysicsCharacter::onGround() {
 	return character->onGround();
 }
 
-
 void PhysicsCharacter::Update() {
 	btVector3 pos = ghostObject->getWorldTransform().getOrigin();
 	entity->setPosition(pos.x(), pos.y(), pos.z());
@@ -189,12 +194,24 @@ PhysicsEntity::PhysicsEntity(Entity *entity, int type, Number mass, Number frict
 	transform.setIdentity();
     
 	Matrix4 ent_mat = entity->getConcatenatedMatrix();
-    Vector3 pos = ent_mat * Vector3(0.0, 0.0, 0.0);
-	transform.setOrigin(btVector3(pos.x,pos.y,pos.z));
     
-	Quaternion q = entity->getConcatenatedQuat();
-	transform.setRotation(btQuaternion(q.x,q.y,q.z,q.w));
-	
+    Vector3 scale = entity->getCompoundScale();
+    Matrix4 invScale;
+    
+    Matrix4 scaleMatrix;
+    scaleMatrix.m[0][0] *= 1.0/scale.x;
+    scaleMatrix.m[1][1] *= 1.0/scale.y;
+    scaleMatrix.m[2][2] *= 1.0/scale.z;
+
+    ent_mat = scaleMatrix * ent_mat;
+    
+    float fl[16];
+    for(int i=0; i < 16; i++) {
+        fl[i] = ent_mat.ml[i];
+    }
+    
+    transform.setFromOpenGLMatrix(fl);
+    
 	if(mass != 0.0f) {
 		shape->calculateLocalInertia(mass,localInertia);
 	}