CSEngine
Loading...
Searching...
No Matches
CameraComponent.cpp
1#include "CameraComponent.h"
2#include "TransformComponent.h"
3#include "../Manager/CameraMgr.h"
4#include "../Manager/EngineCore.h"
5#include "../Util/Render/SFrameBuffer.h"
6#include "../Util/Render/STexture.h"
7#include "../Util/Render/ShaderUtil.h"
8
9#include <mutex>
10
11using namespace CSE;
12
13COMPONENT_CONSTRUCTOR(CameraComponent), m_eye(nullptr), m_targetObject(nullptr) {
14 auto cameraMgr = CORE->GetCore(CameraMgr);
15 cameraMgr->Register(this);
16 m_pRatio = const_cast<float*>(cameraMgr->GetProjectionRatio());
17 m_globalSkyboxHandle = cameraMgr->GetSkyboxProgram();
18}
19
20CameraComponent::~CameraComponent() = default;
21
22void CameraComponent::Exterminate() {
23 SAFE_DELETE(m_backgroundMap);
24 CORE->GetCore(CameraMgr)->Remove(this);
25}
26
27void CameraComponent::Init() {
28 m_eye = static_cast<TransformComponent*>(gameObject->GetTransform())->GetPosition();
29
30 m_resultTarget = vec3();
31 m_pRatio = const_cast<float*>(CORE->GetCore(CameraMgr)->GetProjectionRatio());
32 Tick(0);
33}
34
35void CameraComponent::Tick(float elapsedTime) {
36 if(m_type == CUBE) return;
37
38 if (m_targetObject == nullptr)
39 m_resultTarget = *m_eye + m_target;
40 else {
41 m_resultTarget = *static_cast<TransformComponent*>(m_targetObject->GetTransform())->GetPosition();
42 }
43 SetCameraMatrix();
44}
45
46SComponent* CameraComponent::Clone(SGameObject* object) {
47 INIT_COMPONENT_CLONE(CameraComponent, comp);
48
49 comp->m_eye = m_eye;
50 comp->m_target = m_target;
51 comp->m_up = m_up;
52
53 comp->m_cameraMatrix = m_cameraMatrix;
54 comp->m_projectionMatrix = m_projectionMatrix;
55 comp->m_resultTarget = m_resultTarget;
56 comp->m_frameBuffer = m_frameBuffer;
57
58 comp->m_type = m_type;
59 comp->m_isProjectionInited = m_isProjectionInited;
60
61 //perspective
62 comp->m_pFov = m_pFov;
63 comp->m_pRatio = m_pRatio;
64
65 //Orthographic
66 comp->m_oLeft = m_oLeft;
67 comp->m_oRight = m_oRight;
68 comp->m_oBottom = m_oBottom;
69 comp->m_oTop = m_oTop;
70
71 comp->m_Near = m_Near;
72 comp->m_Far = m_Far;
73
74 //Background
75 comp->m_backgroundType = m_backgroundType;
76 comp->m_backgroundColor = m_backgroundColor;
77 if(comp->m_backgroundMap == nullptr) comp->m_backgroundMap = new BackgroundMapStruct();
78 comp->m_backgroundMap->map = m_backgroundMap->map;
79 comp->m_backgroundMap->mapId = m_backgroundMap->mapId;
80 comp->m_backgroundMap->viewId = m_backgroundMap->viewId;
81 comp->m_backgroundMap->projectionId = m_backgroundMap->projectionId;
82
83 return comp;
84}
85
86void CameraComponent::CopyReference(SComponent* src, std::map<SGameObject*, SGameObject*> lists_obj,
87 std::map<SComponent*, SComponent*> lists_comp) {
88 if (src == nullptr) return;
89 auto convert = static_cast<CameraComponent*>(src);
90
91 //Copy GameObjects
92 FIND_OBJ_REFERENCE(m_targetObject, convert);
93
94}
95
96void CameraComponent::SetTargetVector(const vec3& target) {
97 m_target = target;
98}
99
100void CameraComponent::SetTarget(SGameObject* gameObject) {
101 m_targetObject = gameObject;
102}
103
104void CameraComponent::SetUp(const vec3& up) {
105 m_up = up;
106}
107
108void CameraComponent::SetCameraType(CAMERATYPE type) {
109 m_type = type;
110}
111
112void CameraComponent::SetPerspectiveFov(float fov) {
113 m_pFov = fov;
114}
115
116void CameraComponent::SetZDepthRange(float near, float far) {
117 m_Near = near;
118 m_Far = far;
119
120}
121
122void CameraComponent::SetPerspective(float fov, float near, float far) {
123 m_type = PERSPECTIVE;
124 m_pFov = fov;
125 m_Near = near;
126 m_Far = far;
127
128}
129
130void CameraComponent::SetOrtho(float left, float right, float top, float bottom) {
131 m_type = ORTHO;
132 m_oLeft = left;
133 m_oRight = right;
134 m_oBottom = bottom;
135 m_oTop = top;
136}
137
138void CameraComponent::SetCubeCamera() {
139 m_type = CUBE;
140}
141
142void CameraComponent::SetCameraMatrix() {
143 m_cameraMatrix = mat4::LookAt(*m_eye, m_resultTarget, m_up);
144}
145
146mat4 CameraComponent::GetCameraMatrix() const {
147 return m_cameraMatrix;
148}
149
150vec3 CameraComponent::GetCameraPosition() const {
151 mat4 matrix = static_cast<TransformComponent*>(gameObject->GetTransform())->GetMatrix();
152 return vec3{ matrix.w.x, matrix.w.y, matrix.w.z };
153}
154
155void CameraComponent::SetProjectionMatrix() const {
156 std::mutex mutex;
157 mutex.lock();
158
159 switch (m_type) {
160 case PERSPECTIVE:
161 m_projectionMatrix = mat4::Perspective(m_pFov, *m_pRatio, m_Near, m_Far);
162 break;
163 case ORTHO:
164 m_projectionMatrix = mat4::Ortho(m_oLeft, m_oRight, m_oTop, m_oBottom, m_Near, m_Far);
165 break;
166 case CUBE:
167 m_projectionMatrix = mat4::Perspective(90.0f, 1.0f, 0.1f, 10.0f);
168 break;
169 }
170
171 m_isProjectionInited = true;
172 mutex.unlock();
173}
174
175void CameraComponent::SetValue(std::string name_str, VariableBinder::Arguments value) {
176 if (name_str == "m_target") {
177 SET_VEC3(m_target);
178 } else if (name_str == "m_up") {
179 SET_VEC3(m_up);
180 } else if (name_str == "m_targetObject") {
181 if(value.size() <= 0) return;
182 m_targetObject = SGameObject::FindByHash(value[0]);
183 } else if (name_str == "m_cameraMatrix") {
184 SET_MAT4(m_cameraMatrix);
185 } else if (name_str == "m_projectionMatrix") {
186 SET_MAT4(m_projectionMatrix);
187 } else if (name_str == "m_type") {
188 m_type = static_cast<CAMERATYPE>(std::stoi(value[0]));
189 } else if (name_str == "m_pFov") {
190 m_pFov = std::stof(value[0]);
191 } else if (name_str == "m_orthoValue") {
192 m_oLeft = std::stof(value[0]);
193 m_oRight = std::stof(value[1]);
194 m_oBottom = std::stof(value[2]);
195 m_oTop = std::stof(value[3]);
196
197 } else if (name_str == "m_distance") {
198 m_Near = std::stof(value[0]);
199 m_Far = std::stof(value[1]);
200 } else if (name_str == "m_frameBuffer") {
201 m_frameBuffer = SResource::Create<SFrameBuffer>(value[0]);
202 } else if (name_str == "m_backgroundType") {
203 m_backgroundType = static_cast<BackgroundType>(std::stoi(value[0]));
204 } else if (name_str == "m_backgroundColor") {
205 SET_VEC3(m_backgroundColor);
206 } else if (name_str == "m_backgroundMap.map") {
207 SetBackgroundSkybox(SResource::Create<STexture>(value[0]));
208 }
209
210}
211
212std::string CameraComponent::PrintValue() const {
213 PRINT_START("component");
214
215 PRINT_VALUE_VEC3(m_target);
216 PRINT_VALUE_VEC3(m_up);
217 PRINT_VALUE("obj", m_targetObject, m_targetObject == nullptr ? "" : ConvertSpaceStr(m_targetObject->GetHash()));
218 PRINT_VALUE_MAT4(m_cameraMatrix);
219 PRINT_VALUE_MAT4(m_projectionMatrix);
220 PRINT_VALUE("int", m_type, static_cast<int>(m_type));
221 PRINT_VALUE("float", m_pFov, m_pFov);
222 PRINT_VALUE("vec4", m_orthoValue, m_oLeft, ' ', m_oRight, ' ', m_oBottom, ' ', m_oTop);
223 PRINT_VALUE("vec2", m_distance, m_Near, ' ', m_Far);
224 if (m_frameBuffer != nullptr) PRINT_RES_NAME(m_frameBuffer, m_frameBuffer);
225
226 PRINT_VALUE("int", m_backgroundType, static_cast<int>(m_backgroundType));
227 PRINT_VALUE_COLOR3(m_backgroundColor);
228 if (m_backgroundMap != nullptr && m_backgroundMap->map != nullptr)
229 PRINT_RES_NAME(m_backgroundMap.map, m_backgroundMap->map);
230
231 PRINT_END("component");
232}
233
234CameraMatrixStruct CameraComponent::GetCameraMatrixStruct() const {
235 return { m_cameraMatrix, GetProjectionMatrix(), GetCameraPosition() };
236}
237
238SFrameBuffer* CameraComponent::GetFrameBuffer() const {
239 return m_frameBuffer;
240}
241
242void CameraComponent::SetFrameBuffer(SFrameBuffer* frameBuffer) {
243 m_frameBuffer = frameBuffer;
244}
245
246CameraBase::BackgroundType CameraComponent::GetBackgroundType() {
247 return m_backgroundType;
248}
249
250void CameraComponent::RenderBackground() const {
251 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
252
253 switch (m_backgroundType) {
254 case SOLID:
255 glClearColor(m_backgroundColor.x, m_backgroundColor.y, m_backgroundColor.z, 1.0f);
256 glClear(GL_COLOR_BUFFER_BIT);
257 break;
258 case SKYBOX:
259 const auto& mapStruct = m_backgroundMap;
260 if (mapStruct->map == nullptr) return;
261
262 glUseProgram(m_globalSkyboxHandle->Program);
263 m_globalSkyboxHandle->SetUniformMat4("PROJECTION_MATRIX", m_projectionMatrix);
264 auto viewMatrix = mat4(m_cameraMatrix.ToMat3());
265 m_globalSkyboxHandle->SetUniformMat4("VIEW_MATRIX", viewMatrix);
266 mapStruct->map->Bind(mapStruct->mapId, 0);
267
268 glDisable(GL_CULL_FACE);
269 glDisable(GL_DEPTH_TEST);
270 ShaderUtil::BindAttributeToCubeMap();
271 glEnable(GL_DEPTH_TEST);
272 glEnable(GL_CULL_FACE);
273 break;
274 }
275}
276
277void CameraComponent::SetBackgroundSkybox(STexture* skyboxTexture) {
278 if (skyboxTexture == nullptr) {
279 skyboxTexture = SResource::Get<STexture>("envCubemap.textureCubeMap");
280 }
281 if (m_backgroundMap == nullptr) m_backgroundMap = new BackgroundMapStruct();
282
283 m_backgroundMap->map = skyboxTexture;
284 m_backgroundMap->mapId = static_cast<unsigned short>(m_globalSkyboxHandle->UniformLocation("ENV_MAP")->id);
285 m_backgroundMap->viewId = static_cast<unsigned short>(m_globalSkyboxHandle->UniformLocation("VIEW_MATRIX")->id);
286 m_backgroundMap->projectionId = static_cast<unsigned short>(m_globalSkyboxHandle->UniformLocation(
287 "PROJECTION_MATRIX")->id);
288}
289
290void CameraComponent::SetBackgroundColor(vec3&& color) {
291 m_backgroundColor = color;
292}
293
294void CameraComponent::SetBackgroundType(CameraBase::BackgroundType type) {
295 m_backgroundType = type;
296}
CSE::CameraComponent::SetValue
void SetValue(std::string name_str, Arguments value) override
Definition CameraComponent.cpp:175