Fixing bugs & Work on physics

include/anki/gl/GlQueue.h

@@ -94,7 +94,7 @@ private:
 	AllocAlignedCallback m_allocCb;
 	void* m_allocCbUserData;
 
-	Array<GlCommandBufferHandle, 32> m_queue; ///< Command queue
+	Array<GlCommandBufferHandle, 128> m_queue; ///< Command queue
 	U64 m_tail; ///< Tail of queue
 	U64 m_head; ///< Head of queue. Points to the end
 	U8 m_renderingThreadSignal; ///< Signal to the thread

include/anki/physics/PhysicsBody.h

@@ -47,11 +47,17 @@ private:
 	Transform m_trf = Transform::getIdentity();
 	Bool8 m_updated = true;
 
-	// Newton callback.
+	/// Newton callback.
 	static void onTransform(
 		const NewtonBody* const body, 
 		const dFloat* const matrix, 
 		int threadIndex);
+
+	/// Newton callback
+	static void applyGravityForce(
+		const NewtonBody* body, 
+		dFloat timestep, 
+		int threadIndex);
 };
 /// @}
 

include/anki/scene/Camera.h

@@ -19,8 +19,8 @@ namespace anki {
 /// Camera SceneNode interface class
 class Camera: public SceneNode
 {
-	friend class MoveFeedbackComponent;
-	friend class FrustumFeedbackComponent;
+	friend class CameraMoveFeedbackComponent;
+	friend class CameraFrustumFeedbackComponent;
 
 public:
 	/// @note Don't EVER change the order

include/anki/scene/Light.h

@@ -8,6 +8,7 @@
 
 #include "anki/scene/SceneNode.h"
 #include "anki/scene/Forward.h"
+#include "anki/scene/LightComponent.h"
 #include "anki/resource/Resource.h"
 #include "anki/resource/TextureResource.h"
 #include "anki/Collision.h"
@@ -17,148 +18,6 @@ namespace anki {
 /// @addtogroup scene
 /// @{
 
-/// Light component. It's a dummy component used to identify lights
-class LightComponent: public SceneComponent
-{
-public:
-	enum class LightType: U8
-	{
-		POINT,
-		SPOT,
-		COUNT
- 	};
-
-	LightComponent(SceneNode* node, LightType type);
-
-	LightType getLightType() const
-	{
-		return m_type;
-	}
-
-	const Vec4& getDiffuseColor() const
-	{
-		return m_diffColor;
-	}
-
-	void setDiffuseColor(const Vec4& x)
-	{
-		m_diffColor = x;
-	}
-
-	const Vec4& getSpecularColor() const
-	{
-		return m_specColor;
-	}
-
-	void setSpecularColor(const Vec4& x)
-	{
-		m_specColor = x;
-	}
-
-	void setRadius(F32 x)
-	{
-		m_radius = x;
-		m_dirty = true;
-	}
-
-	F32 getRadius() const
-	{
-		return m_radius;
-	}
-
-	void setDistance(F32 x)
-	{
-		m_distance = x;
-		m_dirty = true;
-	}
-
-	F32 getDistance() const
-	{
-		return m_distance;
-	}
-
-	void setInnerAngle(F32 ang)
-	{
-		m_innerAngleCos = cos(ang / 2.0);
-		m_innerAngle = ang;
-		m_dirty = true;
-	}
-
-	F32 getInnerAngleCos() const
-	{
-		return m_innerAngleCos;
-	}
-
-	F32 getInnerAngle() const
-	{
-		return m_innerAngle;
-	}
-
-	void setOuterAngle(F32 ang)
-	{
-		m_outerAngleCos = cos(ang / 2.0);
-		m_outerAngle = ang;
-		m_dirty = true;
-	}
-
-	F32 getOuterAngle() const
-	{
-		return m_outerAngle;
-	}
-
-	F32 getOuterAngleCos() const
-	{
-		return m_outerAngleCos;
-	}
-
-	Bool getShadowEnabled() const
-	{
-		return m_shadow;
-	}
-
-	void setShadowEnabled(const Bool x)
-	{
-		m_shadow = x;
-	}
-
-	U getShadowMapIndex() const
-	{
-		return static_cast<U>(m_shadowMapIndex);
-	}
-
-	void setShadowMapIndex(const U i)
-	{
-		ANKI_ASSERT(i < 0xFF);
-		m_shadowMapIndex = static_cast<U8>(i);
-	}
-
-	ANKI_USE_RESULT Error update(SceneNode&, F32, F32, Bool& updated) override;
-
-	static constexpr Type getClassType()
-	{
-		return Type::LIGHT;
-	}
-
-private:
-	LightType m_type;
-	Vec4 m_diffColor = Vec4(0.5);
-	Vec4 m_specColor = Vec4(0.5);
-	union
-	{
-		F32 m_radius;
-		F32 m_distance;
-	};
-	F32 m_innerAngleCos;
-	F32 m_outerAngleCos;
-	F32 m_outerAngle;
-	F32 m_innerAngle;
-
-	Bool8 m_shadow = false;
-	U8 m_shadowMapIndex = 0xFF; ///< Used by the renderer
-
-	Bool8 m_dirty = true;
-};
-
 /// Light scene node. It can be spot or point.
 class Light: public SceneNode
 {

include/anki/scene/LightComponent.h

@@ -0,0 +1,163 @@
+// Copyright (C) 2014, Panagiotis Christopoulos Charitos.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#ifndef ANKI_SCENE_LIGHT_COMPONENT_H
+#define ANKI_SCENE_LIGHT_COMPONENT_H
+
+#include "anki/scene/SceneComponent.h"
+#include "anki/Math.h"
+
+namespace anki {
+
+/// @addtogroup scene
+/// @{
+
+/// Light component. It's a dummy component used to identify lights
+class LightComponent: public SceneComponent
+{
+public:
+	enum class LightType: U8
+	{
+		POINT,
+		SPOT,
+		COUNT
+ 	};
+
+	LightComponent(SceneNode* node, LightType type);
+
+	LightType getLightType() const
+	{
+		return m_type;
+	}
+
+	const Vec4& getDiffuseColor() const
+	{
+		return m_diffColor;
+	}
+
+	void setDiffuseColor(const Vec4& x)
+	{
+		m_diffColor = x;
+	}
+
+	const Vec4& getSpecularColor() const
+	{
+		return m_specColor;
+	}
+
+	void setSpecularColor(const Vec4& x)
+	{
+		m_specColor = x;
+	}
+
+	void setRadius(F32 x)
+	{
+		m_radius = x;
+		m_dirty = true;
+	}
+
+	F32 getRadius() const
+	{
+		return m_radius;
+	}
+
+	void setDistance(F32 x)
+	{
+		m_distance = x;
+		m_dirty = true;
+	}
+
+	F32 getDistance() const
+	{
+		return m_distance;
+	}
+
+	void setInnerAngle(F32 ang)
+	{
+		m_innerAngleCos = cos(ang / 2.0);
+		m_innerAngle = ang;
+		m_dirty = true;
+	}
+
+	F32 getInnerAngleCos() const
+	{
+		return m_innerAngleCos;
+	}
+
+	F32 getInnerAngle() const
+	{
+		return m_innerAngle;
+	}
+
+	void setOuterAngle(F32 ang)
+	{
+		m_outerAngleCos = cos(ang / 2.0);
+		m_outerAngle = ang;
+		m_dirty = true;
+	}
+
+	F32 getOuterAngle() const
+	{
+		return m_outerAngle;
+	}
+
+	F32 getOuterAngleCos() const
+	{
+		return m_outerAngleCos;
+	}
+
+	Bool getShadowEnabled() const
+	{
+		return m_shadow;
+	}
+
+	void setShadowEnabled(const Bool x)
+	{
+		m_shadow = x;
+	}
+
+	U getShadowMapIndex() const
+	{
+		return static_cast<U>(m_shadowMapIndex);
+	}
+
+	void setShadowMapIndex(const U i)
+	{
+		ANKI_ASSERT(i < 0xFF);
+		m_shadowMapIndex = static_cast<U8>(i);
+	}
+
+	ANKI_USE_RESULT Error update(SceneNode&, F32, F32, Bool& updated) override;
+
+	static constexpr Type getClassType()
+	{
+		return Type::LIGHT;
+	}
+
+private:
+	LightType m_type;
+	Vec4 m_diffColor = Vec4(0.5);
+	Vec4 m_specColor = Vec4(0.5);
+	union
+	{
+		F32 m_radius;
+		F32 m_distance;
+	};
+	F32 m_innerAngleCos;
+	F32 m_outerAngleCos;
+	F32 m_outerAngle;
+	F32 m_innerAngle;
+
+	Bool8 m_shadow = false;
+	U8 m_shadowMapIndex = 0xFF; ///< Used by the renderer
+
+	Bool8 m_dirty = true;
+};
+/// @}
+
+} // end namespace anki
+
+#endif
+

include/anki/scene/ModelNode.h

@@ -56,7 +56,7 @@ private:
 class ModelNode: public SceneNode
 {
 	friend class ModelPatchNode;
-	friend class ModelNodeFeedbackComponent;
+	friend class ModelMoveFeedbackComponent;
 
 public:
 	ModelNode(SceneGraph* scene);

shaders/MsCommonFrag.glsl

@@ -102,6 +102,35 @@ vec3 readNormalFromTexture(in vec3 normal, in vec4 tangent,
 }
 #endif
 
+// Do normal mapping by combining normal maps
+#if PASS == COLOR
+#	define combineNormalFromTextures_DEFINED
+vec3 combineNormalFromTextures(in vec3 normal, in vec4 tangent,
+	in sampler2D map, in sampler2D map2, in highp vec2 texCoords,
+	in float texCoords2Scale)
+{
+#	if LOD > 0
+	return normalize(normal);
+#	else
+	// First read the textures
+	vec3 nAtTangentspace0 = 
+		normalize((texture(map, texCoords).rgb - 0.5) * 2.0);
+	vec3 nAtTangentspace1 = 
+		normalize((texture(map2, texCoords * texCoords2Scale).rgb - 0.5) * 2.0);
+
+	vec3 nAtTangentspace = (nAtTangentspace0 + nAtTangentspace1) / 2.0;
+
+	vec3 n = normal; // Assume that getNormal() is called
+	vec3 t = normalize(tangent.xyz);
+	vec3 b = cross(n, t) * tangent.w;
+
+	mat3 tbnMat = mat3(t, b, n);
+
+	return tbnMat * nAtTangentspace;
+#	endif
+}
+#endif
+
 // Do environment mapping
 #if PASS == COLOR
 #	define readEnvironmentColor_DEFINED

src/physics/PhysicsBody.cpp

@@ -30,6 +30,7 @@ Error PhysicsBody::create(const Initializer& init)
 
 	// Create
 	Mat4 trf = Mat4(init.m_startTrf);
+	trf.transpose();
 	if(init.m_kinematic)
 	{
 		// TODO
@@ -57,8 +58,7 @@ Error PhysicsBody::create(const Initializer& init)
 	// Set gravity
 	if(init.m_gravity)
 	{
-		Vec3 gravityForce(0.0, -9.8f * init.m_mass, 0.0);
-		NewtonBodySetForce(m_body, &gravityForce[0]);
+		NewtonBodySetForceAndTorqueCallback(m_body, applyGravityForce);
 	}
 
 	// Activate
@@ -82,7 +82,28 @@ void PhysicsBody::onTransform(
 
 	Mat4 trf;
 	memcpy(&trf, matrix, sizeof(Mat4));
+	trf.transpose();
+	trf(3, 3) = 0.0;
 	self->m_trf = Transform(trf);
+	self->m_updated = true;
+}
+
+//==============================================================================
+void PhysicsBody::applyGravityForce(
+	const NewtonBody* body, 
+	dFloat timestep, 
+	int threadIndex)
+{
+	dFloat Ixx;
+	dFloat Iyy;
+	dFloat Izz;
+	dFloat mass;
+
+	NewtonBodyGetMassMatrix(body, &mass, &Ixx, &Iyy, &Izz);
+
+	const F32 GRAVITY = -9.8;
+	Vec4 force(0.0, mass * GRAVITY, 0.0, 0.0);
+	NewtonBodySetForce(body, &force[0]);
 }
 
 } // end namespace anki

src/physics/PhysicsWorld.cpp

@@ -60,6 +60,9 @@ Error PhysicsWorld::create(AllocAlignedCallback allocCb, void* allocCbData)
 		return ErrorCode::FUNCTION_FAILED;
 	}
 
+	// Set the simplified solver mode (faster but less accurate)
+	NewtonSetSolverModel(m_world, 1);
+
 	return err;
 }
 

src/scene/Camera.cpp

@@ -8,14 +8,14 @@
 namespace anki {
 
 //==============================================================================
-// MoveFeedbackComponent                                                       =
+// CameraMoveFeedbackComponent                                                 =
 //==============================================================================
 
 /// Feedback component.
-class MoveFeedbackComponent: public SceneComponent
+class CameraMoveFeedbackComponent: public SceneComponent
 {
 public:
-	MoveFeedbackComponent(Camera* node)
+	CameraMoveFeedbackComponent(Camera* node)
 	:	SceneComponent(SceneComponent::Type::NONE, node)
 	{}
 
@@ -36,14 +36,14 @@ public:
 };
 
 //==============================================================================
-// FrustumFeedbackComponent                                                    =
+// CameraFrustumFeedbackComponent                                              =
 //==============================================================================
 
 /// Feedback component.
-class FrustumFeedbackComponent: public SceneComponent
+class CameraFrustumFeedbackComponent: public SceneComponent
 {
 public:
-	FrustumFeedbackComponent(Camera* node)
+	CameraFrustumFeedbackComponent(Camera* node)
 	:	SceneComponent(SceneComponent::Type::NONE, node)
 	{}
 
@@ -89,7 +89,7 @@ Error Camera::create(const CString& name, Frustum* frustum)
 	if(err) return err;
 
 	// Feedback component
-	comp = getSceneAllocator().newInstance<MoveFeedbackComponent>(this);
+	comp = getSceneAllocator().newInstance<CameraMoveFeedbackComponent>(this);
 	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
 
 	err = addComponent(comp, true);
@@ -103,7 +103,8 @@ Error Camera::create(const CString& name, Frustum* frustum)
 	if(err) return err;
 
 	// Feedback component #2
-	comp = getSceneAllocator().newInstance<FrustumFeedbackComponent>(this);
+	comp = 
+		getSceneAllocator().newInstance<CameraFrustumFeedbackComponent>(this);
 	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
 
 	err = addComponent(comp, true);

src/scene/Light.cpp

@@ -11,32 +11,6 @@
 
 namespace anki {
 
-//==============================================================================
-// LightComponent                                                              =
-//==============================================================================
-
-//==============================================================================
-LightComponent::LightComponent(SceneNode* node, LightType type)
-:	SceneComponent(Type::LIGHT, node),
-	m_type(type)
-{
-	setInnerAngle(toRad(45.0));
-	setOuterAngle(toRad(30.0));
-	m_radius = 1.0;
-}
-
-//==============================================================================
-Error LightComponent::update(SceneNode&, F32, F32, Bool& updated)
-{
-	if(m_dirty)
-	{
-		updated = true;
-		m_dirty = false;
-	}
-
-	return ErrorCode::NONE;
-}
-
 //==============================================================================
 // LightFeedbackComponent                                                      =
 //==============================================================================

src/scene/LightComponent.cpp

@@ -0,0 +1,33 @@
+// Copyright (C) 2014, Panagiotis Christopoulos Charitos.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#include "anki/scene/LightComponent.h"
+
+namespace anki {
+
+//==============================================================================
+LightComponent::LightComponent(SceneNode* node, LightType type)
+:	SceneComponent(Type::LIGHT, node),
+	m_type(type)
+{
+	setInnerAngle(toRad(45.0));
+	setOuterAngle(toRad(30.0));
+	m_radius = 1.0;
+}
+
+//==============================================================================
+Error LightComponent::update(SceneNode&, F32, F32, Bool& updated)
+{
+	if(m_dirty)
+	{
+		updated = true;
+		m_dirty = false;
+	}
+
+	return ErrorCode::NONE;
+}
+
+} // end namespace anki
+

src/scene/ModelNode.cpp

@@ -230,14 +230,14 @@ Error ModelPatchNode::updateInstanceSpatials(
 }
 
 //==============================================================================
-// ModelNodeFeedbackComponent                                                  =
+// ModelMoveFeedbackComponent                                                  =
 //==============================================================================
 
 /// Feedback component.
-class ModelNodeFeedbackComponent: public SceneComponent
+class ModelMoveFeedbackComponent: public SceneComponent
 {
 public:
-	ModelNodeFeedbackComponent(SceneNode* node)
+	ModelMoveFeedbackComponent(SceneNode* node)
 	:	SceneComponent(SceneComponent::Type::NONE, node)
 	{}
 
@@ -257,6 +257,35 @@ public:
 	}
 };
 
+//==============================================================================
+// ModelBodyFeedbackComponent                                                  =
+//==============================================================================
+
+/// Body feedback component.
+class ModelBodyFeedbackComponent: public SceneComponent
+{
+public:
+	ModelBodyFeedbackComponent(SceneNode* node)
+	:	SceneComponent(SceneComponent::Type::NONE, node)
+	{}
+
+	ANKI_USE_RESULT Error update(
+		SceneNode& node, F32, F32, Bool& updated)
+	{
+		updated = false;
+
+		BodyComponent& bodyc = node.getComponent<BodyComponent>();
+
+		if(bodyc.getTimestamp() == getGlobTimestamp())
+		{
+			MoveComponent& move = node.getComponent<MoveComponent>();
+			move.setLocalTransform(bodyc.getTransform());
+		}
+
+		return ErrorCode::NONE;
+	}
+};
+
 //==============================================================================
 // ModelNode                                                                   =
 //==============================================================================
@@ -310,22 +339,6 @@ Error ModelNode::create(const CString& name, const CString& modelFname)
 		if(err) return err;
 	}
 
-	// Move component
-	comp = getSceneAllocator().newInstance<MoveComponent>(this);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-	err = addComponent(comp);
-	if(err) return err;
-	comp->setAutomaticCleanup(true);
-
-	// Feedback component
-	comp = getSceneAllocator().newInstance<ModelNodeFeedbackComponent>(this);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-	err = addComponent(comp);
-	if(err) return err;
-	comp->setAutomaticCleanup(true);
-
 	// Load rigid body
 	const PhysicsCollisionShape* shape = m_model->getPhysicsCollisionShape();
 	if(shape != nullptr)
@@ -338,16 +351,36 @@ Error ModelNode::create(const CString& name, const CString& modelFname)
 			getSceneGraph()._getPhysicsWorld().newBody<PhysicsBody>(init);
 		if(m_body == nullptr) return ErrorCode::OUT_OF_MEMORY;
 
-		BodyComponent* bodyComp = 
-			getSceneAllocator().newInstance<BodyComponent>(this, m_body);
-		if(bodyComp == nullptr) return ErrorCode::OUT_OF_MEMORY;
+		// Body component
+		comp = getSceneAllocator().newInstance<BodyComponent>(this, m_body);
+		if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
 
-		err = addComponent(bodyComp);
+		err = addComponent(comp, true);
 		if(err) return err;
 
-		bodyComp->setAutomaticCleanup(true);
+		// Feedback component
+		comp = 
+			getSceneAllocator().newInstance<ModelBodyFeedbackComponent>(this);
+		if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
+
+		err = addComponent(comp, true);
+		if(err) return err;
 	}
 
+	// Move component
+	comp = getSceneAllocator().newInstance<MoveComponent>(this);
+	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
+
+	err = addComponent(comp, true);
+	if(err) return err;
+
+	// Feedback component
+	comp = getSceneAllocator().newInstance<ModelMoveFeedbackComponent>(this);
+	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
+
+	err = addComponent(comp, true);
+	if(err) return err;
+
 	return err;
 }
 

src/scene/SceneNode.cpp

@@ -23,6 +23,18 @@ Error SceneNode::create(const CString& name)
 SceneNode::~SceneNode()
 {
 	auto alloc = getSceneAllocator();
+	
+	auto it = m_components.begin();
+	auto end = m_components.begin() + m_componentsCount;
+	for(; it != end; ++it)
+	{
+		SceneComponent* comp = *it;
+		if(comp->getAutomaticCleanup())
+		{
+			alloc.deleteInstance(comp);
+		}
+	}
+
 	Base::destroy(alloc);
 	m_name.destroy(alloc);
 	m_components.destroy(alloc);

src/util/Thread.cpp

@@ -119,7 +119,9 @@ Threadpool::Threadpool(U32 threadsCount)
 	m_threadsCount = threadsCount;
 	ANKI_ASSERT(m_threadsCount <= MAX_THREADS && m_threadsCount > 0);
 
-#if !ANKI_DISABLE_THREADPOOL_THREADING
+#if ANKI_DISABLE_THREADPOOL_THREADING
+	ANKI_LOGW("Threadpool works in synchronous mode");
+#else
 	m_threads = reinterpret_cast<detail::ThreadpoolThread*>(
 		malloc(sizeof(detail::ThreadpoolThread) * m_threadsCount));
 

testapp/Main.cpp

@@ -54,7 +54,7 @@ Error init()
 	MainRenderer& renderer = app->getMainRenderer();
 	ResourceManager& resources = app->getResourceManager();
 
-	scene.setAmbientColor(Vec4(0.1, 0.05, 0.05, 0.0) * 1.0);
+	scene.setAmbientColor(Vec4(0.1, 0.05, 0.05, 0.0) * 3.0);
 
 	if(getenv("PROFILE"))
 	{
@@ -219,10 +219,10 @@ Error init()
 	}
 #endif
 
-#if 0
+#if 1
 	// horse
 	err = scene.newSceneNode<ModelNode>("horse", horse, 
-		"models/horse/horse.ankimdl");
+		"models/crate0/crate0.ankimdl");
 	if(err) return err;
 	horse->getComponent<MoveComponent>().setLocalTransform(
 		Transform(Vec4(-2, 0, 0, 0.0), Mat3x4::getIdentity(), 0.7));
@@ -253,7 +253,7 @@ Error init()
 		move->setLocalOrigin(Vec4(0.0, 1.4, 0.6, 0.0));
 	}
 
-#if 1
+#if 0
 	{
 		ScriptResourcePointer script;
 
@@ -556,8 +556,8 @@ Error initSubsystems(int argc, char* argv[])
 
 	//config.set("maxTextureSize", 256);
 
-	config.set("fullscreenDesktopResolution", true);
-	config.set("debugContext", true);
+	config.set("fullscreenDesktopResolution", false);
+	config.set("debugContext", false);
 
 	app = new App;
 	err = app->create(config, allocAligned, nullptr);