SuzanneIsland: An island of Real-time rendering effects!
sceneobject.hpp
1 #pragma once
2 
3 #include <sstream>
4 
5 #include <glm/glm.hpp>
6 #include <glm/gtc/constants.hpp>
7 #include <glm/gtc/matrix_transform.hpp>
8 #include <glm/gtc/matrix_access.hpp>
9 
10 
12 
16 {
17 public:
18  SceneObject(const glm::mat4 &modelMatrix_)
19  : modelMatrix(modelMatrix_)
20  {
21  inverseMatrix = glm::inverse(modelMatrix_);
22  }
23 
24  virtual ~SceneObject()
25  {}
26 
28 
31  enum Order
32  {
33  LEFT,
35  };
36 
39  const glm::mat4 &trans_mat,
40  const glm::mat4 &invtrans_mat,
41  Order mult_order
42  );
43 
45  const glm::mat4& getMatrix() const;
46 
48  void setTransform(
49  const glm::mat4 &new_trans_mat
50  );
51 
53  const glm::mat4& getInverseMatrix() const;
54 
56 
63  glm::vec3 getLocation() const;
64 
67  void setLocation(const glm::vec3 &location);
68 
69 
71  void rotateX(
72  float radians,
73  Order mult_order
74  );
75 
77  void rotateY(
78  float radians,
79  Order mult_order
80  );
81 
83  void rotateZ(
84  float radians,
85  Order mult_order
86  );
87 
89  void rotate(
90  float radians,
91  Order mult_order,
92  const glm::vec3 &rot_axis
93  );
94 
96  void translate(
97  const glm::vec3 &trans_vec,
98  Order mult_order
99  );
100 
101 
103  void scale(
104  const glm::vec3 &scaling_vec,
105  Order mult_order
106  );
107 
110  std::string matrixToString(
111  const glm::mat4 &matrix
112  );
113 private:
114  glm::mat4 modelMatrix;
115  glm::mat4 inverseMatrix;
116 };
117 
118 inline const glm::mat4& SceneObject::getMatrix() const
119 {
120  return modelMatrix;
121 }
122 
123 inline const glm::mat4& SceneObject::getInverseMatrix() const
124 {
125  return inverseMatrix;
126 }
127 
128 inline glm::vec3 SceneObject::getLocation() const
129 {
130  return modelMatrix[3].xyz;
131 }
132 
133 inline void SceneObject::setLocation(const glm::vec3 &location)
134 {
135  modelMatrix[3] = glm::vec4(location, 1.0f);
136 }
137 
138 inline void SceneObject::setTransform(const glm::mat4 &new_trans_mat) {
139  modelMatrix = new_trans_mat;
140  inverseMatrix = glm::inverse(modelMatrix);
141 }
142 
144  const glm::mat4 &trans_mat,
145  const glm::mat4 &invtrans_mat,
146  Order mult_order)
147 {
148  if (mult_order == LEFT) {
149  modelMatrix = trans_mat * modelMatrix;
150  inverseMatrix = inverseMatrix * invtrans_mat;
151  }
152  else {
153  modelMatrix = modelMatrix * trans_mat;
154  inverseMatrix = invtrans_mat * inverseMatrix;
155  }
156 }
157 
158 inline void SceneObject::rotateX(float radians, Order mult_order)
159 {
161  glm::rotate(glm::mat4(), radians, glm::vec3(1.0f, 0.0f, 0.0f)),
162  glm::rotate(glm::mat4(), -radians, glm::vec3(1.0f, 0.0f, 0.0f)),
163  mult_order
164  );
165 }
166 
167 inline void SceneObject::rotateY(float radians, Order mult_order)
168 {
170  glm::rotate(glm::mat4(), radians, glm::vec3(0.0f, 1.0f, 0.0f)),
171  glm::rotate(glm::mat4(), -radians, glm::vec3(0.0f, 1.0f, 0.0f)),
172  mult_order
173  );
174 }
175 
176 inline void SceneObject::rotateZ(float radians, Order mult_order)
177 {
179  glm::rotate(glm::mat4(), radians, glm::vec3(0.0f, 0.0f, 1.0f)),
180  glm::rotate(glm::mat4(), -radians, glm::vec3(0.0f, 0.0f, 1.0f)),
181  mult_order
182  );
183 }
184 
185 inline void SceneObject::rotate(float radians, Order mult_order, const glm::vec3 &rot_axis)
186 {
188  glm::rotate(glm::mat4(), radians, rot_axis),
189  glm::rotate(glm::mat4(), -radians, rot_axis),
190  mult_order
191  );
192 }
193 
194 inline void SceneObject::translate(const glm::vec3 &trans_vec, Order mult_order)
195 {
197  glm::translate(glm::mat4(), trans_vec),
198  glm::translate(glm::mat4(), -trans_vec),
199  mult_order
200  );
201 }
202 
203 inline void SceneObject::scale(const glm::vec3 &scaling_vec, Order mult_order)
204 {
206  glm::scale(glm::mat4(), scaling_vec),
207  glm::scale(glm::mat4(), 1.0f / scaling_vec),
208  mult_order
209  );
210 }
211 
212 inline std::string SceneObject::matrixToString(const glm::mat4 &matrix)
213 {
214  std::stringstream matStr;
215 
216  for (int row = 0; row < 4; ++row) {
217  for (int col = 0; col < 4; ++col) {
218  matStr << matrix[col][row] << " ";
219  }
220  matStr << std::endl;
221  }
222 
223  return matStr.str();
224 }
225 
M_result = M * M_inc.
Definition: sceneobject.hpp:34
void scale(const glm::vec3 &scaling_vec, Order mult_order)
Applies a scale operation to the current transformation.
Definition: sceneobject.hpp:203
void setTransform(const glm::mat4 &new_trans_mat)
Replaces current matrix and sets its inverse.
Definition: sceneobject.hpp:138
void translate(const glm::vec3 &trans_vec, Order mult_order)
Applies a translation operation to the current transformation.
Definition: sceneobject.hpp:194
Order
enum specifying matrix multiplication order.
Definition: sceneobject.hpp:31
glm::vec3 getLocation() const
Returns the location of the SceneObject.
Definition: sceneobject.hpp:128
std::string matrixToString(const glm::mat4 &matrix)
Get a string to visualize the given matrix.
Definition: sceneobject.hpp:212
void rotateZ(float radians, Order mult_order)
Applies a Z axis rotation operation to the current transformation.
Definition: sceneobject.hpp:176
void setLocation(const glm::vec3 &location)
Set SceneObject&#39;s location: rightmost column of the model matrix.
Definition: sceneobject.hpp:133
M_result = M_inc * M.
Definition: sceneobject.hpp:33
const glm::mat4 & getInverseMatrix() const
Definition: sceneobject.hpp:123
void applyTransformation(const glm::mat4 &trans_mat, const glm::mat4 &invtrans_mat, Order mult_order)
Apply a transformation matrix to the current matrix.
Definition: sceneobject.hpp:143
A base class for all scene objects.
Definition: sceneobject.hpp:15
void rotateX(float radians, Order mult_order)
Applies an X axis rotation operation to the current transformation.
Definition: sceneobject.hpp:158
const glm::mat4 & getMatrix() const
Definition: sceneobject.hpp:118
void rotateY(float radians, Order mult_order)
Applies a Y axis rotation operation to the current transformation.
Definition: sceneobject.hpp:167
void rotate(float radians, Order mult_order, const glm::vec3 &rot_axis)
Applies a rotation around a given vector (= axis)
Definition: sceneobject.hpp:185