static mesh finish

ROADMAP.txt

@@ -1,7 +1,6 @@
 ------------ Tyra's v2.0 roadmap to publish on GitHub ------------
 
 --- H4570
-- [Renderer] Mesh, StaticMesh, AnimMesh
 - [Renderer] dynamicRenderer, dbufferring during mesh unrolling, simple clip
 - [Renderer] staticRenderer -> remove animation, dbufferring during mesh unrolling, full plane clip
 - [Renderer] Add possibility to on/off frustum check in all pipelines (renderOptions?)

engine/inc/renderer/3d/mesh/dynamic/dynamic_mesh.hpp

@@ -11,8 +11,8 @@
 #pragma once
 
 #include "loaders/3d/builder/mesh_builder_data.hpp"
-#include "./dynamic_mesh_frame.hpp"
+#include "../mesh_frame.hpp"
-#include "./dynamic_mesh_material_frame.hpp"
+#include "../mesh_material_frame.hpp"
 #include "./dynamic_mesh_anim_state.hpp"
 #include "../mesh.hpp"
 
@@ -24,22 +24,12 @@ class DynamicMesh : public Mesh {
   explicit DynamicMesh(const DynamicMesh& mesh);
   ~DynamicMesh();
 
-  /** Returns material, which is a mesh "subgroup". */
-  DynamicMeshMaterial* getMaterial(const u32& i) const { return materials[i]; }
-
-  DynamicMeshMaterial** getMaterials() { return materials; }
-
-  const u32& getMaterialsCount() const { return materialsCount; }
-
   const DynamicMeshAnimState& getAnimState() const { return animState; }
 
-  /** Count of all vertices.  */
-  inline u32 getVertexCount() { return frames[0]->getVertexCount(); }
-
   /** Returns single frame. */
-  DynamicMeshFrame* getFrame(const u32& i) { return frames[i]; }
+  MeshFrame* getFrame(const u32& i) { return frames[i]; }
 
-  DynamicMeshFrame** getFrames() { return frames; }
+  MeshFrame** getFrames() { return frames; }
 
   /** Count of frames. Static object (not animated) will have only 1 frame. */
   const u32& getFramesCount() const { return framesCount; }
@@ -81,11 +71,10 @@ class DynamicMesh : public Mesh {
   const u8& isStayAnimationSet() const { return animState.isStayFrameSet; }
 
  private:
-  void initMesh();
+  void initAnimation();
   DynamicMeshAnimState animState;
-  u32 framesCount, materialsCount;
+  u32 framesCount;
-  DynamicMeshFrame** frames;
+  MeshFrame** frames;
-  DynamicMeshMaterial** materials;
 };
 
 }  // namespace Tyra

engine/inc/renderer/3d/mesh/mesh.hpp

@@ -11,13 +11,16 @@
 #pragma once
 
 #include "math/m4x4.hpp"
+#include "./mesh_material.hpp"
 #include <tamtypes.h>
+#include "debug/debug.hpp"
 
 namespace Tyra {
 
 class Mesh {
  public:
-  Mesh(const u8& isMother);
+  explicit Mesh(const MeshBuilderData& data);
+  explicit Mesh(const Mesh& mesh);
   ~Mesh();
 
   /** Translation matrix */
@@ -38,14 +41,20 @@ class Mesh {
     return reinterpret_cast<Vec4*>(&translation.data[3 * 4]);
   }
 
-  inline void setPosition(const Vec4& v) {
+  void setPosition(const Vec4& v);
-    TYRA_ASSERT(v.w == 1.0F, "Vec4 must be homogeneous");
+
-    reinterpret_cast<Vec4*>(&translation.data[3 * 4])->set(v);
+  /** Returns material, which is a mesh "subgroup". */
-  }
+  MeshMaterial* getMaterial(const u32& i) const { return materials[i]; }
+
+  MeshMaterial** getMaterials() { return materials; }
+
+  const u32& getMaterialsCount() const { return materialsCount; }
 
  protected:
+  void init();
   u8 _isMother;
-  u32 id;
+  u32 id, materialsCount;
+  MeshMaterial** materials;
 };
 
 }  // namespace Tyra

