New ship model

linguine/CMakeLists.txt

@@ -30,6 +30,7 @@ add_library(linguine
         src/systems/EnemySpawnSystem.cpp
         src/systems/EventSystem.cpp
         src/systems/FallerSystem.cpp
+        src/systems/FireSystem.cpp
         src/systems/FpsSystem.cpp
         src/systems/GestureRecognitionSystem.cpp
         src/systems/GridPositionSystem.cpp

linguine/include/renderer/mesh/MeshType.h

@@ -3,10 +3,14 @@
 namespace linguine {
 
 enum MeshType {
+  Booster,
+  Cockpit,
   Mine,
   Plus,
   Quad,
-  Triangle
+  Ship,
+  Triangle,
+  Wing
 };
 
 }  // namespace linguine

linguine/src/components/Fire.h

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace linguine {
+
+struct Fire {};
+
+}  // namespace linguine

linguine/src/scenes/InfiniteRunnerScene.h

@@ -14,6 +14,7 @@
 #include "components/CircleCollider.h"
 #include "components/Drawable.h"
 #include "components/Emitter.h"
+#include "components/Fire.h"
 #include "components/Friendly.h"
 #include "components/GlobalCooldown.h"
 #include "components/Health.h"
@@ -39,6 +40,7 @@
 #include "systems/CollisionSystem.h"
 #include "systems/CooldownProgressSystem.h"
 #include "systems/EffectSystem.h"
+#include "systems/FireSystem.h"
 #include "systems/FpsSystem.h"
 #include "systems/GestureRecognitionSystem.h"
 #include "systems/HealthProgressSystem.h"
@@ -74,6 +76,7 @@ class InfiniteRunnerScene : public Scene {
       registerSystem(std::make_unique<CooldownProgressSystem>(getEntityManager()));
       registerSystem(std::make_unique<CastSystem>(getEntityManager()));
       registerSystem(std::make_unique<ParticleSystem>(getEntityManager()));
+      registerSystem(std::make_unique<FireSystem>(getEntityManager()));
 
       // Scene-specific
       registerSystem(std::make_unique<SpawnSystem>(getEntityManager(), serviceLocator.get<Renderer>()));
@@ -147,20 +150,135 @@ class InfiniteRunnerScene : public Scene {
         player->acceleration = 0.05f + 0.02f * saveManager.getRank(3);
         player->maxSpeed = 20.0f;
 
-        playerEntity->add<Transform>();
+        auto transform = playerEntity->add<Transform>();
+        transform->scale = glm::vec3(2.0f);
+        transform->position.z = 0.1f;
+
         playerEntity->add<PhysicalState>();
-        playerEntity->add<CircleCollider>();
+
+        auto circleCollider = playerEntity->add<CircleCollider>();
+        circleCollider->radius = transform->scale.x / 2.0f;
+
         playerEntity->add<Velocity>();
         playerEntity->add<Trigger>();
 
         auto drawable = playerEntity->add<Drawable>();
         drawable->feature = new ColoredFeature();
-        drawable->feature->meshType = Triangle;
+        drawable->feature->meshType = Ship;
         drawable->renderable = renderer.create(std::unique_ptr<ColoredFeature>(drawable->feature));
         drawable.setRemovalListener([drawable](const Entity e) {
           drawable->renderable->destroy();
         });
 
+        {
+          auto wingEntity = createEntity();
+
+          auto wingTransform = wingEntity->add<Transform>();
+          wingTransform->scale = transform->scale;
+          wingTransform->position.z = 1.0f;
+
+          wingEntity->add<PhysicalState>();
+
+          auto attachment = wingEntity->add<Attachment>();
+          attachment->parentId = playerEntity->getId();
+
+          auto wingDrawable = wingEntity->add<Drawable>();
+          wingDrawable->feature = new ColoredFeature();
+          wingDrawable->feature->meshType = Wing;
+          wingDrawable->feature->color = { 0.78354f, 0.78354f, 0.78354f };
+          wingDrawable->renderable = renderer.create(std::unique_ptr<ColoredFeature>(wingDrawable->feature));
+          wingDrawable.setRemovalListener([wingDrawable](const Entity e) {
+            wingDrawable->renderable->destroy();
+          });
+        }
+
+        {
+          auto cockpitEntity = createEntity();
+
+          auto cockpitTransform = cockpitEntity->add<Transform>();
+          cockpitTransform->scale = transform->scale;
+
+          cockpitEntity->add<PhysicalState>();
+
+          auto attachment = cockpitEntity->add<Attachment>();
+          attachment->parentId = playerEntity->getId();
+
+          auto cockpitDrawable = cockpitEntity->add<Drawable>();
+          cockpitDrawable->feature = new ColoredFeature();
+          cockpitDrawable->feature->meshType = Cockpit;
+          cockpitDrawable->feature->color = { 0.007f, 0.01521f, 0.04667f };
+          cockpitDrawable->renderable = renderer.create(std::unique_ptr<ColoredFeature>(cockpitDrawable->feature));
+          cockpitDrawable.setRemovalListener([cockpitDrawable](const Entity e) {
+            cockpitDrawable->renderable->destroy();
+          });
+        }
+
+        {
+          auto boosterEntity = createEntity();
+
+          auto boosterTransform = boosterEntity->add<Transform>();
+          boosterTransform->scale = transform->scale;
+
+          boosterEntity->add<PhysicalState>();
+
+          auto attachment = boosterEntity->add<Attachment>();
+          attachment->parentId = playerEntity->getId();
+
+          auto boosterDrawable = boosterEntity->add<Drawable>();
+          boosterDrawable->feature = new ColoredFeature();
+          boosterDrawable->feature->meshType = Booster;
+          boosterDrawable->feature->color = { 0.0f, 0.0f, 0.0f };
+          boosterDrawable->renderable = renderer.create(std::unique_ptr<ColoredFeature>(boosterDrawable->feature));
+          boosterDrawable.setRemovalListener([boosterDrawable](const Entity e) {
+            boosterDrawable->renderable->destroy();
+          });
+        }
+
+        {
+          auto engineFireEntity = createEntity();
+          engineFireEntity->add<Fire>();
+
+          auto engineFireTransform = engineFireEntity->add<Transform>();
+          engineFireTransform->position.z = 1.0f;
+
+          engineFireEntity->add<PhysicalState>();
+
+          auto attachment = engineFireEntity->add<Attachment>();
+          attachment->parentId = playerEntity->getId();
+          attachment->offset = { -0.13f * transform->scale.x, -0.24f * transform->scale.y};
+
+          auto circle = engineFireEntity->add<Circle>();
+          circle->feature = new CircleFeature();
+          circle->feature->color = { 0.97345f, 0.36625f, 0.00561f };
+          circle->renderable = renderer.create(std::unique_ptr<CircleFeature>(circle->feature));
+          circle.setRemovalListener([circle](const Entity e) {
+            circle->renderable->destroy();
+          });
+        }
+
+        {
+          auto engineFireEntity = createEntity();
+          engineFireEntity->add<Fire>();
+
+          auto engineFireTransform = engineFireEntity->add<Transform>();
+          engineFireTransform->scale = glm::vec3(0.25f);
+          engineFireTransform->position.z = 1.0f;
+
+          engineFireEntity->add<PhysicalState>();
+
+          auto attachment = engineFireEntity->add<Attachment>();
+          attachment->parentId = playerEntity->getId();
+          attachment->offset = { 0.13f * transform->scale.x, -0.24f * transform->scale.y};
+
+          auto circle = engineFireEntity->add<Circle>();
+          circle->feature = new CircleFeature();
+          circle->feature->color = { 0.97345f, 0.36625f, 0.00561f };
+          circle->renderable = renderer.create(std::unique_ptr<CircleFeature>(circle->feature));
+          circle.setRemovalListener([circle](const Entity e) {
+            circle->renderable->destroy();
+          });
+        }
+
         auto party = playerEntity->add<Party>();
 
         for (auto i = 0; i < saveManager.getRank(0) + 1; ++i) {
@@ -184,21 +302,28 @@ class InfiniteRunnerScene : public Scene {
 
           auto playerTransform = playerEntity->get<Transform>();
 
-          auto randomScale = std::uniform_real_distribution(0.1f, 0.5f);
-          auto randomX = std::uniform_real_distribution(-0.15f, 0.15f);
+          auto randomScale = std::uniform_real_distribution(0.125f * playerTransform->scale.x, 0.25f * playerTransform->scale.x);
+          auto randomX = std::uniform_real_distribution(-0.2f * playerTransform->scale.x, 0.2f * playerTransform->scale.y);
 
           auto transform = particleEntity->add<Transform>();
           transform->scale = glm::vec3(randomScale(_random));
-          transform->position = { playerTransform->position.x + randomX(_random), playerTransform->position.y - 0.75f, 2.0f };
+          transform->position = { playerTransform->position.x + randomX(_random), playerTransform->position.y - 0.45f * playerTransform->scale.y, 2.0f };
+
+          auto randomColor = std::uniform_int_distribution(0, 1);
 
           auto circle = particleEntity->add<Circle>();
           circle->feature = new CircleFeature();
+
+          if (randomColor(_random) > 0) {
+            circle->feature->color = { 0.78354f, 0.78354f, 0.78354f };
+          }
+
           circle->renderable = renderer.create(std::unique_ptr<CircleFeature>(circle->feature));
           circle.setRemovalListener([circle](const Entity e) {
             circle->renderable->destroy();
           });
         });
-        emitter->frequency = 0.05f;
+        emitter->frequency = 0.035f;
       }
 
       // Shields Text

linguine/src/systems/FireSystem.cpp

@@ -0,0 +1,17 @@
+#include "FireSystem.h"
+
+#include "components/Fire.h"
+#include "components/Transform.h"
+
+namespace linguine {
+
+void FireSystem::update(float deltaTime) {
+  findEntities<Fire, Transform>()->each([this](const Entity& entity) {
+    auto transform = entity.get<Transform>();
+
+    auto randomScale = std::uniform_real_distribution(0.2f, 0.3f);
+    transform->scale = glm::vec3(randomScale(_random));
+  });
+}
+
+}  // namespace linguine

linguine/src/systems/FireSystem.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "System.h"
+
+#include <random>
+
+namespace linguine {
+
+class FireSystem : public System {
+  public:
+    explicit FireSystem(EntityManager& entityManager) : System(entityManager) {}
+
+    void update(float deltaTime) override;
+
+    void fixedUpdate(float fixedDeltaTime) override {}
+
+  private:
+    std::random_device _random;
+};
+
+}  // namespace linguine

renderers/metal/CMakeLists.txt

@@ -5,11 +5,15 @@ add_library(metal
         src/features/ProgressFeatureRenderer.cpp
         src/features/SelectableFeatureRenderer.cpp
         src/features/TextFeatureRenderer.cpp
+        src/mesh/BoosterMesh.cpp
+        src/mesh/CockpitMesh.cpp
         src/mesh/MeshRegistry.cpp
         src/mesh/MineMesh.cpp
         src/mesh/PlusMesh.cpp
         src/mesh/QuadMesh.cpp
+        src/mesh/ShipMesh.cpp
         src/mesh/TriangleMesh.cpp
+        src/mesh/WingMesh.cpp
 )
 
 target_include_directories(metal PUBLIC include)

renderers/metal/src/mesh/BoosterMesh.cpp

@@ -0,0 +1,48 @@
+#include "BoosterMesh.h"
+
+#include <simd/simd.h>
+
+namespace linguine::render {
+
+BoosterMesh::BoosterMesh(MTL::Device& device) {
+  simd::float2 positions[] = {
+      // Left Booster A
+      { -0.2f, -0.2f },
+      { -0.05f, -0.2f },
+      { -0.05f, -0.3f },
+
+      // Left Booster B
+      { -0.05f, -0.2f },
+      { -0.2f, -0.2f },
+      { -0.2f, -0.15f },
+
+      // Right Booster A
+      { 0.05f, -0.2f },
+      { 0.2f, -0.2f },
+      { 0.05f, -0.3f },
+
+      // Right Booster B
+      { 0.2f, -0.2f },
+      { 0.05f, -0.2f },
+      { 0.2f, -0.15f }
+  };
+
+  const auto positionsBufferSize = std::size(positions) * sizeof(simd::float2);
+  _vertexPositionsBuffer = device.newBuffer(positionsBufferSize, MTL::ResourceStorageModeShared);
+
+  memcpy(_vertexPositionsBuffer->contents(), positions, positionsBufferSize);
+}
+
+BoosterMesh::~BoosterMesh() {
+  _vertexPositionsBuffer->release();
+}
+
+void BoosterMesh::bind(MTL::RenderCommandEncoder& encoder) {
+  encoder.setVertexBuffer(_vertexPositionsBuffer, 0, 0);
+}
+
+void BoosterMesh::draw(MTL::RenderCommandEncoder& encoder) {
+  encoder.drawPrimitives(MTL::PrimitiveType::PrimitiveTypeTriangle, NS::UInteger(0), NS::UInteger(12));
+}
+
+}  // namespace linguine::render

renderers/metal/src/mesh/BoosterMesh.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Mesh.h"
+
+namespace linguine::render {
+
+class BoosterMesh : public Mesh {
+  public:
+    explicit BoosterMesh(MTL::Device& device);
+
+    ~BoosterMesh() override;
+
+    void bind(MTL::RenderCommandEncoder& encoder) override;
+
+    void draw(MTL::RenderCommandEncoder& encoder) override;
+
+  private:
+    MTL::Buffer* _vertexPositionsBuffer;
+};
+
+}  // namespace linguine::render

renderers/metal/src/mesh/CockpitMesh.cpp

@@ -0,0 +1,36 @@
+#include "CockpitMesh.h"
+
+#include <simd/simd.h>
+
+namespace linguine::render {
+
+CockpitMesh::CockpitMesh(MTL::Device& device) {
+  simd::float2 positions[] = {
+      { 0.0f, 0.2f },
+      { 0.1f, -0.1f },
+      { -0.1f, -0.1f },
+
+      { -0.1f, -0.1f },
+      { 0.1f, -0.1f },
+      { 0.0f, -0.15f }
+  };
+
+  const auto positionsBufferSize = std::size(positions) * sizeof(simd::float2);
+  _vertexPositionsBuffer = device.newBuffer(positionsBufferSize, MTL::ResourceStorageModeShared);
+
+  memcpy(_vertexPositionsBuffer->contents(), positions, positionsBufferSize);
+}
+
+CockpitMesh::~CockpitMesh() {
+  _vertexPositionsBuffer->release();
+}
+
+void CockpitMesh::bind(MTL::RenderCommandEncoder& encoder) {
+  encoder.setVertexBuffer(_vertexPositionsBuffer, 0, 0);
+}
+
+void CockpitMesh::draw(MTL::RenderCommandEncoder& encoder) {
+  encoder.drawPrimitives(MTL::PrimitiveType::PrimitiveTypeTriangle, NS::UInteger(0), NS::UInteger(6));
+}
+
+}  // namespace linguine::render