assets/shaders/compositor-fragment.glsl

@@ -10,13 +10,11 @@ layout (binding = 1) uniform sampler2D light;
 
 void main() {
   	// Texturing
-	vec4 diffuseTexel = texture2D(albedo, vTexCoords);
+	vec4 albedoTexel = texture2D(albedo, vTexCoords);
-	vec4 lightTexel   = texture2D(light, vTexCoords);
+	vec4 lightTexel  = texture2D(light, vTexCoords);
 
 	// Final color
-    outColor = diffuseTexel * (lightTexel);
+    outColor = albedoTexel * (lightTexel);
-//    outColor = diffuseTexel;// * (lightTexel);
+    outColor = albedoTexel;// * (lightTexel);
-	outColor.a = diffuseTexel.a;
+	outColor.a = albedoTexel.a;
-	
-//	outColor = lightTexel;
 }

assets/shaders/point-light-fragment.glsl

@@ -55,12 +55,7 @@ void main()
 {    
     // Lighting calc
     vec3 a = vec3(0.0);
-    
+    vec3 ds = pointLightADS(texture(albedoMap, vertexTexCoords), 
-//    vec3 ds = pointLightADS(texture(albedoMap, vertexTexCoords), 
-//                            texture(viewSpacePositionMap, vertexTexCoords).xyz, 
-//                            texture(normalMap, vertexTexCoords).xyz);
-
-    vec3 ds = pointLightADS(vec4(1,1,1,1), 
                             texture(viewSpacePositionMap, vertexTexCoords).xyz, 
                             texture(normalMap, vertexTexCoords).xyz);
 

src/JamSpookGame.cpp

@@ -12,6 +12,8 @@ namespace JamSpook {
 JamSpookGame::JamSpookGame():
         ecos::core::Game()
 {
+
+
     Log::write(LogLevel::info, "Game - Constructor");
     setGameState(ecos::core::GameState::Launching);
 
@@ -29,9 +31,8 @@ JamSpookGame::JamSpookGame():
     addSystem(assetSystem);
 
     // Create window
-    // Resolution (256x224 scaled to whatever)
     Log::write(LogLevel::info, "Game - Constructor - Creating window");
-    mWindow = make_shared<Window>("Spooky Game", 480, 272, Window::WindowMode::window);
+    mWindow = make_shared<Window>("BouncyBalls", 1024, 1024, Window::WindowMode::window);
     mWindow->hide();
 
     // Create renderer
@@ -41,15 +42,11 @@ JamSpookGame::JamSpookGame():
     addSystem(make_shared<PhysicsSystem>());
 
     // Add physics related asset loaders
-    assetSystem->addLoader(make_shared<CollisionShapeLoader>(assetPath),       "CollisionShapeLoader");
+    assetSystem->addLoader(make_shared<CollisionShapeLoader>(assetPath), "CollisionShapeLoader");
-    assetSystem->addLoader(make_shared<StaticCollisionShapeLoader>(assetPath), "StaticCollisionShapeLoader");
 
     // Create animation system
     addSystem(make_shared<AnimationSystem>());
 
-    // Create camera system
-    addSystem(make_shared<CameraSystem>());
-
     // Create interaction system
     addSystem(make_shared<InteractionSystem>());
     shared_ptr<InteractionSystem> interactionSystem = dynamic_pointer_cast<InteractionSystem>(findSystem(IDCache::get("InteractionSystem")));
@@ -67,11 +64,11 @@ JamSpookGame::JamSpookGame():
     addSystem(make_shared<DevILSystem>());
 
     // Add graphics related asset loaders
-    assetSystem->addLoader(make_shared<MeshLoader>(assetPath),          "MeshLoader");
+    assetSystem->addLoader(make_shared<MeshLoader>(assetPath), "MeshLoader");
-    assetSystem->addLoader(make_shared<ShaderLoader>(assetPath),        "ShaderLoader");
+    assetSystem->addLoader(make_shared<ShaderLoader>(assetPath), "ShaderLoader");
     assetSystem->addLoader(make_shared<ShaderProgramLoader>(assetPath), "ShaderProgramLoader");
-    assetSystem->addLoader(make_shared<TextureFileLoader>(assetPath),   "TextureFileLoader");
+    assetSystem->addLoader(make_shared<TextureFileLoader>(assetPath), "TextureFileLoader");
-    assetSystem->addLoader(make_shared<TextureBlankLoader>(assetPath),  "TextureBlankLoader");
+    assetSystem->addLoader(make_shared<TextureBlankLoader>(assetPath), "TextureBlankLoader");
 
     // Add render layer compositor shader
     ShaderProgramFactory* shaderProgramFactory = new ShaderProgramFactory(assetSystem);
@@ -99,7 +96,7 @@ JamSpookGame::JamSpookGame():
     // 16.0f/9.0f,
 
 //    mCamera = camFactory->createPerspective(vec3(1.0f, 100.0f, 0.0f),
-    mCamera = camFactory->createPerspective(vec3(0.0f, 0.0f, 0.0f),   // The follow cam implementation will change the position during runtime.
+    mCamera = camFactory->createPerspective(vec3(-60.0f, 40.0f, 60.0f),
                                             vec3(0.0f, -20.0f, 0.0f),
                                             vec3(0.0f, 1.0f, 0.0f),
                                             90.0f/2,
@@ -107,30 +104,15 @@ JamSpookGame::JamSpookGame():
                                             0.1f,
                                             1000.0f);
 
-
-    mCameraBackground = camFactory->createOrthogonal(translate(mat4(1), vec3(0, 0, -1)),
-                                                     vec4(10,10,10,10),
-                                                     0.1f,
-                                                     20);
-
-    mCameraEndScene = camFactory->createPerspective(vec3(1010.0f, 4.0f, 1010.0f),
-                                                    vec3(0.0f, 0.0f, 0.0f),
-                                                    vec3(0.0f, 1.0f, 0.0f),
-                                                    90.0f/2,
-                                                    static_cast<float>(mWindow->getWindowSize().x)/mWindow->getWindowSize().y,
-                                                    0.1f,
-                                                    100.0f);
-
     delete camFactory;
     mRenderer->setCamera(mCamera);
-//    mRenderer->setCamera(mCameraEndScene);
 
     // Create render layers
     // Add render layers
     RenderLayerFactory* renderLayerFactory = new RenderLayerFactory(assetSystem, mWindow);
-    graphicsSystem->addRenderLayer(renderLayerFactory->createRenderLayer("rl-bg", mCameraBackground));
+//    graphicsSystem->addRenderLayer(renderLayerFactory->createRenderLayer("rl-bg", mCamera));
     graphicsSystem->addRenderLayer(renderLayerFactory->createRenderLayer("rl-game", mCamera));
-//    graphicsSystem->addRenderLayer(renderLayerFactory->createRenderLayer("rl-gui", mCamera));
+    graphicsSystem->addRenderLayer(renderLayerFactory->createRenderLayer("rl-gui", mCamera));
     delete renderLayerFactory;
 
     // Add Sound system
@@ -190,43 +172,75 @@ void JamSpookGame::set()
 
     // Prepare scene
     shared_ptr<GraphicsSystem> graphicsSystem = dynamic_pointer_cast<GraphicsSystem>(findSystem(IDCache::get("GraphicsSystem")));
-    shared_ptr<RenderLayer> renderLayerBackground = graphicsSystem->getRenderLayer(IDCache::get("rl-bg"));
     shared_ptr<RenderLayer> renderLayerGame = graphicsSystem->getRenderLayer(IDCache::get("rl-game"));
 
-    // Create lighting
+//      // Add lighting
-    unique_ptr<LightingFactory> lightingFactory = make_unique<LightingFactory>(
+//    unique_ptr<LightingFactory> lightingFactoryGame = make_unique<LightingFactory>(dynamic_pointer_cast<AssetSystem>(findSystem(IDCache::get("AssetSystem"))),
-            dynamic_pointer_cast<AssetSystem>(findSystem(IDCache::get("AssetSystem"))),
+//            graphicsSystem,
-            graphicsSystem,
+//            dynamic_pointer_cast<PhysicsSystem>(findSystem(IDCache::get("PhysicsSystem"))),
-            dynamic_pointer_cast<PhysicsSystem>(findSystem(IDCache::get("PhysicsSystem"))),
+//            dynamic_pointer_cast<InteractionSystem>(findSystem(IDCache::get("InteractionSystem"))));
-            dynamic_pointer_cast<InteractionSystem>(findSystem(IDCache::get("InteractionSystem"))));
+//
+//    lightingFactoryGame->createPointLight(vec3(10, 10, 0),
+//                                          vec3(1.0f, 0.93f, 0.68f),
+//                                          .6f,
+//                                          renderLayerGame);
+//    lightingFactoryGame->createPointLight(vec3(-10, 2, 0),
+//                                          vec3(0.78f, 0.82f, 1.0f),
+//                                          .6f,
+//                                          renderLayerGame);
 
-    lightingFactory->createSun(10.0f,
+//   lightingFactoryGame->createSun(100.0f,
-            vec3(45,-45,0),
+//                                  vec3(0,0,0),
-            vec3(1,1,1),
+//                                  vec3(1,0,0),
-            0.5f,
+//                                  1.0f,
-            renderLayerGame);
+//                                  renderLayerGame);
 
-    lightingFactory.reset();
+
-//    // Create background
+//    lightingFactoryGame->createDirectionalLight(vec3(10, 10, 0),
-//    unique_ptr<SpriteFactory> bakgroundSpriteFactory = make_unique<SpriteFactory>(
+//                                            vec3(-90, 0, 0),
-//                dynamic_pointer_cast<AssetSystem>(findSystem(IDCache::get("AssetSystem"))),
+//                                            vec3(1,0,0),
-//                graphicsSystem,
+//                                            1.0f,
-//                renderLayerBackground);
+//                                            renderLayerGame);
+//    lightingFactoryGame->createDirectionalLight(vec3(-10, 10, 0),
+//                                            vec3(0, 0, 0),
+//                                            vec3(0,1,0),
+//                                            1.0f,
+//                                            renderLayerGame);
+//    lightingFactoryGame->createDirectionalLight(vec3(-10, 10, 0),
+//                                            vec3(0, 0, 0),
+//                                            vec3(0,0,1),
+//                                            1.0f,
+//                                            renderLayerGame);
 //
-//    bakgroundSpriteFactory->createBackground("sky-plane", "sky-diffuse.png");
+//    unique_ptr<LightingFactory> lightingFactoryGUI = make_unique<LightingFactory>(dynamic_pointer_cast<AssetSystem>(findSystem(IDCache::get("AssetSystem"))),
+//            graphicsSystem,
+//            dynamic_pointer_cast<PhysicsSystem>(findSystem(IDCache::get("PhysicsSystem"))),
+//            renderLayerGui,
+//            dynamic_pointer_cast<InteractionSystem>(findSystem(IDCache::get("InteractionSystem"))));
+//    lightingFactoryGUI->createDirectionalLight(vec3(10, 10, 0),
+//                                            vec3(0, 0, 0),
+//                                            vec3(1,0,0),
+//                                            1.0f,
+//                                            renderLayerGui);
+//    lightingFactoryGUI->createDirectionalLight(vec3(-10, 10, 0),
+//                                            vec3(0, 0, 0),
+//                                            vec3(0,1,0),
+//                                            1.0f,
+//                                            renderLayerGui);
+
+
+
+    // Note: this was enabled
 //
-//    bakgroundSpriteFactory.reset();
+//    // Add entities
+//    FloorFactory* floorFactory = new FloorFactory(dynamic_pointer_cast<AssetSystem>(findSystem(IDCache::get("AssetSystem"))),
+//                                                  graphicsSystem,
+//                                                  dynamic_pointer_cast<PhysicsSystem>(findSystem(IDCache::get("PhysicsSystem"))),
+//                                                  renderLayerGame);
+//    floorFactory->createFloor(vec3(0,-5,0));
+//    floorFactory->createStaticFloor(vec3(0,-8,0));
+//    delete floorFactory;
 //
-//    // Create background
-//    unique_ptr<SpriteFactory> spriteFactory = make_unique<SpriteFactory>(
-//                dynamic_pointer_cast<AssetSystem>(findSystem(IDCache::get("AssetSystem"))),
-//                graphicsSystem,
-//                renderLayerGame);
-//
-////    bakgroundSpriteFactory->createBackground("ball-test-plane", "ball-diffuse.png");
-//    spriteFactory->createPlane("water", "water-diffuse.png", vec3(0, 4, 0), vec3(90, 0, 0), vec3(100, 100, 0));
-//
-//    spriteFactory.reset();
 
     // Create 2 jump180s
     unique_ptr<Jump180Factory> jump180Factory = make_unique<Jump180Factory>(
@@ -235,8 +249,8 @@ void JamSpookGame::set()
             dynamic_pointer_cast<PhysicsSystem>(findSystem(IDCache::get("PhysicsSystem"))),
             renderLayerGame);
 
-    jump180Factory->createJump180(vec3(0, -1, 0), vec3(0, 0, 0));
+    jump180Factory->createJump180(vec3(0, 0, 0), vec3(0, 0, 0));
-    jump180Factory->createJump180(vec3(25,-16, 14), vec3(0, 180, 0));
+    jump180Factory->createJump180(vec3(25,-15, 14), vec3(0, 180, 0));
 
     jump180Factory.reset();
 
@@ -247,54 +261,23 @@ void JamSpookGame::set()
             dynamic_pointer_cast<PhysicsSystem>(findSystem(IDCache::get("PhysicsSystem"))),
             renderLayerGame);
 
-    goalFactory->createGoal(vec3(-1, -31, -12));
+    goalFactory->createGoal(vec3(-1, -30, -12));
 //    goalFactory->createGoal(vec3(0, 0, 0));
 
     goalFactory.reset();
 
-    // Create the track pieces
+    // Create the reset trigger
-    unique_ptr<TrackPieceFactory> trackPieceFactory = make_unique<TrackPieceFactory>(
+    unique_ptr<ResetTriggerFactory> resetTriggerFactory = make_unique<ResetTriggerFactory>(
             dynamic_pointer_cast<AssetSystem>(findSystem(IDCache::get("AssetSystem"))),
             graphicsSystem,
             dynamic_pointer_cast<PhysicsSystem>(findSystem(IDCache::get("PhysicsSystem"))),
             renderLayerGame);
 
-//    trackPieceFactory->createRoad();
+    resetTriggerFactory->createResetTrigger(vec3(-1, -30, -12),
-//    trackPieceFactory->createTunnel();
+                                            vec3(1));
-//    trackPieceFactory->createMountain();
+//    goalFactory->createGoal(vec3(0, 0, 0));
-
-//    trackPieceFactory->createStaticPlatform();
-
-    trackPieceFactory->createGhost("SadGhost",
-                                  "ghost-white-diffuse.png",
-                                  vec3(20, -15, 10),
-                                  quat(vec3(radians(0.0f), radians(45.0f), radians(0.0f))),
-                                  5.0f);
-
-    trackPieceFactory->createGhost("AngryGhost",
-                                  "ghost-red-diffuse.png",
-                                  vec3(-8, -25, -18),
-                                  quat(vec3(radians(0.0f), radians(15.0f), radians(0.0f))),
-                                  5.0f);
-
-
-
-
-
-    // End scene entities
-    trackPieceFactory->createGhost("SadGhost",
-                                  "ghost-white-diffuse.png",
-                                  vec3(1005, 4, 1001),
-                                  quat(vec3(radians(0.0f), radians(45.0f), radians(0.0f))));
-
-    trackPieceFactory->createSign("ThankYouSign",
-                                  "sign-thanks-diffuse.png",
-                                  vec3(994, 0, 1000),
-                                  quat(vec3(radians(0.0f), radians(90.0f), radians(0.0f))));
-
-    trackPieceFactory.reset();
-
 
+    resetTriggerFactory.reset();
 
 //    // Create the ball
 //    unique_ptr<BallFactory> ballFactory = make_unique<BallFactory>(dynamic_pointer_cast<AssetSystem>(findSystem(IDCache::get("AssetSystem"))),
@@ -312,70 +295,17 @@ void JamSpookGame::set()
 //    ballFactory.reset();
 
     // Create the player kart
-    shared_ptr<KartFactory> kartFactory = make_unique<KartFactory>(
+    unique_ptr<KartFactory> kartFactory = make_unique<KartFactory>(
             dynamic_pointer_cast<AssetSystem>(findSystem(IDCache::get("AssetSystem"))),
             graphicsSystem,
             dynamic_pointer_cast<PhysicsSystem>(findSystem(IDCache::get("PhysicsSystem"))),
             dynamic_pointer_cast<InteractionSystem>(findSystem(IDCache::get("InteractionSystem"))),
-            dynamic_pointer_cast<AnimationSystem>(findSystem(IDCache::get("AnimationSystem"))),
             renderLayerGame);
 
-    shared_ptr<Entity> kartEntity = kartFactory->createKart(
+    kartFactory->createKart(vec3(0, 3, 0),  // position
-            vec3(0, 3, 0),  // position
+                            vec3(0, 180, 0)); // euler degrees rotation, XYZ
-            vec3(0, 180, 0)); // euler degrees rotation, XYZ
 
-
+    kartFactory.reset();
-
-//    kartFactory.reset();
-
-    // Create the follow camera, and lock it to the kart
-    unique_ptr<CameraFactory> cameraFactory = make_unique<CameraFactory>();
-
-    cameraFactory->createActiveFollowCamera("followKartCamera",
-                                            mCamera,
-                                            kartEntity,
-                                            vec3(0 ,25 ,25),
-                                            vec3(0, 5, 0),
-                                            bvec3(0, 0, 0));
-
-    shared_ptr<Entity> endSceneCamera = cameraFactory->createStaticCamera("endSceneCamera",
-                                                       mCameraEndScene);
-
-    cameraFactory.reset();
-
-
-    // Create the reset trigger
-    unique_ptr<ResetTriggerFactory> resetTriggerFactory = make_unique<ResetTriggerFactory>(
-            dynamic_pointer_cast<AssetSystem>(findSystem(IDCache::get("AssetSystem"))),
-            graphicsSystem,
-            dynamic_pointer_cast<PhysicsSystem>(findSystem(IDCache::get("PhysicsSystem"))),
-            renderLayerGame);
-
-    shared_ptr<Entity> endGameEntity = resetTriggerFactory->
-            createResetTrigger(vec3(-1, -31, -12),
-                               vec3(1));
-
-//    shared_ptr<Entity> endGameEntity = resetTriggerFactory->
-//            createResetTrigger(vec3(0, 0, 0),
-//                               vec3(1));
-
-    // Add the leaking ICCResponse component to // ContactWithPlayer
-    weak_ptr<GraphicsSystem> wGraphicsSystem = graphicsSystem;
-    weak_ptr<Camera> wEndSceneCamera = mCameraEndScene;
-    endGameEntity->addComponent(make_shared<ICCResponseComponent>(endGameEntity, [wGraphicsSystem, wEndSceneCamera, kartFactory] (shared_ptr<Message> message) {
-        if (message->getMessageType() == IDCache::get("ContactWithPlayer"))
-        {
-            Log::write(LogLevel::debug, "endGameEntity - ContactWithPlayer");
-            shared_ptr<GraphicsSystem> graphicsSystem = getShared(wGraphicsSystem);
-            shared_ptr<RenderLayer> renderLayerGame = graphicsSystem->getRenderLayer(IDCache::get("rl-game"));
-            renderLayerGame->setCamera(getShared(wEndSceneCamera));
-
-            // Create the end scene rotating kart
-            shared_ptr<Entity> rotatingKartEntity = kartFactory->createRotatingKart(vec3(1000, 0, 1000));
-        }
-    }));
-
-    resetTriggerFactory.reset();
 
     // Set game state
     setGameState(ecos::core::GameState::InGame);

src/JamSpookGame.h

@@ -36,14 +36,9 @@
 
 #include <ecos/physics/PhysicsSystem.h>
 #include <ecos/physics/loaders/CollisionShapeLoader.h>
-#include <ecos/physics/loaders/StaticCollisionShapeLoader.h>
 
 #include <ecos/animation/AnimationSystem.h>
 
-#include <ecos/camera/CameraSystem.h>
-#include <ecos/camera/CameraFactory.h>
-#include <ecos/camera/Camera.h>
-
 #include <ecos/interaction/InteractionSystem.h>
 
 #include <ecos/graphics/GraphicsSystem.h>
@@ -54,6 +49,8 @@
 #include <ecos/graphics/ShaderProgramFactory.h>
 #include <ecos/graphics/DevILSystem.h>
 #include <ecos/graphics/GL4Renderer.h>
+#include <ecos/graphics/camera/CameraFactory.h>
+#include <ecos/graphics/camera/Camera.h>
 #include <ecos/graphics/loaders/MeshLoader.h>
 #include <ecos/graphics/loaders/ShaderLoader.h>
 #include <ecos/graphics/loaders/ShaderProgramLoader.h>
@@ -63,9 +60,7 @@
 #include <ecos/sound/SoundSystem.h>
 #include <ecos/sound/loaders/SoundEffectLoader.h>
 
-#include "entities/SpriteFactory.h"
 #include "entities/LightingFactory.h"
-#include "entities/TrackPieceFactory.h"
 #include "entities/Jump180Factory.h"
 #include "entities/GoalFactory.h"
 #include "entities/BallFactory.h"
@@ -88,7 +83,6 @@ using std::to_string;
 
 using glm::ivec2;
 using glm::vec2;
-using glm::bvec3;
 using glm::vec3;
 using glm::vec4;
 using glm::mat4;
@@ -117,14 +111,9 @@ using ecos::asset::DataManagementMode;
 
 using ecos::physics::PhysicsSystem;
 using ecos::physics::CollisionShapeLoader;
-using ecos::physics::StaticCollisionShapeLoader;
 
 using ecos::animation::AnimationSystem;
 
-using ecos::camera::CameraSystem;
-using ecos::camera::CameraFactory;
-using ecos::camera::Camera;
-
 using ecos::interaction::InteractionSystem;
 using ecos::interaction::InputDeviceState;
 using ecos::interaction::ButtonState;
@@ -138,6 +127,8 @@ using ecos::graphics::ShaderProgramFactory;
 using ecos::graphics::DevILSystem;
 using ecos::graphics::Renderer;
 using ecos::graphics::GL4Renderer;
+using ecos::graphics::Camera;
+using ecos::graphics::CameraFactory;
 using ecos::graphics::MeshLoader;
 using ecos::graphics::ShaderLoader;
 using ecos::graphics::ShaderProgramLoader;
@@ -160,8 +151,6 @@ private:
     BroadcastObservable<const InputDeviceState>::CallbackID mInputDeviceCallbackId;
     shared_ptr<GL4Renderer> mRenderer;
     shared_ptr<Camera> mCamera;
-    shared_ptr<Camera> mCameraBackground;
-    shared_ptr<Camera> mCameraEndScene;
 
 public:
     JamSpookGame();

src/entities/KartFactory.cpp

@@ -13,13 +13,11 @@ KartFactory::KartFactory(weak_ptr<AssetSystem>       assetSystem,
                          weak_ptr<GraphicsSystem>    graphicsSystem,
                          weak_ptr<PhysicsSystem>     physicsSystem,
                          weak_ptr<InteractionSystem> interactionSystem,
-                         weak_ptr<AnimationSystem>   animationSystem,
                          weak_ptr<RenderLayer>       renderLayer):
         mAssetSystem(assetSystem),
         mGraphicsSystem(graphicsSystem),
         mPhysicsSystem(physicsSystem),
         mInteractionSystem(interactionSystem),
-        mAnimationSystem(animationSystem),
         mRenderLayer(renderLayer)
 {}
 
@@ -78,7 +76,7 @@ shared_ptr<Entity> KartFactory::createKart(const vec3 position,
                                                                                      mRenderLayer);
     entity->addComponent(graphicsComponent);
 
-    // Add the ModelRenderable
+    // Add the ModelRenderable of a ball
     ModelRenderableFactory* modelFactory = new ModelRenderableFactory(mAssetSystem);
 
     shared_ptr<ModelRenderable> modelRenderableKart = modelFactory->createModel("kart-vehicle.bcosm",
@@ -93,14 +91,14 @@ shared_ptr<Entity> KartFactory::createKart(const vec3 position,
 
     delete modelFactory;
 
-//    // Add internal pointlight
+    // Add internal pointlight
-//    LightSourceFactory* lightSourceFactory = new LightSourceFactory(mAssetSystem, mGraphicsSystem);
+    LightSourceFactory* lightSourceFactory = new LightSourceFactory(mAssetSystem, mGraphicsSystem);
-//    shared_ptr<LightSource> lightSource = lightSourceFactory->createPointLight(vec3(1,1,1),
+    shared_ptr<LightSource> lightSource = lightSourceFactory->createPointLight(vec3(1,1,1),
-//                                                                               0.1f,
+                                                                               0.02f,
-//                                                                               0.001f,
+                                                                               0.03f,
-//                                                                               translate(transform, vec3(0,0,0)));
+                                                                               transform);
-//    graphicsComponent->setLightSource(lightSource);
+    graphicsComponent->setLightSource(lightSource);
-//    delete lightSourceFactory;
+    delete lightSourceFactory;
 
     // Add interaction component
     shared_ptr<KartInteractionComponent> interactionComponent =
@@ -116,146 +114,4 @@ shared_ptr<Entity> KartFactory::createKart(const vec3 position,
     return entity;
 }
 
-shared_ptr<Entity> KartFactory::createRotatingKart(const vec3 position)
-{
-    // Create instance
-    shared_ptr<Entity> entity = make_shared<Entity>();
-    entity->setEntityTag("rotatingKart");
-    SceneGraph::addEntity(entity);
-
-    // Create transform
-    mat4 translation = translate(mat4(1.0f), position);
-    mat4 transform = translation;
-
-    // Add graphics component
-    shared_ptr<GraphicsComponent> graphicsComponent = make_shared<GraphicsComponent>(transform,
-                                                                                     entity,
-                                                                                     getShared(mGraphicsSystem),
-                                                                                     mRenderLayer);
-    entity->addComponent(graphicsComponent);
-
-    // Add the ModelRenderable
-    ModelRenderableFactory* modelFactory = new ModelRenderableFactory(mAssetSystem);
-
-    shared_ptr<ModelRenderable> modelRenderableKart = modelFactory->createModel("kart-vehicle.bcosm",
-                                                                                "kart-vehicle-diffuse.png",
-                                                                                "kart-vehicle-model");
-    graphicsComponent->addRenderable(modelRenderableKart);
-
-    shared_ptr<ModelRenderable> modelRenderableDriver = modelFactory->createModel("kart-driver.bcosm",
-                                                                                  "kart-driver-diffuse.png",
-                                                                                  "kart-driver-model");
-    graphicsComponent->addRenderable(modelRenderableDriver);
-
-    delete modelFactory;
-
-    // Add Physics component
-    unique_ptr<ColliderFactory> colliderFactory = make_unique<ColliderFactory>(mPhysicsSystem, mAssetSystem);
-    shared_ptr<PhysicsComponent> physicsComponent =
-            make_shared<PhysicsComponent>(transform,
-                                          entity,
-                                          mPhysicsSystem,
-                                          mPhysicsSystem,
-                                          mPhysicsSystem,
-                                          colliderFactory->createBoxCollider(
-                                                  vec3(1000,0,1000),
-                                                  glm::quat_cast(mat4(1)),
-                                                  vec3(1),
-                                                  0,
-                                                  entity,
-                                                  "rotatingKart"));
-    entity->addComponent(physicsComponent);
-    weak_ptr<PhysicsComponent> wPhysicsComponent(physicsComponent);
-
-    // Animation component, to make the kart rotate continuously
-    shared_ptr<AnimationComponent> animationComponent =
-            make_shared<AnimationComponent>(entity,
-                                            mAnimationSystem);
-    entity->addComponent(animationComponent);
-
-    // Add falling animation
-    animationComponent->addAnimation(AnimationFactory::createLinearAnimation(
-            make_shared<Attribute<PhysicsComponent, vec3> >(
-                    physicsComponent,
-                    [wPhysicsComponent]()->vec3{
-                        if (wPhysicsComponent.expired()) return vec3();
-                        shared_ptr<PhysicsComponent> physicsComponent = wPhysicsComponent.lock();
-                        if (!physicsComponent) return vec3();
-
-                        return physicsComponent->getPosition();
-                    },
-                    [wPhysicsComponent](vec3 i){
-                        if (wPhysicsComponent.expired()) return;
-                        shared_ptr<PhysicsComponent> physicsComponent = wPhysicsComponent.lock();
-                        if (!physicsComponent) return;
-
-                        physicsComponent->setPosition(i);
-                    }),
-            vec3(1000, 10, 1000),
-            vec3(1000, 0, 1000),
-            static_cast<milliseconds>(800),
-            [] () {Log::write(LogLevel::debug, "Translation end"); } ));
-
-    // Add rotation animation
-    animationComponent->addAnimation(AnimationFactory::createLinearAnimation(
-            make_shared<Attribute<PhysicsComponent, vec3> >(
-                    physicsComponent,
-                    [wPhysicsComponent]()->vec3{
-                        if (wPhysicsComponent.expired()) return vec3();
-                        shared_ptr<PhysicsComponent> physicsComponent = wPhysicsComponent.lock();
-                        if (!physicsComponent) return vec3();
-
-                        return getRotationDegrees(physicsComponent->getTransform());
-                    },
-                    [wPhysicsComponent](vec3 i){
-                        if (wPhysicsComponent.expired()) return;
-                        shared_ptr<PhysicsComponent> physicsComponent = wPhysicsComponent.lock();
-                        if (!physicsComponent) return;
-
-                        physicsComponent->setOrientationEulerDegreesXYZ(i);
-                    }),
-            vec3(0, 45, 0),
-            vec3(0, 0, 0),
-            static_cast<milliseconds>(800),
-            [] () {Log::write(LogLevel::debug, "Rotation end"); } ));
-
-
-    // Return instance
-    return entity;
-}
-
 } // namespace JamSpook
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

src/entities/KartFactory.h

@@ -13,7 +13,6 @@
 #include <memory>
 #include <functional>
 #include <vector>
-#include <chrono>
 
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
@@ -21,7 +20,6 @@
 #include <glm/gtx/string_cast.hpp>
 
 #include <ecos/utility/Memory.h>
-#include <ecos/utility/Math.h>
 
 #include <ecos/core/IDCache.h>
 #include <ecos/core/Log.h>
@@ -34,11 +32,6 @@
 #include <ecos/asset/AssetSystem.h>
 #include <ecos/asset/DataManagementMode.h>
 
-#include <ecos/animation/AnimationSystem.h>
-#include <ecos/animation/Animation.h>
-#include <ecos/animation/AnimationFactory.h>
-#include <ecos/animation/AnimationComponent.h>
-
 #include <ecos/physics/PhysicsSystem.h>
 #include <ecos/physics/PhysicsComponent.h>
 #include <ecos/physics/ColliderFactory.h>
@@ -73,13 +66,10 @@ using std::string;
 using std::shared_ptr;
 using std::make_shared;
 using std::weak_ptr;
-using std::unique_ptr;
-using std::make_unique;
 using std::dynamic_pointer_cast;
 using std::function;
 using std::bind;
 using std::vector;
-using std::chrono::milliseconds;
 
 using glm::vec3;
 using glm::mat4;
@@ -92,7 +82,6 @@ using glm::eulerAngleXYZ;
 using glm::radians;
 
 using ecos::utility::getShared;
-using ecos::utility::getRotationDegrees;
 
 using ecos::core::IDCache;
 using ecos::core::logging::Log;
@@ -106,12 +95,6 @@ using ecos::core::ICCResponseComponent;
 using ecos::asset::AssetSystem;
 using ecos::asset::DataManagementMode;
 
-using ecos::animation::AnimationSystem;
-using ecos::animation::Animation;
-using ecos::animation::AnimationFactory;
-using ecos::animation::AnimationComponent;
-using ecos::animation::Attribute;
-
 using ecos::graphics::GraphicsSystem;
 using ecos::graphics::GraphicsComponent;
 using ecos::graphics::RenderLayer;
@@ -145,7 +128,6 @@ private:
     weak_ptr<GraphicsSystem>     mGraphicsSystem;
     weak_ptr<PhysicsSystem>      mPhysicsSystem;
     weak_ptr<InteractionSystem>  mInteractionSystem;
-    weak_ptr<AnimationSystem>    mAnimationSystem;
     weak_ptr<RenderLayer>        mRenderLayer;
 
 public:
@@ -153,16 +135,12 @@ public:
                 weak_ptr<GraphicsSystem>     graphicsSystem,
                 weak_ptr<PhysicsSystem>      physicsSystem,
                 weak_ptr<InteractionSystem>  interactionSystem,
-                weak_ptr<AnimationSystem>    animationSystem,
                 weak_ptr<RenderLayer>        renderLayer);
     virtual ~KartFactory();
 
     /// Compose a kart entity
     shared_ptr<Entity> createKart(const vec3 position,
                                   const vec3 eulerRotationXYZDegrees);
-
-    /// Compose a rotating kart entity
-    shared_ptr<Entity> createRotatingKart(const vec3 position);
 };
 
 } // namespace JamSpook

src/entities/KartPhysicsComponent.cpp

@@ -20,8 +20,7 @@ KartPhysicsComponent::KartPhysicsComponent(mat4 transform,
                          physicsSystem,
                          physicsCollisionSubSystem,
                          physicsColliderQuerySubSystem,
-                         collider),
+                         collider)
-        mInitialTransform(transform)
 {}
 
 KartPhysicsComponent::~KartPhysicsComponent()
@@ -34,8 +33,9 @@ void KartPhysicsComponent::update(const milliseconds dtms)
 
     if (getPosition().y < -100.0f)
     {
-    	setPosition(vec3(0, 0, 0), true);
+    	setPosition(vec3(getFloatInRange(-10.0f, 10.0f),
-    	setTransform(mInitialTransform);
+                		 10, /// above the ball
+						 getFloatInRange(-10.0f, 10.0f)));
     }
 
     if (glm::length(mDirection) > 0)
@@ -76,8 +76,7 @@ void KartPhysicsComponent::onICCMessage(shared_ptr<Message> message)
 
 void KartPhysicsComponent::onCollision(const string& tag)
 {
-    if (tag == "goal"
+    if (tag == "goal")
-        || tag == "jump180")
     {
         ICCBroadcast(make_shared<Message>(IDCache::get("GroundCollisionMessage")));
     }
@@ -93,8 +92,7 @@ void KartPhysicsComponent::onCollision(const string& tag)
 
 void KartPhysicsComponent::onSeparation(const string& tag)
 {
-    if (tag == "goal"
+    if (tag == "goal")
-        || tag == "jump180")
     {
         ICCBroadcast(make_shared<Message>(IDCache::get("GroundSeparationMessage")));
     }

src/entities/KartPhysicsComponent.h

@@ -77,7 +77,6 @@ class KartPhysicsComponent:
 {
 private:
     vec3 mDirection;
-    mat4 mInitialTransform; ///< Used for reset.
 
 public:
     KartPhysicsComponent(mat4 transform,

src/entities/ResetTriggerFactory.cpp

@@ -27,7 +27,7 @@ shared_ptr<Entity> ResetTriggerFactory::createResetTrigger(const vec3 position,
 {
     // Create instance
     shared_ptr<Entity> entity = make_shared<Entity>();
-    entity->setEntityTag("end-trigger");
+    entity->setEntityTag("reset-trigger");
     SceneGraph::addEntity(entity);
     mat4 transform = translate(mat4(1), position);
 

src/entities/ResetTriggerPhysicsComponent.cpp

@@ -39,7 +39,12 @@ void ResetTriggerPhysicsComponent::onICCMessage(shared_ptr<Message> message)
 
 void ResetTriggerPhysicsComponent::onCollision(const string& tag)
 {
-    ICCBroadcast(make_shared<Message>(IDCache::get("ContactWithPlayer")));
+//    if (tag == "ground-plane")
+//    {
+//        vec3 position = getPosition();
+//        setPosition(vec3(position.x, 10.0f, position.z));
+//        ICCBroadcast(make_shared<Message>(IDCache::get("GroundContactMessage")));
+//    }
 }
 
 } // namespace JamSpook

src/entities/SpriteFactory.cpp

@@ -1,82 +0,0 @@
-/*
- * SpriteFactory.cpp
- *
- *  Created on: Aug 24, 2020
- *      Author: fredrick
- */
-
-#include "SpriteFactory.h"
-
-namespace JamSpook {
-
-SpriteFactory::SpriteFactory(weak_ptr<AssetSystem>    assetSystem,
-                             weak_ptr<GraphicsSystem> graphicsSystem,
-                             weak_ptr<RenderLayer>    renderLayer):
-        mAssetSystem(assetSystem),
-        mGraphicsSystem(graphicsSystem),
-        mRenderLayer(renderLayer)
-{}
-
-SpriteFactory::~SpriteFactory()
-{}
-
-shared_ptr<Entity> SpriteFactory::createPlane(const string name,
-                                              const string filePath,
-                                              const vec3 position,
-                                              const vec3 rotation,
-                                              const vec3 scaleFactor)
-{
-    // Create instance
-    shared_ptr<Entity> entity = make_shared<Entity>();
-    entity->setEntityTag(name);
-    SceneGraph::addEntity(entity);
-    mat4 transform = scale(mat4(1), scaleFactor) * translate(mat4(1), position);
-
-    // Add graphics component
-    shared_ptr<GraphicsComponent> graphicsComponent = make_shared<GraphicsComponent>(transform,
-                                                                                     entity,
-                                                                                     getShared(mGraphicsSystem),
-                                                                                     mRenderLayer);
-    entity->addComponent(graphicsComponent);
-
-    // Add the ModelRenderable of a ball
-    ModelRenderableFactory* modelFactory = new ModelRenderableFactory(mAssetSystem);
-    shared_ptr<ModelRenderable> modelRenderable = modelFactory->createModel("plane-1x1.bcosm",
-                                                                            filePath,
-                                                                            name+"_model");
-    delete modelFactory;
-    graphicsComponent->addRenderable(modelRenderable);
-
-    // Return instance
-    return entity;
-}
-
-shared_ptr<Entity> SpriteFactory::createBackground(const string name,
-                                                   const string filePath)
-{
-    // Create instance
-    shared_ptr<Entity> entity = make_shared<Entity>();
-    entity->setEntityTag(name);
-    SceneGraph::addEntity(entity);
-    mat4 transform = scale(mat4(1), vec3(1, 1, 1)) * translate(mat4(1), vec3(-1, -1, -1));
-
-    // Add graphics component
-    shared_ptr<GraphicsComponent> graphicsComponent = make_shared<GraphicsComponent>(transform,
-                                                                                     entity,
-                                                                                     getShared(mGraphicsSystem),
-                                                                                     mRenderLayer);
-    entity->addComponent(graphicsComponent);
-
-    // Add the ModelRenderable of a ball
-    ModelRenderableFactory* modelFactory = new ModelRenderableFactory(mAssetSystem);
-    shared_ptr<ModelRenderable> modelRenderable = modelFactory->createModel("plane-1x1.bcosm",
-                                                                            filePath,
-                                                                            name+"_model");
-    delete modelFactory;
-    graphicsComponent->addRenderable(modelRenderable);
-
-    // Return instance
-    return entity;
-}
-
-} // namespace JamSpook

src/entities/SpriteFactory.h

@@ -1,123 +0,0 @@
-/*
- * SpriteFactory.h
- *
- *  Created on: Aug 24, 2020
- *      Author: fredrick
- */
-
-#ifndef SPRITEFACTORY_H_
-#define SPRITEFACTORY_H_
-
-#include <cstdint>
-#include <string>
-#include <memory>
-#include <functional>
-#include <vector>
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-
-#include <ecos/utility/Memory.h>
-#include <ecos/core/IDCache.h>
-#include <ecos/core/Log.h>
-#include <ecos/core/BroadcastObservable.h>
-#include <ecos/core/Message.h>
-#include <ecos/core/Entity.h>
-#include <ecos/core/SceneGraph.h>
-#include <ecos/core/ICCResponseComponent.h>
-#include <ecos/asset/AssetSystem.h>
-#include <ecos/asset/DataManagementMode.h>
-#include <ecos/physics/PhysicsSystem.h>
-#include <ecos/physics/PhysicsComponent.h>
-#include <ecos/physics/ColliderFactory.h>
-#include <ecos/physics/Collider.h>
-#include <ecos/graphics/GraphicsSystem.h>
-#include <ecos/graphics/GraphicsComponent.h>
-#include <ecos/graphics/RenderLayer.h>
-#include <ecos/graphics/TextureFactory.h>
-#include <ecos/graphics/Texture.h>
-#include <ecos/graphics/assets/ShaderAsset.h>
-#include <ecos/graphics/ShaderProgram.h>
-#include <ecos/graphics/ShaderProgramFactory.h>
-#include <ecos/graphics/Material.h>
-#include <ecos/graphics/MaterialFactory.h>
-#include <ecos/graphics/Mesh.h>
-#include <ecos/graphics/MeshFactory.h>
-#include <ecos/graphics/ModelRenderable.h>
-#include <ecos/graphics/lighting/LightSource.h>
-#include <ecos/graphics/lighting/LightSourceFactory.h>
-#include <ecos/graphics/ModelRenderableFactory.h>
-#include <ecos/graphics/ShaderType.h>
-
-namespace JamSpook {
-
-using std::string;
-using std::shared_ptr;
-using std::make_shared;
-using std::weak_ptr;
-using std::dynamic_pointer_cast;
-using std::function;
-using std::bind;
-using std::vector;
-
-using glm::vec3;
-using glm::mat4;
-using glm::quat;
-using glm::translate;
-
-using ecos::utility::getShared;
-using ecos::core::IDCache;
-using ecos::core::logging::Log;
-using ecos::core::logging::LogLevel;
-using ecos::core::BroadcastObservable;
-using ecos::core::Message;
-using ecos::core::Entity;
-using ecos::core::SceneGraph;
-using ecos::core::ICCResponseComponent;
-using ecos::asset::AssetSystem;
-using ecos::asset::DataManagementMode;
-using ecos::graphics::GraphicsSystem;
-using ecos::graphics::GraphicsComponent;
-using ecos::graphics::RenderLayer;
-using ecos::graphics::TextureFactory;
-using ecos::graphics::Texture;
-using ecos::graphics::ShaderType;
-using ecos::graphics::ShaderAsset;
-using ecos::graphics::ShaderProgram;
-using ecos::graphics::ShaderProgramFactory;
-using ecos::graphics::Material;
-using ecos::graphics::MaterialFactory;
-using ecos::graphics::Mesh;
-using ecos::graphics::MeshFactory;
-using ecos::graphics::ModelRenderableFactory;
-using ecos::graphics::ModelRenderable;
-using ecos::graphics::lighting::LightSource;
-using ecos::graphics::lighting::LightSourceFactory;
-
-///
-class SpriteFactory
-{
-private:
-    weak_ptr<AssetSystem>    mAssetSystem;
-    weak_ptr<GraphicsSystem> mGraphicsSystem;
-    weak_ptr<RenderLayer>    mRenderLayer;
-
-public:
-    SpriteFactory(weak_ptr<AssetSystem>    assetSystem,
-                  weak_ptr<GraphicsSystem> graphicsSystem,
-                  weak_ptr<RenderLayer>    renderLayer);
-    virtual ~SpriteFactory();
-
-    shared_ptr<Entity> createPlane(const string name,
-                                                  const string filePath,
-                                                  const vec3 position,
-                                                  const vec3 rotation,
-                                                  const vec3 scaleFactor);
-
-    shared_ptr<Entity> createBackground(const string name,
-                                        const string filePath);
-};
-
-} // namespace JamSpook
-
-#endif // SPRITEFACTORY_H_

src/entities/TrackPieceFactory.cpp

@@ -1,312 +0,0 @@
-/*
- * TrackPieceFactory.cpp
- *
- *  Created on: Aug 27, 2020
- *      Author: fredrick
- */
-
-#include "TrackPieceFactory.h"
-
-namespace JamSpook {
-
-TrackPieceFactory::TrackPieceFactory(weak_ptr<AssetSystem>    assetSystem,
-                                     weak_ptr<GraphicsSystem> graphicsSystem,
-                                     weak_ptr<PhysicsSystem>  physicsSystem,
-                                     weak_ptr<RenderLayer>    renderLayer):
-        mAssetSystem(assetSystem),
-        mGraphicsSystem(graphicsSystem),
-        mPhysicsSystem(physicsSystem),
-        mRenderLayer(renderLayer)
-{}
-
-TrackPieceFactory::~TrackPieceFactory()
-{}
-
-/// Compose a road entity
-shared_ptr<Entity> TrackPieceFactory::createRoad()
-{
-    // Create instance
-    shared_ptr<Entity> entity = make_shared<Entity>();
-    entity->setEntityTag("road");
-    SceneGraph::addEntity(entity);
-
-    // Create transform
-    mat4 transform = mat4(1);
-
-    // Add physics component
-    ColliderFactory* colliderFactory = new ColliderFactory(mPhysicsSystem, mAssetSystem);
-    shared_ptr<TrackPiecePhysicsComponent> physicsComponent =
-            make_shared<TrackPiecePhysicsComponent>(
-                    transform,
-                    entity,
-                    getShared(mPhysicsSystem),
-                    getShared(mPhysicsSystem),
-                    getShared(mPhysicsSystem),
-                    colliderFactory->createConvexHullCollider(vec3(0),
-                                                              quat_cast(mat4(1)),
-                                                              "road.bcosp", // filePath
-                                                              "road-shape", // name
-                                                              100.0f, // mass
-                                                              entity,
-                                                              entity->getEntityTag()));
-    delete colliderFactory;
-    // Note: Editing of rigid body params, maybe only has effect is it has been added to the world.
-    physicsComponent->getCollider()->getRigidBody()->setLinearFactor(btVector3(0, 0, 0));  // deny positional movement movement in any axis
-    physicsComponent->getCollider()->getRigidBody()->setAngularFactor(btVector3(0, 0, 0)); // deny rotational movement movement in any axis
-    physicsComponent->getCollider()->getRigidBody()->setRestitution(1);
-    entity->addComponent(physicsComponent);
-
-    // Add graphics component
-    shared_ptr<GraphicsComponent> graphicsComponent = make_shared<GraphicsComponent>(transform,
-                                                                                     entity,
-                                                                                     getShared(mGraphicsSystem),
-                                                                                     mRenderLayer);
-    entity->addComponent(graphicsComponent);
-
-    // Add the ModelRenderable of a ball
-    ModelRenderableFactory* modelFactory = new ModelRenderableFactory(mAssetSystem);
-    shared_ptr<ModelRenderable> modelRenderable = modelFactory->createModel("road.bcosm",
-                                                                            "road-diffuse.png",
-                                                                            "road-model");
-    delete modelFactory;
-    graphicsComponent->addRenderable(modelRenderable);
-
-    // Return instance
-    return entity;
-}
-
-/// Compose a tunnel entity
-shared_ptr<Entity> TrackPieceFactory::createTunnel()
-{
-    // Create instance
-    shared_ptr<Entity> entity = make_shared<Entity>();
-    entity->setEntityTag("tunnel");
-    SceneGraph::addEntity(entity);
-
-    // Create transform
-    mat4 transform = mat4(1);
-
-    // Add physics component
-    ColliderFactory* colliderFactory = new ColliderFactory(mPhysicsSystem, mAssetSystem);
-    shared_ptr<TrackPiecePhysicsComponent> physicsComponent =
-            make_shared<TrackPiecePhysicsComponent>(
-                    transform,
-                    entity,
-                    getShared(mPhysicsSystem),
-                    getShared(mPhysicsSystem),
-                    getShared(mPhysicsSystem),
-                    colliderFactory->createConvexHullCollider(vec3(0),
-                                                              quat_cast(mat4(1)),
-                                                              "tunnel.bcosp", // filePath
-                                                              "tunnel-shape", // name
-                                                              100.0f, // mass
-                                                              entity,
-                                                              entity->getEntityTag()));
-    delete colliderFactory;
-    // Note: Editing of rigid body params, maybe only has effect is it has been added to the world.
-    physicsComponent->getCollider()->getRigidBody()->setLinearFactor(btVector3(0, 0, 0));  // deny positional movement movement in any axis
-    physicsComponent->getCollider()->getRigidBody()->setAngularFactor(btVector3(0, 0, 0)); // deny rotational movement movement in any axis
-    physicsComponent->getCollider()->getRigidBody()->setRestitution(1);
-    entity->addComponent(physicsComponent);
-
-    // Add graphics component
-    shared_ptr<GraphicsComponent> graphicsComponent = make_shared<GraphicsComponent>(transform,
-                                                                                     entity,
-                                                                                     getShared(mGraphicsSystem),
-                                                                                     mRenderLayer);
-    entity->addComponent(graphicsComponent);
-
-    // Add the ModelRenderable of a ball
-    ModelRenderableFactory* modelFactory = new ModelRenderableFactory(mAssetSystem);
-    shared_ptr<ModelRenderable> modelRenderable = modelFactory->createModel("tunnel.bcosm",
-                                                                            "tunnel-diffuse.png",
-                                                                            "tunnel-model");
-    delete modelFactory;
-    graphicsComponent->addRenderable(modelRenderable);
-
-    // Return instance
-    return entity;
-}
-
-/// Compose a mountain entity
-shared_ptr<Entity> TrackPieceFactory::createMountain()
-{
-    // Create instance
-    shared_ptr<Entity> entity = make_shared<Entity>();
-    entity->setEntityTag("mountain");
-    SceneGraph::addEntity(entity);
-
-    // Create transform
-    mat4 transform = mat4(1);
-
-//    // Add physics component
-//    ColliderFactory* colliderFactory = new ColliderFactory(mPhysicsSystem, mAssetSystem);
-//    shared_ptr<TrackPiecePhysicsComponent> physicsComponent =
-//            make_shared<TrackPiecePhysicsComponent>(
-//                    transform,
-//                    entity,
-//                    getShared(mPhysicsSystem),
-//                    getShared(mPhysicsSystem),
-//                    getShared(mPhysicsSystem),
-//                    colliderFactory->createConvexHullCollider(vec3(0),
-//                                                              quat_cast(mat4(1)),
-//                                                              "mountain.bcosp", // filePath
-//                                                              "mountain-shape", // name
-//                                                              100.0f, // mass
-//                                                              entity,
-//                                                              entity->getEntityTag()));
-//    delete colliderFactory;
-//    // Note: Editing of rigid body params, maybe only has effect is it has been added to the world.
-//    physicsComponent->getCollider()->getRigidBody()->setLinearFactor(btVector3(0, 0, 0));  // deny positional movement movement in any axis
-//    physicsComponent->getCollider()->getRigidBody()->setAngularFactor(btVector3(0, 0, 0)); // deny rotational movement movement in any axis
-//    physicsComponent->getCollider()->getRigidBody()->setRestitution(1);
-//    entity->addComponent(physicsComponent);
-
-    // Add graphics component
-    shared_ptr<GraphicsComponent> graphicsComponent = make_shared<GraphicsComponent>(transform,
-                                                                                     entity,
-                                                                                     getShared(mGraphicsSystem),
-                                                                                     mRenderLayer);
-    entity->addComponent(graphicsComponent);
-
-    // Add the ModelRenderable of a ball
-    ModelRenderableFactory* modelFactory = new ModelRenderableFactory(mAssetSystem);
-    shared_ptr<ModelRenderable> modelRenderable = modelFactory->createModel("mountain.bcosm",
-                                                                            "mountain-diffuse.png",
-                                                                            "mountain-model");
-    delete modelFactory;
-    graphicsComponent->addRenderable(modelRenderable);
-
-    // Return instance
-    return entity;
-}
-
-shared_ptr<Entity> TrackPieceFactory::createSign(
-        const string name,
-        const string diffuseTextureFilePath,
-        vec3 position,
-        quat orientation)
-{
-    // Create instance
-    shared_ptr<Entity> entity = make_shared<Entity>();
-    entity->setEntityTag(name + "_sign");
-    SceneGraph::addEntity(entity);
-
-    // Create transform
-    mat4 rotation = glm::toMat4(orientation);
-
-    mat4 translation = translate(mat4(1.0f), position);
-
-    mat4 transform = translation * rotation;// * rotateToCenter;
-
-    // Add graphics component
-    shared_ptr<GraphicsComponent> graphicsComponent = make_shared<GraphicsComponent>(transform,
-                                                                                     entity,
-                                                                                     getShared(mGraphicsSystem),
-                                                                                     mRenderLayer);
-    entity->addComponent(graphicsComponent);
-
-    // Add the ModelRenderable of a ball
-    ModelRenderableFactory* modelFactory = new ModelRenderableFactory(mAssetSystem);
-    shared_ptr<ModelRenderable> modelRenderable = modelFactory->createModel("sign.bcosm",
-                                                                            diffuseTextureFilePath,
-                                                                            "sign-model");
-    delete modelFactory;
-    graphicsComponent->addRenderable(modelRenderable);
-
-    // Return instance
-    return entity;
-}
-
-shared_ptr<Entity> TrackPieceFactory::createGhost(
-        const string name,
-        const string diffuseTextureFilePath,
-        vec3 position,
-        quat orientation,
-        float scaling)
-{
-    // Create instance
-    shared_ptr<Entity> entity = make_shared<Entity>();
-    entity->setEntityTag(name + "_ghost");
-    SceneGraph::addEntity(entity);
-
-    // Create transform
-    mat4 translationMatrix = translate(mat4(1.0f), position);
-    mat4 rotationMatrix = glm::toMat4(orientation);
-    mat4 scalingMatrix = glm::scale(mat4(1), vec3(scaling));
-
-
-    mat4 transform = translationMatrix * rotationMatrix * scalingMatrix;// * rotateToCenter;
-
-    // Add graphics component
-    shared_ptr<GraphicsComponent> graphicsComponent = make_shared<GraphicsComponent>(transform,
-                                                                                     entity,
-                                                                                     getShared(mGraphicsSystem),
-                                                                                     mRenderLayer);
-    entity->addComponent(graphicsComponent);
-
-    // Add the ModelRenderable
-    ModelRenderableFactory* modelFactory = new ModelRenderableFactory(mAssetSystem);
-    shared_ptr<ModelRenderable> modelRenderable = modelFactory->createModel("ghost.bcosm",
-                                                                            diffuseTextureFilePath,
-                                                                            name + "-model");
-    delete modelFactory;
-    graphicsComponent->addRenderable(modelRenderable);
-
-    // Return instance
-    return entity;
-}
-
-shared_ptr<Entity> TrackPieceFactory::createStaticPlatform()
-{
-    // Create instance
-    shared_ptr<Entity> entity = make_shared<Entity>();
-    entity->setEntityTag("staticPlatform");
-    SceneGraph::addEntity(entity);
-
-    // Create transform
-    mat4 transform = mat4(1);
-
-    // Add physics component
-    ColliderFactory* colliderFactory = new ColliderFactory(mPhysicsSystem, mAssetSystem);
-    shared_ptr<TrackPiecePhysicsComponent> physicsComponent =
-            make_shared<TrackPiecePhysicsComponent>(
-                    transform,
-                    entity,
-                    getShared(mPhysicsSystem),
-                    getShared(mPhysicsSystem),
-                    getShared(mPhysicsSystem),
-                    colliderFactory->createStaticMeshCollider(vec3(0),
-                                                              quat_cast(mat4(1)),
-                                                              "static-platform.bcosps", // filePath
-                                                              "static-platform-shape",  // name
-                                                              100.0f, // mass
-                                                              entity,
-                                                              entity->getEntityTag()));
-    delete colliderFactory;
-    // Note: Editing of rigid body params, maybe only has effect is it has been added to the world.
-    physicsComponent->getCollider()->getRigidBody()->setLinearFactor(btVector3(0, 0, 0));  // deny positional movement movement in any axis
-    physicsComponent->getCollider()->getRigidBody()->setAngularFactor(btVector3(0, 0, 0)); // deny rotational movement movement in any axis
-    physicsComponent->getCollider()->getRigidBody()->setRestitution(1);
-    entity->addComponent(physicsComponent);
-
-    // Add graphics component
-    shared_ptr<GraphicsComponent> graphicsComponent = make_shared<GraphicsComponent>(transform,
-                                                                                     entity,
-                                                                                     getShared(mGraphicsSystem),
-                                                                                     mRenderLayer);
-    entity->addComponent(graphicsComponent);
-
-    // Add the ModelRenderable of a ball
-    ModelRenderableFactory* modelFactory = new ModelRenderableFactory(mAssetSystem);
-    shared_ptr<ModelRenderable> modelRenderable = modelFactory->createModel("static-platform.bcosm",
-                                                                            "static-platform-diffuse.png",
-                                                                            "static-platform-model");
-    delete modelFactory;
-    graphicsComponent->addRenderable(modelRenderable);
-
-    // Return instance
-    return entity;
-}
-
-} // namespace JamSpook

src/entities/TrackPieceFactory.h

@@ -1,156 +0,0 @@
-/*
- * TrackPieceFactory.h
- *
- *  Created on: Aug 27, 2020
- *      Author: fredrick
- */
-
-#ifndef ENTITIES_TRACKPIECEFACTORY_H_
-#define ENTITIES_TRACKPIECEFACTORY_H_
-
-#include <string>
-#include <memory>
-#include <functional>
-#include <vector>
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtx/euler_angles.hpp>
-#include <glm/gtx/string_cast.hpp>
-#include <glm/gtx/quaternion.hpp>
-
-#include <ecos/utility/Memory.h>
-#include <ecos/core/IDCache.h>
-#include <ecos/core/Log.h>
-#include <ecos/core/BroadcastObservable.h>
-#include <ecos/core/Message.h>
-#include <ecos/core/Entity.h>
-#include <ecos/core/SceneGraph.h>
-#include <ecos/core/ICCResponseComponent.h>
-#include <ecos/asset/AssetSystem.h>
-#include <ecos/asset/DataManagementMode.h>
-#include <ecos/physics/PhysicsSystem.h>
-#include <ecos/physics/PhysicsComponent.h>
-#include <ecos/physics/ColliderFactory.h>
-#include <ecos/physics/Collider.h>
-#include <ecos/graphics/GraphicsSystem.h>
-#include <ecos/graphics/GraphicsComponent.h>
-#include <ecos/graphics/RenderLayer.h>
-#include <ecos/graphics/TextureFactory.h>
-#include <ecos/graphics/Texture.h>
-#include <ecos/graphics/assets/ShaderAsset.h>
-#include <ecos/graphics/ShaderProgram.h>
-#include <ecos/graphics/ShaderProgramFactory.h>
-#include <ecos/graphics/Material.h>
-#include <ecos/graphics/MaterialFactory.h>
-#include <ecos/graphics/Mesh.h>
-#include <ecos/graphics/MeshFactory.h>
-#include <ecos/graphics/ModelRenderable.h>
-#include <ecos/graphics/ModelRenderableFactory.h>
-#include <ecos/graphics/ShaderType.h>
-
-#include "TrackPiecePhysicsComponent.h"
-
-namespace JamSpook {
-
-using std::string;
-using std::shared_ptr;
-using std::make_shared;
-using std::weak_ptr;
-using std::dynamic_pointer_cast;
-using std::function;
-using std::bind;
-using std::vector;
-
-using glm::vec3;
-using glm::mat4;
-using glm::quat;
-using glm::quat_cast;
-using glm::translate;
-using glm::scale;
-using glm::rotate;
-using glm::eulerAngleXYZ;
-using glm::radians;
-
-using ecos::utility::getShared;
-
-using ecos::core::IDCache;
-using ecos::core::logging::Log;
-using ecos::core::logging::LogLevel;
-using ecos::core::BroadcastObservable;
-using ecos::core::Message;
-using ecos::core::Entity;
-using ecos::core::SceneGraph;
-using ecos::core::ICCResponseComponent;
-
-using ecos::asset::AssetSystem;
-using ecos::asset::DataManagementMode;
-
-using ecos::graphics::GraphicsSystem;
-using ecos::graphics::GraphicsComponent;
-using ecos::graphics::RenderLayer;
-using ecos::graphics::TextureFactory;
-using ecos::graphics::Texture;
-using ecos::graphics::ShaderType;
-using ecos::graphics::ShaderAsset;
-using ecos::graphics::ShaderProgram;
-using ecos::graphics::ShaderProgramFactory;
-using ecos::graphics::Material;
-using ecos::graphics::MaterialFactory;
-using ecos::graphics::Mesh;
-using ecos::graphics::MeshFactory;
-using ecos::graphics::ModelRenderableFactory;
-using ecos::graphics::ModelRenderable;
-
-using ecos::physics::PhysicsSystem;
-using ecos::physics::PhysicsComponent;
-using ecos::physics::ColliderFactory;
-using ecos::physics::Collider;
-
-/// Factory to simplify track piece entity creation
-class TrackPieceFactory
-{
-private:
-    weak_ptr<AssetSystem>    mAssetSystem;
-    weak_ptr<GraphicsSystem> mGraphicsSystem;
-    weak_ptr<PhysicsSystem>  mPhysicsSystem;
-    weak_ptr<RenderLayer>    mRenderLayer;
-
-public:
-    TrackPieceFactory(weak_ptr<AssetSystem>    assetSystem,
-                      weak_ptr<GraphicsSystem> graphicsSystem,
-                      weak_ptr<PhysicsSystem>  physicsSystem,
-                      weak_ptr<RenderLayer>    renderLayer);
-    virtual ~TrackPieceFactory();
-
-    /// Compose a road entity
-    shared_ptr<Entity> createRoad();
-
-    /// Compose a tunnel entity
-    shared_ptr<Entity> createTunnel();
-
-//    /// Compose a tunnel entity
-//    shared_ptr<Entity> createTunnel();
-
-    /// Compose a mountain entity
-    shared_ptr<Entity> createMountain();
-
-    /// Compose a sign entity
-    shared_ptr<Entity> createSign(const string name,
-                                  const string diffuseTextureFilePath,
-                                  vec3 position,
-                                  quat orientation);
-
-    /// Compose a ghost entity
-    shared_ptr<Entity> createGhost(const string name,
-                                   const string diffuseTextureFilePath,
-                                   vec3 position,
-                                   quat orientation,
-                                   float scaling = 1.0f);
-
-    shared_ptr<Entity> createStaticPlatform();
-};
-
-} // namespace JamSpook
-
-#endif // ENTITIES_TRACKPIECEFACTORY_H_

src/entities/TrackPiecePhysicsComponent.cpp

@@ -1,42 +0,0 @@
-/*
- * TrackPiecePhysicsComponent.cpp
- *
- *  Created on: Aug 27, 2020
- *      Author: fredrick
- */
-
-#include "TrackPiecePhysicsComponent.h"
-
-namespace JamSpook {
-
-TrackPiecePhysicsComponent::TrackPiecePhysicsComponent(mat4 transform,
-                                                       shared_ptr<BroadcastObservable<shared_ptr<Message> > > entity,
-                                                       weak_ptr<BroadcastObservable<const milliseconds> > physicsSystem,
-                                                       weak_ptr<BroadcastObservable<shared_ptr<CollisionStateChangeMessage> > > physicsCollisionSubSystem,
-                                                       weak_ptr<BroadcastObservable<shared_ptr<ColliderQueryMessage> > > physicsColliderQuerySubSystem,
-                                                       shared_ptr<Collider> collider):
-        PhysicsComponent(transform,
-                         entity,
-                         physicsSystem,
-                         physicsCollisionSubSystem,
-                         physicsColliderQuerySubSystem,
-                         collider)
-{}
-
-TrackPiecePhysicsComponent::~TrackPiecePhysicsComponent()
-{}
-
-void TrackPiecePhysicsComponent::update(const milliseconds dtms)
-{
-    PhysicsComponent::update(dtms);
-}
-
-void TrackPiecePhysicsComponent::onICCMessage(shared_ptr<Message> message)
-{
-    PhysicsComponent::onICCMessage(message);
-}
-
-void TrackPiecePhysicsComponent::onCollision(const string& tag)
-{}
-
-} // namespace JamSpook

src/entities/TrackPiecePhysicsComponent.h

@@ -1,77 +0,0 @@
-/*
- * TrackPiecePhysicsComponent.h
- *
- *  Created on: Aug 27, 2020
- *      Author: fredrick
- */
-
-#ifndef TRACKPIECEPHYSICSCOMPONENT_H_
-#define TRACKPIECEPHYSICSCOMPONENT_H_
-
-#include <chrono>
-#include <memory>
-#include <cstdint>
-#include <string>
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-
-#include <ecos/core/IDCache.h>
-#include <ecos/core/Log.h>
-#include <ecos/core/Message.h>
-#include <ecos/core/BroadcastObservable.h>
-#include <ecos/physics/PhysicsSystem.h>
-#include <ecos/physics/TransformChangeMessage.h>
-#include <ecos/physics/CollisionStateChangeMessage.h>
-#include <ecos/physics/ColliderQueryMessage.h>
-#include <ecos/physics/PhysicsComponent.h>
-#include <ecos/physics/Collider.h>
-
-namespace JamSpook {
-
-using std::chrono::milliseconds;
-using std::weak_ptr;
-using std::shared_ptr;
-using std::make_shared;
-using std::dynamic_pointer_cast;
-using std::string;
-
-using glm::vec3;
-using glm::mat4;
-using glm::translate;
-using glm::scale;
-
-using ecos::core::IDCache;
-using ecos::core::logging::Log;
-using ecos::core::logging::LogLevel;
-using ecos::core::Message;
-using ecos::core::BroadcastObservable;
-
-using ecos::physics::PhysicsSystem;
-using ecos::physics::PhysicsComponent;
-using ecos::physics::Collider;
-using ecos::physics::TransformChangeMessage;
-using ecos::physics::CollisionStateChangeMessage;
-using ecos::physics::ColliderQueryMessage;
-
-///
-class TrackPiecePhysicsComponent:
-        public PhysicsComponent
-{
-public:
-    TrackPiecePhysicsComponent(mat4 transform,
-                               shared_ptr<BroadcastObservable<shared_ptr<Message> > > entity,
-                               weak_ptr<BroadcastObservable<const milliseconds> > physicsSystem,
-                               weak_ptr<BroadcastObservable<shared_ptr<CollisionStateChangeMessage> > > physicsCollisionSubSystem,
-                               weak_ptr<BroadcastObservable<shared_ptr<ColliderQueryMessage> > > physicsColliderQuerySubSystem,
-                               shared_ptr<Collider> collider);
-    virtual ~TrackPiecePhysicsComponent();
-
-    virtual void update(const milliseconds dtms);
-    virtual void onICCMessage(shared_ptr<Message> message);
-    virtual void onCollision(const string& tag);
-};
-
-} // namespace JamSpook
-
-#endif // TRACKPIECEPHYSICSCOMPONENT_H_