src/model/composite.cpp

   1 #include "CompositeModel.hpp"
   2 #include "CompositeInstance.hpp"
   3 #include "Skeletons.hpp"
   4
   5 #include "EntityModel.hpp"
   6 #include "shapes.hpp"
   7 #include "../graphics/DirectionalLighting.hpp"
   8
   9 #include <glm/gtx/quaternion.hpp>
  10
  11
  12 namespace blank {
  13
  14 CompositeModel::CompositeModel()
  15 : node_model(nullptr)
  16 , position(0.0f)
  17 , orientation(1.0f, 0.0f, 0.0f, 0.0f)
  18 , parts() {
  19
  20 }
  21
  22
  23 CompositeModel &CompositeModel::AddPart() {
  24         parts.emplace_back();
  25         parts.back().parent = this;
  26         return parts.back();
  27 }
  28
  29
  30 glm::mat4 CompositeModel::LocalTransform() const noexcept {
  31         glm::mat4 transform(toMat4(orientation));
  32         transform[3].x = position.x;
  33         transform[3].y = position.y;
  34         transform[3].z = position.z;
  35         return transform;
  36 }
  37
  38 glm::mat4 CompositeModel::GlobalTransform() const noexcept {
  39         if (HasParent()) {
  40                 return Parent().GlobalTransform() * LocalTransform();
  41         } else {
  42                 return LocalTransform();
  43         }
  44 }
  45
  46
  47 void CompositeModel::Instantiate(CompositeInstance &inst) const {
  48         inst.part_model = this;
  49         inst.position = position;
  50         inst.orientation = orientation;
  51         inst.parts.clear();
  52         inst.parts.reserve(parts.size());
  53         for (const CompositeModel &part : parts) {
  54                 part.Instantiate(inst.AddPart());
  55         }
  56 }
  57
  58
  59 CompositeInstance::CompositeInstance()
  60 : part_model(nullptr)
  61 , parent(nullptr)
  62 , position(0.0f)
  63 , orientation(1.0f, 0.0f, 0.0f, 0.0f)
  64 , parts() {
  65
  66 }
  67
  68
  69 CompositeInstance &CompositeInstance::AddPart() {
  70         parts.emplace_back();
  71         parts.back().parent = this;
  72         return parts.back();
  73 }
  74
  75
  76 glm::mat4 CompositeInstance::LocalTransform() const noexcept {
  77         glm::mat4 transform(toMat4(orientation));
  78         transform[3].x = position.x;
  79         transform[3].y = position.y;
  80         transform[3].z = position.z;
  81         return transform;
  82 }
  83
  84 glm::mat4 CompositeInstance::GlobalTransform() const noexcept {
  85         if (HasParent()) {
  86                 return Parent().GlobalTransform() * LocalTransform();
  87         } else {
  88                 return LocalTransform();
  89         }
  90 }
  91
  92
  93 void CompositeInstance::Render(const glm::mat4 &M, DirectionalLighting &prog) const {
  94         glm::mat4 transform(M * LocalTransform());
  95         if (part_model->HasNodeModel()) {
  96                 prog.SetM(transform);
  97                 part_model->NodeModel().Draw();
  98         }
  99         for (const CompositeInstance &part : parts) {
 100                 part.Render(transform, prog);
 101         }
 102 }
 103
 104
 105 Skeletons::Skeletons()
 106 : skeletons()
 107 , models() {
 108
 109 }
 110
 111 Skeletons::~Skeletons() {
 112
 113 }
 114
 115 void Skeletons::LoadHeadless() {
 116         skeletons.clear();
 117         skeletons.reserve(3);
 118         {
 119                 AABB bounds{{ -0.25f, -0.5f, -0.25f }, { 0.25f, 0.5f, 0.25f }};
 120                 skeletons.emplace_back(new CompositeModel);
 121                 skeletons[0]->Bounds(bounds);
 122         }
 123         {
 124                 AABB bounds{{ -0.5f, -0.25f, -0.5f }, { 0.5f, 0.25f, 0.5f }};
 125                 skeletons.emplace_back(new CompositeModel);
 126                 skeletons[1]->Bounds(bounds);
 127         }
 128         {
 129                 AABB bounds{{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f }};
 130                 skeletons.emplace_back(new CompositeModel);
 131                 skeletons[2]->Bounds(bounds);
 132         }
 133 }
 134
 135 void Skeletons::Load() {
 136         LoadHeadless();
 137         models.resize(3);
 138         EntityModel::Buffer buf;
 139         {
 140                 CuboidShape shape(skeletons[0]->Bounds());
 141                 shape.Vertices(buf, 1.0f);
 142                 buf.colors.resize(shape.VertexCount(), { 1.0f, 1.0f, 0.0f });
 143                 models[0].Update(buf);
 144                 skeletons[0]->SetNodeModel(&models[0]);
 145         }
 146         {
 147                 CuboidShape shape(skeletons[1]->Bounds());
 148                 buf.Clear();
 149                 shape.Vertices(buf, 2.0f);
 150                 buf.colors.resize(shape.VertexCount(), { 0.0f, 1.0f, 1.0f });
 151                 models[1].Update(buf);
 152                 skeletons[1]->SetNodeModel(&models[1]);
 153         }
 154         {
 155                 StairShape shape(skeletons[2]->Bounds(), { 0.4f, 0.4f });
 156                 buf.Clear();
 157                 shape.Vertices(buf, 3.0f);
 158                 buf.colors.resize(shape.VertexCount(), { 1.0f, 0.0f, 1.0f });
 159                 models[2].Update(buf);
 160                 skeletons[2]->SetNodeModel(&models[2]);
 161         }
 162 }
 163
 164 }