Cogs.Core
EngineBuffers.cpp
1#include <array>
2
3#include "Context.h"
4#include "EngineBuffers.h"
5#include "Renderer.h"
6#include "RenderTarget.h"
7
8#include "Services/Time.h"
9#include "Services/Random.h"
10#include "Systems/Core/LightSystem.h"
11#include "Systems/Core/FogSystem.h"
12#include "Systems/Core/EnvironmentSystem.h"
13#include "Tasks/RenderTask.h"
14#include "Systems/Core/CameraArraySystem.h"
15
16#include "Rendering/IBuffers.h"
17#include "Rendering/ICapabilities.h"
18
19void Cogs::Core::initializeEngineBuffers(IBuffers * buffers, ICapabilities* capabilites, EngineBuffers & engineBuffers)
20{
21 engineBuffers.viewBufferHandle = buffers->loadBuffer(nullptr, sizeof(ViewBufferEntry) * 2, Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
22 engineBuffers.sceneBufferHandle = buffers->loadBuffer(nullptr, sizeof(SceneParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
23 engineBuffers.lightBufferHandle = buffers->loadBuffer(nullptr, sizeof(LightBuffer), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
24 engineBuffers.objectBufferHandle = buffers->loadBuffer(nullptr, sizeof(ObjectBuffer), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
25 engineBuffers.shadowBufferHandle = buffers->loadBuffer(nullptr, sizeof(ShadowBuffer), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
26
27 engineBuffers.animationBuffer = buffers->loadBuffer(nullptr, sizeof(AnimationBuffer), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
28
29 buffers->annotate(engineBuffers.sceneBufferHandle, "Engine:SceneParameters");
30 buffers->annotate(engineBuffers.lightBufferHandle, "Engine:LightBuffer");
31 buffers->annotate(engineBuffers.objectBufferHandle, "Engine:ObjectBuffer");
32 buffers->annotate(engineBuffers.shadowBufferHandle, "Engine:ShadowBuffer");
33 buffers->annotate(engineBuffers.animationBuffer, "Engine::AnimationBuffer");
34
35 if (capabilites && capabilites->getDeviceCapabilities().ConstantBufferRange) {
36 uint32_t alignment = capabilites->getDeviceCapabilities().ConstantBufferOffsetAlignment;
37 assert(alignment && ((alignment & (alignment - 1)) == 0) && "Constant buffer alignment is not a power of two");
38
39 engineBuffers.objectBatch.stride = uint32_t((sizeof(ObjectBuffer) + (alignment - 1))) & ~(alignment - 1);
40 engineBuffers.objectBatch.count = 128;
41 engineBuffers.objectBatch.bufferHandle = buffers->loadBuffer(nullptr, engineBuffers.objectBatch.stride * engineBuffers.objectBatch.count, Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
42 buffers->annotate(engineBuffers.objectBatch.bufferHandle, "Engine:ObjectBatchBuffer");
43 } else {
44 engineBuffers.objectBatch.count = 0;
45 }
46}
47
48namespace {
49 using namespace Cogs::Core;
50
51 void updateViewBuffer(Context* context, Cogs::BufferHandle& viewBufferHandle, const CameraData* viewportData)
52 {
53 RenderPassOptions passOptions = viewportData->passOptions ? *viewportData->passOptions : RenderPassOptions{};
54
55
56 if (passOptions.multiViews && viewportData->cameraArray) {
57 const CameraArrayComponent* camArrComp = viewportData->cameraArray.resolveComponent<CameraArrayComponent>();
58 const CameraArrayData& camArrData = context->cameraArraySystem->getData(camArrComp);
59
60 // These are populated by CameraArraySystem::update
61 assert(camArrData.viewBuffer.size() == passOptions.multiViews);
62 if (HandleIsValid(viewBufferHandle)) {
63 Cogs::IGraphicsDevice* device = context->renderer->getDevice();
64 Cogs::IContext* deviceContext = device->getImmediateContext();
65 deviceContext->updateBuffer(viewBufferHandle, camArrData.viewBuffer.data(), sizeof(camArrData.viewBuffer[0]) * camArrData.viewBuffer.size());
66 }
67 }
68 }
69}
70
71void Cogs::Core::updateViewportBuffer(RenderTaskContext* taskContext,BufferHandle& sceneBufferHandle, BufferHandle& viewBufferHandle, const RenderTarget* renderTarget, const CameraData* viewportData, const std::array<glm::vec4, 6>* clipEquations)
72{
73 IGraphicsDevice* device = taskContext->renderer->getDevice();
74 IContext* deviceContext = device->getImmediateContext();
75 auto& engineBuffers = taskContext->renderer->getEngineBuffers();
76 auto& random = taskContext->context->random;
77
78 updateViewBuffer(taskContext->context, viewBufferHandle, viewportData);
79
80 {
81 auto& sceneParameters = engineBuffers.sceneParameters;
82
83 static std::uniform_int_distribution<uint32_t> dist(0, 63);
84 glm::uvec4 offset(dist(random->mt), dist(random->mt), viewportData->blueNoiseOffset);
85 sceneParameters.blueNoiseOffset = offset;
86
87 sceneParameters.projectionMatrix = viewportData->projectionMatrix;
88 sceneParameters.viewMatrix = viewportData->viewMatrix;
89 sceneParameters.inverseViewMatrix = viewportData->inverseViewMatrix;
90 sceneParameters.worldToClipMatrix = sceneParameters.projectionMatrix * sceneParameters.viewMatrix;
91 sceneParameters.inverseProjectionMatrix = viewportData->inverseProjectionMatrix;
92 sceneParameters.viewFromViewportMatrix = viewportData->viewFromViewportMatrix;
93 sceneParameters.viewportOrigin = viewportData->viewportOrigin;
94 sceneParameters.viewportSize = viewportData->viewportSize;
95 sceneParameters.viewportSizeRcp = 1.0f / viewportData->viewportSize;
96
97 RenderPassOptions passOptions = viewportData->passOptions ? *viewportData->passOptions : RenderPassOptions{};
98 if (viewportData->cameraArray && !passOptions.multiViews) {
99 const CameraArrayComponent* camArrComp = viewportData->cameraArray.resolveComponent<CameraArrayComponent>();
100 const CameraArrayData& camArrData = taskContext->context->cameraArraySystem->getData(camArrComp);
101 const ViewBufferEntry &entry = camArrData.viewBuffer[renderTarget->depthLayerIndex];
102 sceneParameters.projectionMatrix = entry.clipFromView;
103 sceneParameters.worldToClipMatrix = entry.clipFromWorld;
104 sceneParameters.viewMatrix = entry.viewFromWorld;
105 sceneParameters.inverseProjectionMatrix = entry.viewFromClip;
106 sceneParameters.inverseViewMatrix = entry.worldFromView;
107 }
108
109 const bool reverseDepth = taskContext->context->variables->get("renderer.reverseDepth", false);
110 float depthClamp = viewportData->depthClamp;
111 if(reverseDepth){
112 depthClamp = 1.0f - depthClamp;
113 }
114 if(device->getCapabilities()->getDeviceCapabilities().DepthNegativeOneToOne){
115 sceneParameters.shadowDepthClamp = 2.f * depthClamp - 1.f;
116 }
117 else{
118 sceneParameters.shadowDepthClamp = depthClamp;
119 }
120
121 sceneParameters.animationTime = static_cast<float>(taskContext->context->time->getAnimationTime());
122 sceneParameters.exposure = viewportData->exposure;
123
124 const float aspect = viewportData->viewportSize.y == 0 ? 1.0f : viewportData->viewportSize.x / viewportData->viewportSize.y;
125 sceneParameters.projectionParameters.y = 2.0f * viewportData->nearDistance * glm::tan(0.5f * viewportData->fieldOfView);
126 sceneParameters.projectionParameters.x = aspect * sceneParameters.projectionParameters.y;
127 sceneParameters.projectionParameters.z = aspect;
128 sceneParameters.projectionParameters.w = viewportData->fieldOfView;
129
130 unsigned sceneFlags = 0;
131 if ((renderTarget == taskContext->defaultRenderTarget && taskContext->renderer->getSettings().defaultRenderTargetExpectsSRGB) || renderTarget->expectsSRGB) {
132 sceneFlags |= COGS_SCENEFLAGS_OUTPUT_SRGB;
133 }
134 if (auto* environment = viewportData->environment.resolveComponent<EnvironmentComponent>(); environment && environment->isSubmerged(viewportData)) {
135 sceneFlags |= COGS_SCENEFLAGS_SUBMERGED;
136 }
137 sceneParameters.sceneFlags = sceneFlags;
138 sceneParameters.clientFlags = viewportData->clientFlags;
139 if (taskContext->context->environmentSystem) {
140 auto* envComp = taskContext->context->environmentSystem->getGlobalEnvironment();
141 if (envComp) {
142 auto& envData = taskContext->context->environmentSystem->getData(envComp);
143 sceneParameters.numEnvironmentIrradianceMips = static_cast<float>(envData.irradianceLods);
144 sceneParameters.numEnvironmentRadianceMips = static_cast<float>(envData.radianceLods);
145 }
146 }
147
148 static const std::array<glm::vec4, 6> noClipEquations = {
149 glm::vec4(0.f, 0.f, 0.f, 1.f), glm::vec4(0.f, 0.f, 0.f, 1.f),
150 glm::vec4(0.f, 0.f, 0.f, 1.f), glm::vec4(0.f, 0.f, 0.f, 1.f),
151 glm::vec4(0.f, 0.f, 0.f, 1.f), glm::vec4(0.f, 0.f, 0.f, 1.f)
152 };
153 std::memcpy(&sceneParameters.clippingPlanes, clipEquations ? clipEquations : &noClipEquations, sizeof(std::array<glm::vec4, 6>));
154
155 taskContext->cameraData = viewportData;
156 }
157
158 if (HandleIsValid(sceneBufferHandle)) {
159 deviceContext->updateBuffer(sceneBufferHandle, &engineBuffers.sceneParameters, sizeof(SceneParameters));
160 }
161}
162
163namespace {
164 using namespace Cogs::Core;
165
166 void updateLightBuffer(RenderTaskContext* taskContext, const CameraData* viewportData)
167 {
168 ActiveLights& activeLights = taskContext->renderer->getActiveLights();
169 EngineBuffers& engineBuffers = taskContext->renderer->getEngineBuffers();
170 LightSystem& lightSystem = *taskContext->context->lightSystem;
171 LightBuffer& lightParameters = engineBuffers.lightParameters;
172 lightParameters = {};
173 lightParameters.eyePosition = viewportData->inverseViewMatrix[3];
174
175 size_t numActiveLights = activeLights.lights.size();
176 for (size_t i = 0; i < numActiveLights; i++) {
177 const LightComponent* light = activeLights.lights[i];
178 const LightData& lightData = lightSystem.getData(light);
179 lightParameters.lightPositions[i] = lightData.lightPosition;
180 lightParameters.lightDirections[i] = lightData.lightDirection;
181 lightParameters.lightColorIntensity[i] = lightData.lightColor;
182 lightParameters.lightColorIntensity[i].a = (light->lightingLayer & viewportData->lightingMask) == 0 ? 0.f : light->intensity;
183 lightParameters.lightParameters[i].r = lightData.shadowIntensityOffset;
184 lightParameters.lightParameters[i].a = light->range;
185 }
186 lightParameters.numLights[0] = static_cast<uint32_t>(numActiveLights);
187 lightParameters.ambientColor = taskContext->renderer->getSettings().ambientColor;
188 lightParameters.ambientIntensity = taskContext->renderer->getSettings().ambientIntensity;
189
190 const FogComponent* globalFog = taskContext->context->fogSystem->getGlobalFog();
191 if (globalFog && globalFog->enabled) {
192 lightParameters.fogEnabled = 1;
193 lightParameters.fogColor = globalFog->color;
194 lightParameters.fogDistance = globalFog->distance;
195 lightParameters.fogAmount = globalFog->amount;
196 }
197 else {
198 lightParameters.fogEnabled = 0;
199 }
200
201 const EnvironmentComponent* environmentComponent = viewportData->environment.resolveComponent<EnvironmentComponent>();
202 lightParameters.seaFlags = 0;
203 lightParameters.flags = 0;
204 lightParameters.environmentBrightness = 1.0f;
205 lightParameters.skyMultiplier = 1.0f;
206 if (environmentComponent) {
207 lightParameters.environmentBrightness = environmentComponent->brightness;
208 lightParameters.skyMultiplier = environmentComponent->skyMultiplier;
209 lightParameters.flags = ((HandleIsValid(environmentComponent->skyDome) ? 1 : 0) |
210 (HandleIsValid(environmentComponent->radiance) ? 2 : 0) |
211 (HandleIsValid(environmentComponent->irradiance) ? 4 : 0) |
212 (HandleIsValid(environmentComponent->subseaRadiance) ? 8 : 0) |
213 (HandleIsValid(environmentComponent->ambientIrradiance) ? 16 : 0) |
214 (HandleIsValid(environmentComponent->brdfLUT) ? 32 : 0));
215
216 if (environmentComponent->subseaSupport) {
217 lightParameters.seaFlags = environmentComponent->isSubmerged(viewportData);
218 if (lightParameters.seaFlags) {
219 lightParameters.fogEnabled = 2 + 4;
220 lightParameters.fogColor = glm::vec4(1, 0, 0, 1);
221 lightParameters.fogDistance = environmentComponent->subseaTurbidityDistance;
222 lightParameters.fogAmount = environmentComponent->subseaTurbidityAmount;
223 }
224 }
225 }
226 }
227
228 const glm::vec4 softShadowJitter[] = {
229 { -2.5f, -2.5f, 0.0f, 0.0f },
230 { -2.5f, -1.5f, -1.5f, 0.0f },
231 { -2.5f, -0.5f, 0.0f, -1.5f },
232 { -2.5f, 0.5f, 0.0f, 1.5f },
233 { -2.5f, 1.5f, 1.5f, 0.0f },
234 { -2.5f, 2.5f, -1.5f, -1.5f },
235 { -1.5f, -2.5f, -1.5f, 1.5f },
236 { -1.5f, -1.5f, 1.5f, -1.5f },
237 { -1.5f, -0.5f, 1.5f, 1.5f },
238 { -1.5f, 0.5f, 0.0f, 0.0f },
239 { -1.5f, 1.5f, 0.0f, 0.0f },
240 { -1.5f, 2.5f, 0.0f, 0.0f },
241 { -0.5f, -2.5f, 0.0f, 0.0f },
242 { -0.5f, -1.5f, 0.0f, 0.0f },
243 { -0.5f, -0.5f, 0.0f, 0.0f },
244 { -0.5f, 0.5f, 0.0f, 0.0f },
245 { -0.5f, 1.5f, 0.0f, 0.0f },
246 { -0.5f, 2.5f, 0.0f, 0.0f },
247 { 0.5f, -2.5f, 0.0f, 0.0f },
248 { 0.5f, -1.5f, 0.0f, 0.0f },
249 { 0.5f, -0.5f, 0.0f, 0.0f },
250 { 0.5f, 0.5f, 0.0f, 0.0f },
251 { 0.5f, 1.5f, 0.0f, 0.0f },
252 { 0.5f, 2.5f, 0.0f, 0.0f },
253 { 1.5f, -2.5f, 0.0f, 0.0f },
254 { 1.5f, -1.5f, 0.0f, 0.0f },
255 { 1.5f, -0.5f, 0.0f, 0.0f },
256 { 1.5f, 0.5f, 0.0f, 0.0f },
257 { 1.5f, 1.5f, 0.0f, 0.0f },
258 { 1.5f, 2.5f, 0.0f, 0.0f },
259 { 2.5f, -2.5f, 0.0f, 0.0f },
260 { 2.5f, -1.5f, 0.0f, 0.0f },
261 { 2.5f, -0.5f, 0.0f, 0.0f },
262 { 2.5f, 0.5f, 0.0f, 0.0f },
263 { 2.5f, 1.5f, 0.0f, 0.0f },
264 { 2.5f, 2.5f, 0.0f, 0.0f }
265 };
266
267 void updateShadowBuffer(RenderTaskContext* taskContext)
268 {
269 ActiveLights& activeLights = taskContext->renderer->getActiveLights();
270 EngineBuffers& engineBuffers = taskContext->renderer->getEngineBuffers();
271 LightSystem& lightSystem = *taskContext->context->lightSystem;
272
273 ShadowBuffer& shadowParameters = engineBuffers.shadowBuffer;
274 shadowParameters = {};
275 static_assert(sizeof(softShadowJitter) == sizeof(ShadowBuffer::softShadowJitter));
276 std::memcpy(&shadowParameters.softShadowJitter, &softShadowJitter, sizeof(ShadowBuffer::softShadowJitter));
277 const bool reverseDepth = taskContext->context->variables->get("renderer.reverseDepth", false);
278 glm::mat4 viewportTransform;
279 switch (taskContext->device->getType())
280 {
281 case Cogs::GraphicsDeviceType::OpenGL20:
282 case Cogs::GraphicsDeviceType::OpenGLES30:
283 // - Do not flip Y
284 if(taskContext->device->getCapabilities()->getDeviceCapabilities().DepthNegativeOneToOne){
285 // - Scale depth from [-1, 1] to [0,1]
286 viewportTransform = glm::mat4(0.5f, 0.0f, 0.0f, 0.0f,
287 0.0f, 0.5f, 0.0f, 0.0f,
288 0.0f, 0.0f, 0.5f, 0.0f,
289 0.5f, 0.5f, 0.5f, 1.0f);
290 }
291 else{
292 // - Depth is already scaled to [0,1] by projection matrix generated by getProjectionMatrix
293 viewportTransform = glm::mat4(0.5f, 0.0f, 0.0f, 0.0f,
294 0.0f, 0.5f, 0.0f, 0.0f,
295 0.0f, 0.0f, 1.0f, 0.0f,
296 0.5f, 0.5f, 0.0f, 1.0f);
297 }
298 break;
299 default:
300 // - Flip Y
301 // - Depth is already scaled to [0,1] by projection matrix generated by getProjectionMatrix
302 viewportTransform = glm::mat4(0.5f, 0.0f, 0.0f, 0.0f,
303 0.0f, -0.5f, 0.0f, 0.0f,
304 0.0f, 0.0f, 1.0f, 0.0f,
305 0.5f, 0.5f, 0.0f, 1.0f);
306 break;
307 }
308
309
310 for (size_t i = 0; i < activeLights.numDirectionalShadowLights; i++) {
311 const LightComponent* light = activeLights.lights[i];
312 const LightData& lightData = lightSystem.getData(light);
313 shadowParameters.cascadeOffsets[i].x = lightData.arrayOffset;
314 ShadowData& shadow = shadowParameters.shadowData[i];
315 shadow.shadowsEnabled = lightData.enabled && lightData.castShadows;
316 shadow.texelSize = 1.f / lightData.textureSize;
317 shadow.cascadeLine = lightData.cascadeLine;
318 shadow.nearSplits = *reinterpret_cast<const glm::vec4*>(lightData.nearDepths);
319 shadow.farSplits = *reinterpret_cast<const glm::vec4*>(lightData.farDepths);
320 shadow.shadowSampleBias = reverseDepth ? -light->shadowSampleBias : light->shadowSampleBias;
321 shadow.numCascades = lightData.numViewports;
322 for (size_t k = 0; k < lightData.numViewports; k++) {
323 shadow.lightMatrix[k] = viewportTransform * lightData.lightCameraData[k].viewProjection;
324 }
325 }
326
327 for (size_t i = 0; i < activeLights.numPointShadowLights; i++) {
328 size_t o = activeLights.numDirectionalShadowLights + activeLights.numDirectionalLights + i;
329 const LightComponent* light = activeLights.lights[o];
330 const LightData& lightData = lightSystem.getData(light);
331
332 shadowParameters.cascadeOffsets[o].x = lightData.arrayOffset / 6;
333
334 ShadowData& shadow = shadowParameters.shadowData[o];
335 shadow.shadowsEnabled = lightData.enabled && lightData.castShadows;
336 shadow.texelSize = 1.f / lightData.textureSize;
337 shadow.cascadeLine = lightData.cascadeLine;
338 shadow.nearSplits = *reinterpret_cast<const glm::vec4*>(lightData.nearDepths);
339 shadow.farSplits = *reinterpret_cast<const glm::vec4*>(lightData.farDepths);
340 shadow.shadowSampleBias = reverseDepth ? -light->shadowSampleBias : light->shadowSampleBias;
341 shadow.numCascades = lightData.numViewports;
342 for (size_t k = 0; k < lightData.numViewports; k++) {
343 shadow.lightMatrix[k] = viewportTransform * lightData.lightCameraData[k].viewProjection;
344 }
345 }
346 }
347
348}
349
350void Cogs::Core::updateEngineBuffers(RenderTaskContext * taskContext, const RenderTarget* renderTarget, const CameraData * viewportData, const std::array<glm::vec4, 6>* clipEquations)
351{
352 auto device = taskContext->renderer->getDevice();
353 auto deviceContext = device->getImmediateContext();
354
355 auto & engineBuffers = taskContext->renderer->getEngineBuffers();
356
357 if (!viewportData) return;
358
359 updateViewportBuffer(taskContext, engineBuffers.sceneBufferHandle, engineBuffers.viewBufferHandle, renderTarget, viewportData, clipEquations);
360
361 updateLightBuffer(taskContext, viewportData);
362 if (HandleIsValid(engineBuffers.lightBufferHandle)) {
363 deviceContext->updateBuffer(engineBuffers.lightBufferHandle, &engineBuffers.lightParameters, sizeof(LightBuffer));
364 }
365
366 updateShadowBuffer(taskContext);
367 if (HandleIsValid(engineBuffers.shadowBufferHandle)) {
368 deviceContext->updateBuffer(engineBuffers.shadowBufferHandle, &engineBuffers.shadowBuffer, sizeof(ShadowBuffer));
369 }
370}
Cogs::Core::CameraArrayComponent
Multi-view: Render a set of related views into array texture layers.
Definition: CameraArrayComponent.h:41
Cogs::Core::Context
A Context instance contains all the services, systems and runtime components needed to use Cogs.
Definition: Context.h:83
Cogs::Core::Context::renderer
class IRenderer * renderer
Renderer.
Definition: Context.h:228
Cogs::Core::Context::random
std::unique_ptr< class Random > random
Random Number service instance.
Definition: Context.h:189
Cogs::Core::Context::variables
std::unique_ptr< class Variables > variables
Variables service instance.
Definition: Context.h:180
Cogs::Core::Context::time
std::unique_ptr< class Time > time
Time service instance.
Definition: Context.h:198
Cogs::Core::FogComponent
Contains data to describe fog.
Definition: FogComponent.h:17
Cogs::Core::FogComponent::color
glm::vec4 color
Fog color.
Definition: FogComponent.h:23
Cogs::Core::FogComponent::amount
float amount
Amount of fog to blend in.
Definition: FogComponent.h:29
Cogs::Core::FogComponent::distance
float distance
Distance at which the fog is at its most dense.
Definition: FogComponent.h:26
Cogs::Core::FogComponent::enabled
bool enabled
If the fog should be enabled or disabled.
Definition: FogComponent.h:32
Cogs::Core::IRenderer::getDevice
virtual IGraphicsDevice * getDevice()=0
Get the graphics device used by the renderer.
Cogs::Core::LightComponent
Defines a single light source and its behavior.
Definition: LightComponent.h:69
Cogs::Core::LightComponent::intensity
float intensity
Intensity of the light source.
Definition: LightComponent.h:90
Cogs::Core::LightComponent::shadowSampleBias
float shadowSampleBias
Constant term shadow map sampling bias.
Definition: LightComponent.h:117
Cogs::Core::LightComponent::lightingLayer
LightingLayers lightingLayer
The lighting layer the light belongs to.
Definition: LightComponent.h:87
Cogs::Core::LightComponent::range
float range
Falloff range.
Definition: LightComponent.h:93
Cogs::Core::LightSystem
Holds all LightComponent instances in the system.
Definition: LightSystem.h:78
Cogs::Core::Renderer::getActiveLights
ActiveLights & getActiveLights() override
Get the reference to the ActiveLights structure.
Definition: Renderer.h:72
Cogs::Core::Renderer::getEngineBuffers
EngineBuffers & getEngineBuffers() override
Get the reference to the EngineBuffers structure.
Definition: Renderer.h:67
Cogs::Core::Renderer::getDevice
IGraphicsDevice * getDevice() override
Get the graphics device used by the renderer.
Definition: Renderer.h:45
Cogs::Core::Renderer::getSettings
const RenderSettings & getSettings() const override
Get the settings of the renderer.
Definition: Renderer.h:46
Cogs::IGraphicsDevice
Represents a graphics device used to manage graphics resources and issue drawing commands.
Definition: IGraphicsDevice.h:169
Cogs::IGraphicsDevice::getCapabilities
virtual ICapabilities * getCapabilities()=0
Get a pointer to the capability management interface used to query the graphics device capability fla...
Cogs::IGraphicsDevice::getImmediateContext
virtual IContext * getImmediateContext()=0
Get a pointer to the immediate context used to issue commands to the graphics device.
Cogs::IGraphicsDevice::getType
virtual GraphicsDeviceType getType() const
Get the type of the graphics device.
Definition: IGraphicsDevice.h:234
Cogs::Core
Contains the Engine, Renderer, resource managers and other systems needed to run Cogs....
Definition: ComponentFunctions.h:10
Cogs::Core::HandleIsValid
bool HandleIsValid(const ResourceHandle_t< T > &handle)
Check if the given resource is valid, that is not equal to NoHandle or InvalidHandle.
Definition: ResourceHandle.h:212
Cogs::GraphicsDeviceType::OpenGLES30
@ OpenGLES30
Graphics device using the OpenGLES 3.0 API.
Cogs::GraphicsDeviceType::OpenGL20
@ OpenGL20
Graphics device using OpenGL, supporting at least OpenGL 2.0.
Cogs::ComponentModel::ComponentHandle::resolveComponent
ComponentType * resolveComponent() const
Definition: Component.h:90
Cogs::Core::ActiveLights
Active lights settings.
Definition: IRenderer.h:47
Cogs::Core::CameraData
Contains data describing a Camera instance and its derived data structured such as matrix data and vi...
Definition: CameraSystem.h:67
Cogs::Core::LightData
Defines calculated light data.
Definition: LightSystem.h:34
Cogs::GraphicsDeviceCapabilities::DepthNegativeOneToOne
bool DepthNegativeOneToOne
If true, min z depth=-1 otherwise it is min z depth = 0 (max z depth = 1).
Definition: ICapabilities.h:111
Cogs::Handle_t< BufferTag >
Cogs::ICapabilities::getDeviceCapabilities
virtual const GraphicsDeviceCapabilities & getDeviceCapabilities() const
Gets the device capabilities in a structure.
Definition: ICapabilities.h:182
Cogs::IContext
Represents a graphics device context which can receive rendering commands.
Definition: IContext.h:43
Cogs::IContext::updateBuffer
virtual void updateBuffer(BufferHandle bufferHandle, const void *data, size_t size)=0
Replace contents of buffer with new data.
Generated by doxygen 1.9.6