engine/inc/renderer/3d/mesh/mesh_frame.hpp

@@ -10,17 +10,17 @@
 
 #pragma once
 
-#include "./dynamic_mesh_material.hpp"
+#include "./mesh_material.hpp"
 #include "loaders/3d/builder/mesh_builder_data.hpp"
 #include "renderer/3d/bbox/bbox.hpp"
 
 namespace Tyra {
 
-class DynamicMeshFrame {
+class MeshFrame {
  public:
-  explicit DynamicMeshFrame(const MeshBuilderData& data, const u32& index);
+  explicit MeshFrame(const MeshBuilderData& data, const u32& index);
-  explicit DynamicMeshFrame(const DynamicMeshFrame& frame);
+  explicit MeshFrame(const MeshFrame& frame);
-  ~DynamicMeshFrame();
+  ~MeshFrame();
 
   const u32& getId() const { return id; }
   const u32& getVertexCount() const { return vertexCount; }

engine/inc/renderer/3d/mesh/mesh_material.hpp

@@ -12,16 +12,15 @@
 
 #include "debug/debug.hpp"
 #include "loaders/3d/builder/mesh_builder_data.hpp"
-#include "renderer/3d/mesh/dynamic/dynamic_mesh_material_frame.hpp"
+#include "./mesh_material_frame.hpp"
 
 namespace Tyra {
 
-class DynamicMeshMaterial {
+class MeshMaterial {
  public:
-  explicit DynamicMeshMaterial(const MeshBuilderData& data,
+  explicit MeshMaterial(const MeshBuilderData& data, const u32& materialIndex);
-                               const u32& materialIndex);
+  explicit MeshMaterial(const MeshMaterial& material);
-  explicit DynamicMeshMaterial(const DynamicMeshMaterial& material);
+  ~MeshMaterial();
-  ~DynamicMeshMaterial();
 
   Color singleColor;
 
@@ -30,15 +29,13 @@ class DynamicMeshMaterial {
   const u32& getFacesCount() const { return facesCount; }
   const u8& isMother() const { return _isMother; }
   const u8& isSingleColorActivated() const { return singleColorFlag; }
-
   u32* getVertexFaces() const { return vertexFaces; }
   u32* getTextureCoordFaces() const { return textureCoordFaces; }
   u32* getNormalFaces() const { return normalFaces; }
   u32* getColorFaces() const { return normalFaces; }
-  DynamicMeshMaterialFrame* getFrames() const { return *frames; }
+  MeshMaterialFrame* getFrames() const { return *frames; }
 
   const BBox& getBBox(const u32& frame) const;
-
   void setSingleColorFlag(const u8& flag);
 
   void print() const;
@@ -47,7 +44,7 @@ class DynamicMeshMaterial {
   std::string getPrint(const char* name = nullptr) const;
 
  private:
-  DynamicMeshMaterialFrame** frames;
+  MeshMaterialFrame** frames;
 
   std::string _name;
   u8 _isMother, singleColorFlag;

engine/inc/renderer/3d/mesh/mesh_material_frame.hpp

@@ -10,17 +10,17 @@
 
 #pragma once
 
+#include "loaders/3d/builder/mesh_builder_data.hpp"
 #include "./renderer/3d/bbox/bbox.hpp"
 
 namespace Tyra {
 
-class DynamicMeshMaterialFrame {
+class MeshMaterialFrame {
  public:
-  explicit DynamicMeshMaterialFrame(const MeshBuilderData& data,
+  explicit MeshMaterialFrame(const MeshBuilderData& data, const u32& frameIndex,
-                                    const u32& frameIndex,
                              const u32& materialIndex);
-  explicit DynamicMeshMaterialFrame(const DynamicMeshMaterialFrame& frame);
+  explicit MeshMaterialFrame(const MeshMaterialFrame& frame);
-  ~DynamicMeshMaterialFrame();
+  ~MeshMaterialFrame();
 
   const u32& getId() const { return id; }
   const u8& isMother() const { return _isMother; }

engine/inc/renderer/3d/mesh/static/static_mesh.hpp

@@ -0,0 +1,34 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#pragma once
+
+#include "../mesh.hpp"
+#include "../mesh_frame.hpp"
+#include "../mesh_material.hpp"
+
+namespace Tyra {
+
+class StaticMesh : public Mesh {
+ public:
+  StaticMesh(const MeshBuilderData& data);
+  StaticMesh(const StaticMesh& mesh);
+  ~StaticMesh();
+
+  MeshFrame* getFrame() { return frame; }
+
+  /** @returns bounding box object of current frame. */
+  const BBox& getBoundingBox() const { return frame->getBBox(); }
+
+ private:
+  MeshFrame* frame;
+};
+
+}  // namespace Tyra

engine/inc/renderer/3d/pipeline/static/static_pipeline.hpp

@@ -39,24 +39,19 @@ class Stapipeline : public Renderer3DPipeline {
   RendererCore* rendererCore;
   Vec4* colorsCache;
 
-  void addVertices(DynamicMesh* mesh, DynamicMeshMaterial* material,
+  void addVertices(DynamicMesh* mesh, MeshMaterial* material, StapipBag* bag,
-                   StapipBag* bag, DynamicMeshFrame* frameFrom,
+                   MeshFrame* frameFrom, MeshFrame* frameTo) const;
-                   DynamicMeshFrame* frameTo) const;
   StapipInfoBag* getInfoBag(DynamicMesh* mesh, const StapipOptions* options,
                             M4x4* model) const;
-  StapipColorBag* getColorBag(DynamicMesh* mesh, DynamicMeshMaterial* material,
+  StapipColorBag* getColorBag(DynamicMesh* mesh, MeshMaterial* material,
-                              DynamicMeshFrame* frameFrom,
+                              MeshFrame* frameFrom, MeshFrame* frameTo) const;
-                              DynamicMeshFrame* frameTo) const;
+  StapipTextureBag* getTextureBag(DynamicMesh* mesh, MeshMaterial* material,
-  StapipTextureBag* getTextureBag(DynamicMesh* mesh,
+                                  MeshFrame* frameFrom, MeshFrame* frameTo);
-                                  DynamicMeshMaterial* material,
+  StapipLightingBag* getLightingBag(DynamicMesh* mesh, MeshMaterial* material,
-                                  DynamicMeshFrame* frameFrom,
+                                    M4x4* model, MeshFrame* frameFrom,
-                                  DynamicMeshFrame* frameTo);
+                                    MeshFrame* frameTo,
-  StapipLightingBag* getLightingBag(DynamicMesh* mesh,
-                                    DynamicMeshMaterial* material, M4x4* model,
-                                    DynamicMeshFrame* frameFrom,
-                                    DynamicMeshFrame* frameTo,
                                     const StapipOptions* options) const;
-  void deallocDrawBags(StapipBag* bag, DynamicMeshMaterial* material) const;
+  void deallocDrawBags(StapipBag* bag, MeshMaterial* material) const;
 
   void setLightingColorsCache(StapipLightingOptions* lightingOptions);
 };

engine/src/renderer/3d/mesh/dynamic/dynamic_mesh.cpp

@@ -15,41 +15,28 @@
 
 namespace Tyra {
 
-DynamicMesh::DynamicMesh(const MeshBuilderData& data) : Mesh(true) {
+DynamicMesh::DynamicMesh(const MeshBuilderData& data) : Mesh(data) {
+  TYRA_ASSERT(framesCount > 1, "Frames count must be greater than 1");
+
   framesCount = data.framesCount;
-  TYRA_ASSERT(framesCount > 0, "Frames count must be greater than 0");
 
-  materialsCount = data.materialsCount;
+  frames = new MeshFrame*[framesCount];
-  TYRA_ASSERT(materialsCount > 0, "Materials count must be greater than 0");
-
-  frames = new DynamicMeshFrame*[framesCount];
   for (u32 i = 0; i < framesCount; i++) {
-    frames[i] = new DynamicMeshFrame(data, i);
+    frames[i] = new MeshFrame(data, i);
   }
 
-  materials = new DynamicMeshMaterial*[materialsCount];
+  initAnimation();
-  for (u32 i = 0; i < materialsCount; i++) {
-    materials[i] = new DynamicMeshMaterial(data, i);
-  }
-
-  initMesh();
 }
 
-DynamicMesh::DynamicMesh(const DynamicMesh& mesh) : Mesh(false) {
+DynamicMesh::DynamicMesh(const DynamicMesh& mesh) : Mesh(mesh) {
   framesCount = mesh.framesCount;
-  materialsCount = mesh.materialsCount;
 
-  frames = new DynamicMeshFrame*[framesCount];
+  frames = new MeshFrame*[framesCount];
   for (u32 i = 0; i < framesCount; i++) {
-    frames[i] = new DynamicMeshFrame(*mesh.frames[i]);
+    frames[i] = new MeshFrame(*mesh.frames[i]);
   }
 
-  materials = new DynamicMeshMaterial*[materialsCount];
+  initAnimation();
-  for (u32 i = 0; i < materialsCount; i++) {
-    materials[i] = new DynamicMeshMaterial(*mesh.materials[i]);
-  }
-
-  initMesh();
 }
 
 DynamicMesh::~DynamicMesh() {
@@ -57,15 +44,9 @@ DynamicMesh::~DynamicMesh() {
     delete frames[i];
   }
   delete[] frames;
-
-  for (u32 i = 0; i < materialsCount; i++) {
-    delete materials[i];
-
-    delete[] materials;
-  }
 }
 
-void DynamicMesh::initMesh() {
+void DynamicMesh::initAnimation() {
   animState.startFrame = 0;
   animState.endFrame = 0;
   animState.interpolation = 0.0F;

engine/src/renderer/3d/mesh/mesh.cpp

@@ -13,14 +13,53 @@
 
 namespace Tyra {
 
-Mesh::Mesh(const u8& isMother) {
+Mesh::Mesh(const MeshBuilderData& data) {
-  id = rand() % 1000000;
+  init();
-  _isMother = isMother;
+
-  translation.translate(Vec4(0.0F, 0.0F, 0.0F, 1.0F));
+  TYRA_ASSERT(data.materialsCount > 0,
+              "Materials count must be greater than 0");
+
+  materialsCount = data.materialsCount;
+  materials = new MeshMaterial*[materialsCount];
+
+  for (u32 i = 0; i < materialsCount; i++) {
+    materials[i] = new MeshMaterial(data, i);
+  }
+
+  _isMother = true;
+}
+
+Mesh::Mesh(const Mesh& mesh) {
+  init();
+
+  materialsCount = mesh.materialsCount;
+  materials = new MeshMaterial*[materialsCount];
+
+  for (u32 i = 0; i < materialsCount; i++) {
+    materials[i] = new MeshMaterial(*mesh.materials[i]);
+  }
+
+  _isMother = false;
 }
 
 M4x4 Mesh::getModelMatrix() const { return translation * rotation * scale; }
 
-Mesh::~Mesh() {}
+Mesh::~Mesh() {
+  for (u32 i = 0; i < materialsCount; i++) {
+    delete materials[i];
+  }
+  delete[] materials;
+}
+
+void Mesh::init() {
+  id = rand() % 1000000;
+  materialsCount = 0;
+  translation.translate(Vec4(0.0F, 0.0F, 0.0F, 1.0F));
+}
+
+void Mesh::setPosition(const Vec4& v) {
+  TYRA_ASSERT(v.w == 1.0F, "Vec4 must be homogeneous");
+  reinterpret_cast<Vec4*>(&translation.data[3 * 4])->set(v);
+}
 
 }  // namespace Tyra

engine/src/renderer/3d/mesh/mesh_frame.cpp

@@ -15,12 +15,11 @@
 #include <string>
 #include "math/vec4.hpp"
 #include "renderer/models/color.hpp"
-#include "renderer/3d/mesh/dynamic/dynamic_mesh_frame.hpp"
+#include "renderer/3d/mesh/mesh_frame.hpp"
 
 namespace Tyra {
 
-DynamicMeshFrame::DynamicMeshFrame(const MeshBuilderData& data,
+MeshFrame::MeshFrame(const MeshBuilderData& data, const u32& index) {
-                                   const u32& index) {
   TYRA_ASSERT(index < data.framesCount && index >= 0, "Provided index \"",
               index, "\" is out of range");
 
@@ -64,7 +63,7 @@ DynamicMeshFrame::DynamicMeshFrame(const MeshBuilderData& data,
   _isMother = true;
 }
 
-DynamicMeshFrame::DynamicMeshFrame(const DynamicMeshFrame& frame) {
+MeshFrame::MeshFrame(const MeshFrame& frame) {
   id = rand() % 1000000;
 
   vertices = frame.vertices;
@@ -82,7 +81,7 @@ DynamicMeshFrame::DynamicMeshFrame(const DynamicMeshFrame& frame) {
   _isMother = false;
 }
 
-DynamicMeshFrame::~DynamicMeshFrame() {
+MeshFrame::~MeshFrame() {
   if (_isMother) {
     delete[] vertices;
     if (normals) delete[] normals;
@@ -92,17 +91,17 @@ DynamicMeshFrame::~DynamicMeshFrame() {
   }
 }
 
-void DynamicMeshFrame::print() const {
+void MeshFrame::print() const {
   auto text = getPrint(nullptr);
   printf("%s\n", text.c_str());
 }
 
-void DynamicMeshFrame::print(const char* name) const {
+void MeshFrame::print(const char* name) const {
   auto text = getPrint(name);
   printf("%s\n", text.c_str());
 }
 
-std::string DynamicMeshFrame::getPrint(const char* name) const {
+std::string MeshFrame::getPrint(const char* name) const {
   std::stringstream res;
   if (name) {
     res << name << "(";

engine/src/renderer/3d/mesh/mesh_material.cpp

@@ -13,11 +13,11 @@
 #include <string>
 #include <cstdlib>
 #include <iomanip>
-#include "renderer/3d/mesh/dynamic/dynamic_mesh_material.hpp"
+#include "renderer/3d/mesh/mesh_material.hpp"
 
 namespace Tyra {
 
-DynamicMeshMaterial::DynamicMeshMaterial(const MeshBuilderData& data,
+MeshMaterial::MeshMaterial(const MeshBuilderData& data,
                            const u32& materialIndex)
     : singleColor(false) {
   TYRA_ASSERT(materialIndex < data.materialsCount && materialIndex >= 0,
@@ -58,18 +58,18 @@ DynamicMeshMaterial::DynamicMeshMaterial(const MeshBuilderData& data,
   TYRA_ASSERT(facesCount > 0, "Faces count must be greater than 0");
 
   _name = data.materials[materialIndex]->name;
-  TYRA_ASSERT(_name.length() > 0, "DynamicMeshMaterial name cannot be empty");
+  TYRA_ASSERT(_name.length() > 0, "MeshMaterial name cannot be empty");
 
   framesCount = data.framesCount;
-  frames = new DynamicMeshMaterialFrame*[framesCount];
+  frames = new MeshMaterialFrame*[framesCount];
   for (u32 i = 0; i < framesCount; i++) {
-    frames[i] = new DynamicMeshMaterialFrame(data, i, materialIndex);
+    frames[i] = new MeshMaterialFrame(data, i, materialIndex);
   }
 
   _isMother = true;
 }
 
-DynamicMeshMaterial::DynamicMeshMaterial(const DynamicMeshMaterial& mesh) {
+MeshMaterial::MeshMaterial(const MeshMaterial& mesh) {
   id = rand() % 1000000;
 
   vertexFaces = mesh.vertexFaces;
@@ -83,15 +83,15 @@ DynamicMeshMaterial::DynamicMeshMaterial(const DynamicMeshMaterial& mesh) {
 
   singleColor.set(128.0F, 128.0F, 128.0F, 128.0F);
 
-  frames = new DynamicMeshMaterialFrame*[framesCount];
+  frames = new MeshMaterialFrame*[framesCount];
   for (u32 i = 0; i < framesCount; i++) {
-    frames[i] = new DynamicMeshMaterialFrame(*mesh.frames[i]);
+    frames[i] = new MeshMaterialFrame(*mesh.frames[i]);
   }
 
   _isMother = false;
 }
 
-DynamicMeshMaterial::~DynamicMeshMaterial() {
+MeshMaterial::~MeshMaterial() {
   if (_isMother) {
     delete[] vertexFaces;
     if (textureCoordFaces) delete[] textureCoordFaces;
@@ -105,11 +105,11 @@ DynamicMeshMaterial::~DynamicMeshMaterial() {
   delete[] frames;
 }
 
-const BBox& DynamicMeshMaterial::getBBox(const u32& frame) const {
+const BBox& MeshMaterial::getBBox(const u32& frame) const {
   return frames[frame]->getBBox();
 }
 
-void DynamicMeshMaterial::setSingleColorFlag(const u8& flag) {
+void MeshMaterial::setSingleColorFlag(const u8& flag) {
   TYRA_ASSERT(
       colorFaces != nullptr,
       "Colors and color faces are required to use color-per-vertex mode");
@@ -117,22 +117,22 @@ void DynamicMeshMaterial::setSingleColorFlag(const u8& flag) {
   singleColorFlag = flag;
 }
 
-void DynamicMeshMaterial::print() const {
+void MeshMaterial::print() const {
   auto text = getPrint(nullptr);
   printf("%s\n", text.c_str());
 }
 
-void DynamicMeshMaterial::print(const char* name) const {
+void MeshMaterial::print(const char* name) const {
   auto text = getPrint(name);
   printf("%s\n", text.c_str());
 }
 
-std::string DynamicMeshMaterial::getPrint(const char* name) const {
+std::string MeshMaterial::getPrint(const char* name) const {
   std::stringstream res;
   if (name) {
     res << name << "(";
   } else {
-    res << "DynamicMeshMaterial(";
+    res << "MeshMaterial(";
   }
 
   res << std::endl;

engine/src/renderer/3d/mesh/mesh_material_frame.cpp

@@ -13,11 +13,11 @@
 #include <tamtypes.h>
 #include "renderer/models/color.hpp"
 #include "loaders/3d/builder/mesh_builder_data.hpp"
-#include "renderer/3d/mesh/dynamic/dynamic_mesh_material_frame.hpp"
+#include "renderer/3d/mesh/mesh_material_frame.hpp"
 
 namespace Tyra {
 
-DynamicMeshMaterialFrame::DynamicMeshMaterialFrame(const MeshBuilderData& data,
+MeshMaterialFrame::MeshMaterialFrame(const MeshBuilderData& data,
                                      const u32& frameIndex,
                                      const u32& materialIndex) {
   TYRA_ASSERT(frameIndex < data.framesCount && frameIndex >= 0,
@@ -34,8 +34,7 @@ DynamicMeshMaterialFrame::DynamicMeshMaterialFrame(const MeshBuilderData& data,
   _isMother = true;
 }
 
-DynamicMeshMaterialFrame::DynamicMeshMaterialFrame(
+MeshMaterialFrame::MeshMaterialFrame(const MeshMaterialFrame& frame) {
-    const DynamicMeshMaterialFrame& frame) {
   id = rand() % 1000000;
 
   bbox = frame.bbox;
@@ -43,7 +42,7 @@ DynamicMeshMaterialFrame::DynamicMeshMaterialFrame(
   _isMother = false;
 }
 
-DynamicMeshMaterialFrame::~DynamicMeshMaterialFrame() {
+MeshMaterialFrame::~MeshMaterialFrame() {
   if (_isMother) {
     delete bbox;
   }

engine/src/renderer/3d/mesh/static/static_mesh.cpp

@@ -0,0 +1,27 @@
+
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2020, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#include "renderer/3d/mesh/static/static_mesh.hpp"
+
+namespace Tyra {
+
+StaticMesh::StaticMesh(const MeshBuilderData& data) : Mesh(data) {
+  TYRA_ASSERT(data.framesCount == 1, "Static meshes must have only one frame");
+  frame = new MeshFrame(data, 0);
+}
+
+StaticMesh::StaticMesh(const StaticMesh& mesh) : Mesh(mesh) {
+  frame = new MeshFrame(*mesh.frame);
+}
+
+StaticMesh::~StaticMesh() { delete frame; }
+
+}  // namespace Tyra

engine/src/renderer/3d/pipeline/static/static_pipeline.cpp

@@ -26,13 +26,12 @@ void Stapipeline::onUse() { core.reinitStandardVU1Programs(); }
 void Stapipeline::render(DynamicMesh* mesh, const StapipOptions* options) {
   auto model = mesh->getModelMatrix();
 
-  DynamicMeshFrame* frameFrom =
+  MeshFrame* frameFrom = mesh->getFramesCount() > 0
-      mesh->getFramesCount() > 0
                              ? mesh->getFrame(mesh->getCurrentAnimationFrame())
                              : mesh->getFrame(0);
 
-  DynamicMeshFrame* frameTo =
+  MeshFrame* frameTo = mesh->getFramesCount() > 0
-      mesh->getFramesCount() > 0 ? mesh->getFrame(mesh->getNextAnimationFrame())
+                           ? mesh->getFrame(mesh->getNextAnimationFrame())
                            : nullptr;
 
   auto* infoBag = getInfoBag(mesh, options, &model);
@@ -66,9 +65,9 @@ void Stapipeline::render(DynamicMesh* mesh, const StapipOptions* options) {
   delete infoBag;
 }
 
-void Stapipeline::addVertices(DynamicMesh* mesh, DynamicMeshMaterial* material,
+void Stapipeline::addVertices(DynamicMesh* mesh, MeshMaterial* material,
-                              StapipBag* bag, DynamicMeshFrame* frameFrom,
+                              StapipBag* bag, MeshFrame* frameFrom,
-                              DynamicMeshFrame* frameTo) const {
+                              MeshFrame* frameTo) const {
   bag->count = material->getFacesCount();
   bag->vertices = new Vec4[bag->count];
 
@@ -107,9 +106,9 @@ StapipInfoBag* Stapipeline::getInfoBag(DynamicMesh* mesh,
 }
 
 StapipColorBag* Stapipeline::getColorBag(DynamicMesh* mesh,
-                                         DynamicMeshMaterial* material,
+                                         MeshMaterial* material,
-                                         DynamicMeshFrame* frameFrom,
+                                         MeshFrame* frameFrom,
-                                         DynamicMeshFrame* frameTo) const {
+                                         MeshFrame* frameTo) const {
   auto* result = new StapipColorBag();
 
   if (material->isSingleColorActivated()) {
@@ -135,9 +134,9 @@ StapipColorBag* Stapipeline::getColorBag(DynamicMesh* mesh,
 }
 
 StapipTextureBag* Stapipeline::getTextureBag(DynamicMesh* mesh,
-                                             DynamicMeshMaterial* material,
+                                             MeshMaterial* material,
-                                             DynamicMeshFrame* frameFrom,
+                                             MeshFrame* frameFrom,
-                                             DynamicMeshFrame* frameTo) {
+                                             MeshFrame* frameTo) {
   if (!material->getTextureCoordFaces()) return nullptr;
 
   auto* result = new StapipTextureBag();
@@ -165,8 +164,8 @@ StapipTextureBag* Stapipeline::getTextureBag(DynamicMesh* mesh,
 }
 
 StapipLightingBag* Stapipeline::getLightingBag(
-    DynamicMesh* mesh, DynamicMeshMaterial* material, M4x4* model,
+    DynamicMesh* mesh, MeshMaterial* material, M4x4* model,
-    DynamicMeshFrame* frameFrom, DynamicMeshFrame* frameTo,
+    MeshFrame* frameFrom, MeshFrame* frameTo,
     const StapipOptions* options) const {
   if (!material->getNormalFaces() || options == nullptr ||
       options->lighting == nullptr)
@@ -204,7 +203,7 @@ void Stapipeline::setLightingColorsCache(
 }
 
 void Stapipeline::deallocDrawBags(StapipBag* bag,
-                                  DynamicMeshMaterial* material) const {
+                                  MeshMaterial* material) const {
   if (bag->color->many) {
     delete[] bag->color->many;
   }