Cogs.Core
EffectsGL20.cpp
1#include "EffectsGL20.h"
2#include "GraphicsDeviceGL20.h"
3
4#include "../Base/Utilities.h"
5
6#include "Foundation/Logging/Logger.h"
7#include "Foundation/Platform/IO.h"
8
9#define COGS_DUMP_SHADERS 1
10
11#ifdef COGS_ENABLE_GLSLANG
12#define ENABLE_HLSL
13#include <glslang/Public/ShaderLang.h>
14
15#include <glslang/SPIRV/GlslangToSpv.h>
16#ifdef COGS_DUMP_SHADERS
17#include <glslang/SPIRV/disassemble.h>
18#endif
19
20#include <spirv_cross.hpp>
21#include <spirv_glsl.hpp>
22
23#endif
24
25#include <fstream>
26
27using namespace Cogs;
28
29namespace
30{
31#ifdef COGS_ENABLE_GLSLANG
32 TBuiltInResource resources = {
33 /* .MaxLights = */ 32,
34 /* .MaxClipPlanes = */ 6,
35 /* .MaxTextureUnits = */ 32,
36 /* .MaxTextureCoords = */ 32,
37 /* .MaxVertexAttribs = */ 64,
38 /* .MaxVertexUniformComponents = */ 4096,
39 /* .MaxVaryingFloats = */ 64,
40 /* .MaxVertexTextureImageUnits = */ 32,
41 /* .MaxCombinedTextureImageUnits = */ 80,
42 /* .MaxTextureImageUnits = */ 32,
43 /* .MaxFragmentUniformComponents = */ 4096,
44 /* .MaxDrawBuffers = */ 32,
45 /* .MaxVertexUniformVectors = */ 128,
46 /* .MaxVaryingVectors = */ 8,
47 /* .MaxFragmentUniformVectors = */ 16,
48 /* .MaxVertexOutputVectors = */ 16,
49 /* .MaxFragmentInputVectors = */ 15,
50 /* .MinProgramTexelOffset = */ -8,
51 /* .MaxProgramTexelOffset = */ 7,
52 /* .MaxClipDistances = */ 8,
53 /* .MaxComputeWorkGroupCountX = */ 65535,
54 /* .MaxComputeWorkGroupCountY = */ 65535,
55 /* .MaxComputeWorkGroupCountZ = */ 65535,
56 /* .MaxComputeWorkGroupSizeX = */ 1024,
57 /* .MaxComputeWorkGroupSizeY = */ 1024,
58 /* .MaxComputeWorkGroupSizeZ = */ 64,
59 /* .MaxComputeUniformComponents = */ 1024,
60 /* .MaxComputeTextureImageUnits = */ 16,
61 /* .MaxComputeImageUniforms = */ 8,
62 /* .MaxComputeAtomicCounters = */ 8,
63 /* .MaxComputeAtomicCounterBuffers = */ 1,
64 /* .MaxVaryingComponents = */ 60,
65 /* .MaxVertexOutputComponents = */ 64,
66 /* .MaxGeometryInputComponents = */ 64,
67 /* .MaxGeometryOutputComponents = */ 128,
68 /* .MaxFragmentInputComponents = */ 128,
69 /* .MaxImageUnits = */ 8,
70 /* .MaxCombinedImageUnitsAndFragmentOutputs = */ 8,
71 /* .MaxCombinedShaderOutputResources = */ 8,
72 /* .MaxImageSamples = */ 0,
73 /* .MaxVertexImageUniforms = */ 0,
74 /* .MaxTessControlImageUniforms = */ 0,
75 /* .MaxTessEvaluationImageUniforms = */ 0,
76 /* .MaxGeometryImageUniforms = */ 0,
77 /* .MaxFragmentImageUniforms = */ 8,
78 /* .MaxCombinedImageUniforms = */ 8,
79 /* .MaxGeometryTextureImageUnits = */ 16,
80 /* .MaxGeometryOutputVertices = */ 256,
81 /* .MaxGeometryTotalOutputComponents = */ 1024,
82 /* .MaxGeometryUniformComponents = */ 1024,
83 /* .MaxGeometryVaryingComponents = */ 64,
84 /* .MaxTessControlInputComponents = */ 128,
85 /* .MaxTessControlOutputComponents = */ 128,
86 /* .MaxTessControlTextureImageUnits = */ 16,
87 /* .MaxTessControlUniformComponents = */ 1024,
88 /* .MaxTessControlTotalOutputComponents = */ 4096,
89 /* .MaxTessEvaluationInputComponents = */ 128,
90 /* .MaxTessEvaluationOutputComponents = */ 128,
91 /* .MaxTessEvaluationTextureImageUnits = */ 16,
92 /* .MaxTessEvaluationUniformComponents = */ 1024,
93 /* .MaxTessPatchComponents = */ 120,
94 /* .MaxPatchVertices = */ 32,
95 /* .MaxTessGenLevel = */ 64,
96 /* .MaxViewports = */ 16,
97 /* .MaxVertexAtomicCounters = */ 0,
98 /* .MaxTessControlAtomicCounters = */ 0,
99 /* .MaxTessEvaluationAtomicCounters = */ 0,
100 /* .MaxGeometryAtomicCounters = */ 0,
101 /* .MaxFragmentAtomicCounters = */ 8,
102 /* .MaxCombinedAtomicCounters = */ 8,
103 /* .MaxAtomicCounterBindings = */ 1,
104 /* .MaxVertexAtomicCounterBuffers = */ 0,
105 /* .MaxTessControlAtomicCounterBuffers = */ 0,
106 /* .MaxTessEvaluationAtomicCounterBuffers = */ 0,
107 /* .MaxGeometryAtomicCounterBuffers = */ 0,
108 /* .MaxFragmentAtomicCounterBuffers = */ 1,
109 /* .MaxCombinedAtomicCounterBuffers = */ 1,
110 /* .MaxAtomicCounterBufferSize = */ 16384,
111 /* .MaxTransformFeedbackBuffers = */ 4,
112 /* .MaxTransformFeedbackInterleavedComponents = */ 64,
113 /* .MaxCullDistances = */ 8,
114 /* .MaxCombinedClipAndCullDistances = */ 8,
115 /* .MaxSamples = */ 4,
116 /* .maxMeshOutputVerticesNV = */ 256,
117 /* .maxMeshOutputPrimitivesNV = */ 512,
118 /* .maxMeshWorkGroupSizeX_NV = */ 32,
119 /* .maxMeshWorkGroupSizeY_NV = */ 1,
120 /* .maxMeshWorkGroupSizeZ_NV = */ 1,
121 /* .maxTaskWorkGroupSizeX_NV = */ 32,
122 /* .maxTaskWorkGroupSizeY_NV = */ 1,
123 /* .maxTaskWorkGroupSizeZ_NV = */ 1,
124 /* .maxMeshViewCountNV = */ 4,
125 /* .maxDualSourceDrawBuffersEXT =*/ 1,
126
127 /* .limits = */{
128 /* .nonInductiveForLoops = */ 1,
129 /* .whileLoops = */ 1,
130 /* .doWhileLoops = */ 1,
131 /* .generalUniformIndexing = */ 1,
132 /* .generalAttributeMatrixVectorIndexing = */ 1,
133 /* .generalVaryingIndexing = */ 1,
134 /* .generalSamplerIndexing = */ 1,
135 /* .generalVariableIndexing = */ 1,
136 /* .generalConstantMatrixVectorIndexing = */ 1,
137 }
138 };
139
140 struct HlslSemantic
141 {
142 StringView name;
143 size_t index = 0;
144 };
145
146 HlslSemantic getSemanticWithIndex(const StringView & str)
147 {
148 size_t index = 0;
149 while (index < str.size()) {
150 if (str[index] >= '0' && str[index] <= '9') break;
151 ++index;
152 }
153
154 size_t semanticIndex = 0;
155 if (index < str.size()) {
156 semanticIndex = atoi(str.substr(index).data());
157 }
158
159 return { str.substr(0, index), semanticIndex };
160 }
161
162 int shader_num = 0;
163#endif
164}
165
166namespace
167{
168 Cogs::Logging::Log logger = Cogs::Logging::getLogger("EffectsGL20");
169
170 void checkGLError(const char * /*operation*/) { }
171
172 void printShaderSource(GLint shaderId, Cogs::EffectFlags::EEffectFlags effectFlags)
173 {
174 if ((effectFlags & Cogs::EffectFlags::LogShaderSource) == Cogs::EffectFlags::LogShaderSource) {
175 GLint sourceLength = 0;
176 glGetShaderiv(shaderId, GL_SHADER_SOURCE_LENGTH, &sourceLength);
177 if (sourceLength) {
178 std::vector<char> source(sourceLength);
179 glGetShaderSource(shaderId, sourceLength, &sourceLength, source.data());
180
181 char* start = source.data();
182 char* stop;
183 int line = 1;
184 do {
185 stop = start;
186 while ((*stop != '\0') && (*stop != '\n') && (*stop != '\r')) { stop++; }
187
188 LOG_DEBUG(logger, "%3d: %s", line++, std::string(start, stop - start).c_str());
189
190 while ((*stop != '\0') && (*stop != '\n')) { stop++; }
191 while ((*stop != '\0') && (*stop == '\r')) { stop++; }
192
193 start = stop + 1;
194 } while (*stop != '\0');
195 }
196 }
197 }
198
199 void printShaderLog(GLenum /*shaderType*/, GLint shaderId, Cogs::EffectFlags::EEffectFlags effectFlags, bool isError = true)
200 {
201 GLint bufferLength = 0;
202 glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &bufferLength);
203
204 if (bufferLength) {
205 std::vector<char> buffer(bufferLength);
206
207 glGetShaderInfoLog(shaderId, bufferLength, nullptr, buffer.data());
208
209 if (isError) {
210 printShaderSource(shaderId, effectFlags);
211 LOG_ERROR(logger, "Could not compile shader %d:\n", shaderId);
212 LOG_ERROR(logger, "%s\n", buffer.data());
213 } else if (bufferLength > 1) {
214 LOG_WARNING(logger, "Warnings compiling shader:\n%s\n", buffer.data());
215 }
216 }
217 }
218
219 void printProgramError(GLint programId, Cogs::EffectFlags::EEffectFlags effectFlags, bool isError = true)
220 {
221 GLint bufferLength = 0;
222 glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &bufferLength);
223
224 if (bufferLength) {
225
226 if ((effectFlags & Cogs::EffectFlags::LogShaderSource) == Cogs::EffectFlags::LogShaderSource) {
227 GLint attachedShadersCount = 0;
228 glGetProgramiv(programId, GL_ATTACHED_SHADERS, &attachedShadersCount);
229 std::vector<GLuint> shaders(attachedShadersCount);
230
231 GLsizei actualCount = 0;
232 glGetAttachedShaders(programId, static_cast<GLsizei>(shaders.size()), &actualCount, shaders.data());
233
234 for (auto shaderId : shaders) {
235 const char* stage = "unknown";
236 GLint shaderType;
237 glGetShaderiv(shaderId, GL_SHADER_TYPE, &shaderType);
238 switch (shaderType)
239 {
240 case GL_VERTEX_SHADER: stage = "vertex"; break;
241 case GL_TESS_CONTROL_SHADER: stage = "tess control"; break;
242 case GL_TESS_EVALUATION_SHADER: stage = "tess eval"; break;
243 case GL_GEOMETRY_SHADER: stage = "geometry"; break;
244 case GL_FRAGMENT_SHADER: stage = "fragment"; break;
245 default:
246 break;
247 }
248 LOG_DEBUG(logger, "Source of %s stage:", stage);
249 printShaderSource(shaderId, effectFlags);
250 }
251 }
252
253 std::vector<char> buffer(bufferLength);
254
255 glGetProgramInfoLog(programId, bufferLength, nullptr, buffer.data());
256
257 if (isError) {
258 LOG_ERROR(logger, "Could not link program:\n%s\n", buffer.data());
259 } else if (bufferLength > 1) {
260 LOG_WARNING(logger, "Warnings linking program:\n%s\n", buffer.data());
261 }
262 }
263 }
264
265 static const char* getShaderUniformTypeString(GLenum type)
266 {
267 switch (type)
268 {
269 case GL_FLOAT: return "float"; break;
270 case GL_FLOAT_VEC2: return "vec2"; break;
271 case GL_FLOAT_VEC3: return "vec3"; break;
272 case GL_FLOAT_VEC4: return "vec4"; break;
273 case GL_DOUBLE: return "double"; break;
274 case GL_DOUBLE_VEC2: return "dvec2"; break;
275 case GL_DOUBLE_VEC3: return "dvec3"; break;
276 case GL_DOUBLE_VEC4: return "dvec4"; break;
277 case GL_INT: return "int"; break;
278 case GL_INT_VEC2: return "ivec2"; break;
279 case GL_INT_VEC3: return "ivec3"; break;
280 case GL_INT_VEC4: return "ivec4"; break;
281 case GL_UNSIGNED_INT: return "unsigned int"; break;
282 case GL_UNSIGNED_INT_VEC2: return "uvec2"; break;
283 case GL_UNSIGNED_INT_VEC3: return "uvec3"; break;
284 case GL_UNSIGNED_INT_VEC4: return "uvec4"; break;
285 case GL_BOOL: return "bool"; break;
286 case GL_BOOL_VEC2: return "bvec2"; break;
287 case GL_BOOL_VEC3: return "bvec3"; break;
288 case GL_BOOL_VEC4: return "bvec4"; break;
289 case GL_FLOAT_MAT2: return "mat2"; break;
290 case GL_FLOAT_MAT3: return "mat3"; break;
291 case GL_FLOAT_MAT4: return "mat4"; break;
292 case GL_FLOAT_MAT2x3: return "mat2x3"; break;
293 case GL_FLOAT_MAT2x4: return "mat2x4"; break;
294 case GL_FLOAT_MAT3x2: return "mat3x2"; break;
295 case GL_FLOAT_MAT3x4: return "mat3x4"; break;
296 case GL_FLOAT_MAT4x2: return "mat4x2"; break;
297 case GL_FLOAT_MAT4x3: return "mat4x3"; break;
298 case GL_DOUBLE_MAT2: return "dmat2"; break;
299 case GL_DOUBLE_MAT3: return "dmat3"; break;
300 case GL_DOUBLE_MAT4: return "dmat4"; break;
301 case GL_DOUBLE_MAT2x3: return "dmat2x3"; break;
302 case GL_DOUBLE_MAT2x4: return "dmat2x4"; break;
303 case GL_DOUBLE_MAT3x2: return "dmat3x2"; break;
304 case GL_DOUBLE_MAT3x4: return "dmat3x4"; break;
305 case GL_DOUBLE_MAT4x2: return "dmat4x2"; break;
306 case GL_DOUBLE_MAT4x3: return "dmat4x3"; break;
307 case GL_SAMPLER_1D: return "sampler1D"; break;
308 case GL_SAMPLER_2D: return "sampler2D"; break;
309 case GL_SAMPLER_3D: return "sampler3D"; break;
310 case GL_SAMPLER_CUBE: return "samplerCube"; break;
311 case GL_SAMPLER_1D_SHADOW: return "sampler1DShadow"; break;
312 case GL_SAMPLER_2D_SHADOW: return "sampler2DShadow"; break;
313 case GL_SAMPLER_1D_ARRAY: return "sampler1DArray"; break;
314 case GL_SAMPLER_2D_ARRAY: return "sampler2DArray"; break;
315 case GL_SAMPLER_1D_ARRAY_SHADOW: return "sampler1DArrayShadow"; break;
316 case GL_SAMPLER_2D_ARRAY_SHADOW: return "sampler2DArrayShadow"; break;
317 case GL_SAMPLER_2D_MULTISAMPLE: return "sampler2DMS"; break;
318 case GL_SAMPLER_2D_MULTISAMPLE_ARRAY: return "sampler2DMSArray"; break;
319 case GL_SAMPLER_CUBE_SHADOW: return "samplerCubeShadow"; break;
320 case GL_SAMPLER_BUFFER: return "samplerBuffer"; break;
321 case GL_SAMPLER_2D_RECT: return "sampler2DRect"; break;
322 case GL_SAMPLER_2D_RECT_SHADOW: return "sampler2DRectShadow"; break;
323 case GL_INT_SAMPLER_1D: return "isampler1D"; break;
324 case GL_INT_SAMPLER_2D: return "isampler2D"; break;
325 case GL_INT_SAMPLER_3D: return "isampler3D"; break;
326 case GL_INT_SAMPLER_CUBE: return "isamplerCube"; break;
327 case GL_INT_SAMPLER_1D_ARRAY: return "isampler1DArray"; break;
328 case GL_INT_SAMPLER_2D_ARRAY: return "isampler2DArray"; break;
329 case GL_INT_SAMPLER_2D_MULTISAMPLE: return "isampler2DMS"; break;
330 case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: return "isampler2DMSArray"; break;
331 case GL_INT_SAMPLER_BUFFER: return "isamplerBuffer"; break;
332 case GL_INT_SAMPLER_2D_RECT: return "isampler2DRect"; break;
333 case GL_UNSIGNED_INT_SAMPLER_1D: return "usampler1D"; break;
334 case GL_UNSIGNED_INT_SAMPLER_2D: return "usampler2D"; break;
335 case GL_UNSIGNED_INT_SAMPLER_3D: return "usampler3D"; break;
336 case GL_UNSIGNED_INT_SAMPLER_CUBE: return "usamplerCube"; break;
337 case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY: return "usampler2DArray"; break;
338 case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: return "usampler2DArray"; break;
339 case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: return "usampler2DMS"; break;
340 case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: return "usampler2DMSArray"; break;
341 case GL_UNSIGNED_INT_SAMPLER_BUFFER: return "usamplerBuffer"; break;
342 case GL_UNSIGNED_INT_SAMPLER_2D_RECT: return "usampler2DRect"; break;
343 case GL_IMAGE_1D: return "image1D"; break;
344 case GL_IMAGE_2D: return "image2D"; break;
345 case GL_IMAGE_3D: return "image3D"; break;
346 case GL_IMAGE_2D_RECT: return "image2DRect"; break;
347 case GL_IMAGE_CUBE: return "imageCube"; break;
348 case GL_IMAGE_BUFFER: return "imageBuffer"; break;
349 case GL_IMAGE_1D_ARRAY: return "image1DArray"; break;
350 case GL_IMAGE_2D_ARRAY: return "image2DArray"; break;
351 case GL_IMAGE_2D_MULTISAMPLE: return "image2DMS"; break;
352 case GL_IMAGE_2D_MULTISAMPLE_ARRAY: return "image2DMSArray"; break;
353 case GL_INT_IMAGE_1D: return "iimage1D"; break;
354 case GL_INT_IMAGE_2D: return "iimage2D"; break;
355 case GL_INT_IMAGE_3D: return "iimage3D"; break;
356 case GL_INT_IMAGE_2D_RECT: return "iimage2DRect"; break;
357 case GL_INT_IMAGE_CUBE: return "iimageCube"; break;
358 case GL_INT_IMAGE_BUFFER: return "iimageBuffer"; break;
359 case GL_INT_IMAGE_1D_ARRAY: return "iimage1DArray"; break;
360 case GL_INT_IMAGE_2D_ARRAY: return "iimage2DArray"; break;
361 case GL_INT_IMAGE_2D_MULTISAMPLE: return "iimage2DMS"; break;
362 case GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY: return "iimage2DMSArray"; break;
363 case GL_UNSIGNED_INT_IMAGE_1D: return "uimage1D"; break;
364 case GL_UNSIGNED_INT_IMAGE_2D: return "uimage2D"; break;
365 case GL_UNSIGNED_INT_IMAGE_3D: return "uimage3D"; break;
366 case GL_UNSIGNED_INT_IMAGE_2D_RECT: return "uimage2DRect"; break;
367 case GL_UNSIGNED_INT_IMAGE_CUBE: return "uimageCube"; break;
368 case GL_UNSIGNED_INT_IMAGE_BUFFER: return "uimageBuffer"; break;
369 case GL_UNSIGNED_INT_IMAGE_1D_ARRAY: return "uimage1DArray"; break;
370 case GL_UNSIGNED_INT_IMAGE_2D_ARRAY: return "uimage2DArray"; break;
371 case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE: return "uimage2DMS"; break;
372 case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY: return "uimage2DMSArray"; break;
373 case GL_UNSIGNED_INT_ATOMIC_COUNTER: return "atomic_uint"; break;
374 default:
375 return "UNKNOWN type";
376 break;
377 }
378 }
379
380}
381
382void Cogs::EffectsGL20::initialize(GraphicsDeviceGL20* device, CapabilitiesGL20 * capabilities, IBuffers * buffers)
383{
384 this->capabilities = capabilities;
385 graphicsDevice = device;
386 EffectsCommon::initialize(buffers);
387 attributes.initialize();
388 glEnable(GL_CLIP_DISTANCE0);
389
390#ifdef COGS_ENABLE_GLSLANG
391 // glGetIntegerv(GL_MAX_LIGHTS, &resources.maxLights);
392 // glGetIntegerv(GL_MAX_CLIP_PLANES, &resources.maxClipPlanes);
393 // glGetIntegerv(GL_MAX_TEXTURE_UNITS, &resources.maxTextureUnits);
394 // glGetIntegerv(GL_MAX_TEXTURE_COORDS, &resources.maxTextureCoords);
395 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &resources.maxVertexAttribs);
396 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &resources.maxVertexUniformComponents);
397 glGetIntegerv(GL_MAX_VARYING_FLOATS, &resources.maxVaryingFloats);
398 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &resources.maxVertexTextureImageUnits);
399 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &resources.maxCombinedTextureImageUnits);
400 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &resources.maxTextureImageUnits);
401 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &resources.maxFragmentUniformComponents);
402 glGetIntegerv(GL_MAX_DRAW_BUFFERS, &resources.maxDrawBuffers);
403
404 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &resources.maxVertexUniformVectors);
405 glGetIntegerv(GL_MAX_VARYING_VECTORS, &resources.maxVaryingVectors);
406 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &resources.maxFragmentUniformVectors);
407 // glGetIntegerv(, &resources.maxVertexOutputVectors);
408 // glGetIntegerv(, &resources.maxFragmentInputVectors);
409 glGetIntegerv(GL_MIN_PROGRAM_TEXEL_OFFSET, &resources.minProgramTexelOffset);
410 glGetIntegerv(GL_MAX_PROGRAM_TEXEL_OFFSET, &resources.maxProgramTexelOffset);
411 glGetIntegerv(GL_MAX_CLIP_DISTANCES, &resources.maxClipDistances);
412
413 const GraphicsDeviceSettings& settings = device->getSettings();
414
415 if (settings.featureLevelMajor == 4 ||
416 ((settings.featureLevelMajor == 4 ) && (settings.featureLevelMinor >= 3))) {
417 GLint count;
418 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 0, &count);
419 resources.maxComputeWorkGroupCountX = count;
420 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 1, &count);
421 resources.maxComputeWorkGroupCountY = count;
422 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 2, &count);
423 resources.maxComputeWorkGroupCountZ = count;
424 GLint size;
425 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 0, &size);
426 resources.maxComputeWorkGroupSizeX = size;
427 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 1, &size);
428 resources.maxComputeWorkGroupSizeY = size;
429 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 2, &size);
430 resources.maxComputeWorkGroupSizeZ = size;
431 glGetIntegerv(GL_MAX_COMPUTE_UNIFORM_COMPONENTS, &resources.maxComputeUniformComponents);
432 glGetIntegerv(GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS, &resources.maxComputeTextureImageUnits);
433 glGetIntegerv(GL_MAX_COMPUTE_IMAGE_UNIFORMS, &resources.maxComputeImageUniforms);
434 glGetIntegerv(GL_MAX_COMPUTE_ATOMIC_COUNTERS, &resources.maxComputeAtomicCounters);
435 glGetIntegerv(GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS, &resources.maxComputeAtomicCounterBuffers);
436 }
437 glGetIntegerv(GL_MAX_VARYING_COMPONENTS, &resources.maxVaryingComponents);
438 glGetIntegerv(GL_MAX_VERTEX_OUTPUT_COMPONENTS, &resources.maxVertexOutputComponents);
439 glGetIntegerv(GL_MAX_GEOMETRY_INPUT_COMPONENTS, &resources.maxGeometryInputComponents);
440 glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_COMPONENTS, &resources.maxGeometryOutputComponents);
441 glGetIntegerv(GL_MAX_FRAGMENT_INPUT_COMPONENTS, &resources.maxFragmentInputComponents);
442 glGetIntegerv(GL_MAX_IMAGE_UNITS, &resources.maxImageUnits);
443 glGetIntegerv(GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS, &resources.maxCombinedImageUnitsAndFragmentOutputs);
444 glGetIntegerv(GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES, &resources.maxCombinedShaderOutputResources);
445 glGetIntegerv(GL_MAX_IMAGE_SAMPLES, &resources.maxImageSamples);
446
447 glGetIntegerv(GL_MAX_VERTEX_IMAGE_UNIFORMS, &resources.maxVertexImageUniforms);
448 glGetIntegerv(GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS, &resources.maxTessControlImageUniforms);
449 glGetIntegerv(GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS, &resources.maxTessEvaluationImageUniforms);
450 glGetIntegerv(GL_MAX_GEOMETRY_IMAGE_UNIFORMS, &resources.maxGeometryImageUniforms);
451 glGetIntegerv(GL_MAX_FRAGMENT_IMAGE_UNIFORMS, &resources.maxFragmentImageUniforms);
452 glGetIntegerv(GL_MAX_COMBINED_IMAGE_UNIFORMS, &resources.maxCombinedImageUniforms);
453
454 glGetIntegerv(GL_MAX_VIEWPORTS, &resources.maxViewports);
455
456 glGetIntegerv(GL_MAX_VERTEX_ATOMIC_COUNTERS, &resources.maxVertexAtomicCounters);
457 glGetIntegerv(GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS, &resources.maxTessControlAtomicCounters);
458 glGetIntegerv(GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS, &resources.maxTessEvaluationAtomicCounters);
459 glGetIntegerv(GL_MAX_GEOMETRY_ATOMIC_COUNTERS, &resources.maxGeometryAtomicCounters);
460 glGetIntegerv(GL_MAX_FRAGMENT_ATOMIC_COUNTERS, &resources.maxFragmentAtomicCounters);
461 glGetIntegerv(GL_MAX_COMBINED_ATOMIC_COUNTERS, &resources.maxCombinedAtomicCounters);
462
463 glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, &resources.maxAtomicCounterBindings);
464
465 glGetIntegerv(GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS, &resources.maxVertexAtomicCounterBuffers);
466 glGetIntegerv(GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS, &resources.maxTessControlAtomicCounterBuffers);
467 glGetIntegerv(GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS, &resources.maxTessEvaluationAtomicCounterBuffers);
468 glGetIntegerv(GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS, &resources.maxGeometryAtomicCounterBuffers);
469 glGetIntegerv(GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS, &resources.maxFragmentAtomicCounterBuffers);
470 glGetIntegerv(GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS, &resources.maxCombinedAtomicCounterBuffers);
471
472 glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE, &resources.maxAtomicCounterBufferSize);
473 glGetIntegerv(GL_MAX_CULL_DISTANCES, &resources.maxCullDistances);
474 glGetIntegerv(GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES, &resources.maxCombinedClipAndCullDistances);
475 glGetIntegerv(GL_MAX_SAMPLES, &resources.maxSamples);
476#endif
477}
478
479ShaderHandle Cogs::EffectsGL20::loadShader(GLenum shaderType, const char * pSource, EffectFlags::EEffectFlags effectFlags, PreprocessorDefinitions definitions)
480{
481 if (pSource[0] == '\0') return ShaderHandle::NoHandle;
482
483 const GLuint shaderId = glCreateShader(shaderType);
484 assert(shaderId);
485
486 if (shaderId) {
487 if (definitions.size() == 0) {
488 glShaderSource(shaderId, 1, &pSource, nullptr);
489 } else {
490 std::vector<std::string> defines(definitions.size());
491
492 for (size_t i = 0; i < definitions.size(); ++i) {
493 if (definitions[i].first == "version") {
494 if (i != 0) {
495 LOG_ERROR(logger, "Version tag must be first.");
496
497 return ShaderHandle::InvalidHandle;
498 }
499
500 defines[i] = "#version " + definitions[i].second + "\n";
501 } else {
502 defines[i] = "#define " + definitions[i].first + " " + definitions[i].second + "\n";
503 }
504 }
505
506 std::vector<const char *> strings(definitions.size());
507
508 for (size_t i = 0; i < definitions.size(); ++i) {
509 strings[i] = defines[i].c_str();
510 }
511
512 strings.push_back(pSource);
513
514 glShaderSource(shaderId, static_cast<GLsizei>(strings.size()), strings.data(), nullptr);
515 }
516
517 glCompileShader(shaderId);
518
519 GLint compiled = 0;
520 glGetShaderiv(shaderId, GL_COMPILE_STATUS, &compiled);
521
522 if (compiled != GL_TRUE) {
523 printShaderLog(shaderType, shaderId, effectFlags);
524
525 glDeleteShader(shaderId);
526
527 return ShaderHandle::InvalidHandle;
528 } else {
529 printShaderLog(shaderType, shaderId, effectFlags, false);
530 }
531 }
532
533 return this->shaderIds.addResource(shaderId);
534}
535
536Cogs::EffectHandle Cogs::EffectsGL20::loadProgram(ShaderHandle vertexShader, ShaderHandle hullShader, ShaderHandle domainShader, ShaderHandle geometryShader, ShaderHandle pixelShader, EffectFlags::EEffectFlags effectFlags, bool hlsl)
537{
538 GLuint programId = glCreateProgram();
539 assert(programId);
540
541 if (programId == GL_INVALID_INDEX) {
542 return EffectHandle::InvalidHandle;
543 }
544
545 if (HandleIsValid(vertexShader)) {
546 glAttachShader(programId, this->shaderIds[vertexShader]);
547 checkGLError("glAttachShader");
548 }
549
550 if (HandleIsValid(hullShader)) {
551 glAttachShader(programId, this->shaderIds[hullShader]);
552 checkGLError("glAttachShader");
553 }
554
555 if (HandleIsValid(domainShader)) {
556 glAttachShader(programId, this->shaderIds[domainShader]);
557 checkGLError("glAttachShader");
558 }
559
560 if (HandleIsValid(geometryShader)) {
561 glAttachShader(programId, this->shaderIds[geometryShader]);
562 checkGLError("glAttachShader");
563 }
564
565 if (HandleIsValid(pixelShader)) {
566 glAttachShader(programId, this->shaderIds[pixelShader]);
567 checkGLError("glAttachShader");
568 }
569
570 glLinkProgram(programId);
571
572 GLint linkStatus = GL_FALSE;
573 glGetProgramiv(programId, GL_LINK_STATUS, &linkStatus);
574
575 if (linkStatus != GL_TRUE) {
576 printProgramError(programId, effectFlags);
577
578 glDeleteProgram(programId);
579
580 return EffectHandle::InvalidHandle;
581 } else {
582 printProgramError(programId, effectFlags, false);
583 }
584
585 GLint savedProgram = 0;
586 glGetIntegerv(GL_CURRENT_PROGRAM, &savedProgram);
587 glUseProgram(programId);
588
589 EffectGL20 effect;
590 effect.programId = programId;
591 effect.pixelShader.shaderHandle = pixelShader;
592 effect.vertexShader.shaderHandle = vertexShader;
593 effect.geometryShader.shaderHandle = geometryShader;
594 effect.computeShader.shaderHandle = ShaderHandle::NoHandle;
595
596 const bool logInputs = false;
597
598#ifndef __APPLE__
599 GLint activeAtomicCounterBuffers = 0;
600 glGetProgramiv(programId, GL_ACTIVE_ATOMIC_COUNTER_BUFFERS, &activeAtomicCounterBuffers);
601 for (int i = 0; i < activeAtomicCounterBuffers; i++) {
602 AtomicCounterBufferGL20 b;
603 glGetActiveAtomicCounterBufferiv(programId, i, GL_ATOMIC_COUNTER_BUFFER_BINDING, &b.binding);
604 glGetActiveAtomicCounterBufferiv(programId, i, GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE, &b.dataSize);
605
606 GLuint bufferName = 0;
607 glGenBuffers(1, &bufferName);
608 glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bufferName);
609 glBufferData(GL_ATOMIC_COUNTER_BUFFER, b.dataSize, nullptr, GL_STREAM_COPY);
610 glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0);
611 b.backingBuffer = this->backingBuffers.addResource(bufferName);
612
613 if (logInputs) LOG_INFO(logger, "Atomic counter buffer %d: name=%d, binding=%d, size=%d", i, bufferName, b.binding, b.dataSize);
614 effect.atomicCounterBuffers.push_back(b);
615 }
616#endif
617
618 GLint activeUniforms = 0, uniformMaxLength = 0;
619 glGetProgramiv(programId, GL_ACTIVE_UNIFORMS, &activeUniforms);
620 glGetProgramiv(programId, GL_ACTIVE_UNIFORM_MAX_LENGTH, &uniformMaxLength);
621 std::vector<char> nameBuf(uniformMaxLength);
622 for (GLuint i = 0; i < static_cast<GLuint>(activeUniforms); i++) {
623 GLsizei length = 0;
624 GLenum type = 0;
625 GLint size = 0;
626 glGetActiveUniform(programId, static_cast<GLsizei>(i), static_cast<GLsizei>(nameBuf.size()), &length, &size, &type, nameBuf.data());
627
628 if (type == GL_UNSIGNED_INT_ATOMIC_COUNTER) {
629 AtomicCounterVariableGL20 v = { nameBuf.data(), i, 0, 0 };
630
631 glGetActiveUniformsiv(programId, 1, &v.uniformIndex, GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX, &v.bufferIndex);
632 glGetActiveUniformsiv(programId, 1, &v.uniformIndex, GL_UNIFORM_OFFSET, &v.bufferOffset);
633
634 if (logInputs) LOG_DEBUG(logger, "Program %d: Active uniform %d: type='%s', symbol='%s', buffer index=%d, offset=%d.", programId, i, getShaderUniformTypeString(type), nameBuf.data(), v.bufferIndex, v.bufferOffset);
635 effect.atomicCounterVariables.push_back(v);
636 } else if(type == GL_SAMPLER_1D ||
637 type == GL_SAMPLER_2D ||
638 type == GL_SAMPLER_3D ||
639 type == GL_SAMPLER_CUBE ||
640 type == GL_SAMPLER_1D_SHADOW ||
641 type == GL_SAMPLER_2D_SHADOW ||
642 type == GL_SAMPLER_1D_ARRAY ||
643 type == GL_SAMPLER_2D_ARRAY ||
644 type == GL_SAMPLER_1D_ARRAY_SHADOW ||
645 type == GL_SAMPLER_2D_ARRAY_SHADOW ||
646 type == GL_SAMPLER_2D_MULTISAMPLE ||
647 type == GL_SAMPLER_2D_MULTISAMPLE_ARRAY ||
648 type == GL_SAMPLER_CUBE_SHADOW ||
649 type == GL_SAMPLER_BUFFER ||
650 type == GL_SAMPLER_2D_RECT ||
651 type == GL_SAMPLER_2D_RECT_SHADOW ||
652 type == GL_INT_SAMPLER_1D ||
653 type == GL_INT_SAMPLER_2D ||
654 type == GL_INT_SAMPLER_3D ||
655 type == GL_INT_SAMPLER_CUBE ||
656 type == GL_INT_SAMPLER_1D_ARRAY ||
657 type == GL_INT_SAMPLER_2D_ARRAY ||
658 type == GL_INT_SAMPLER_2D_MULTISAMPLE ||
659 type == GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY ||
660 type == GL_INT_SAMPLER_BUFFER ||
661 type == GL_INT_SAMPLER_2D_RECT ||
662 type == GL_UNSIGNED_INT_SAMPLER_1D ||
663 type == GL_UNSIGNED_INT_SAMPLER_2D ||
664 type == GL_UNSIGNED_INT_SAMPLER_3D ||
665 type == GL_UNSIGNED_INT_SAMPLER_CUBE ||
666 type == GL_UNSIGNED_INT_SAMPLER_1D_ARRAY ||
667 type == GL_UNSIGNED_INT_SAMPLER_2D_ARRAY ||
668 type == GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE ||
669 type == GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY ||
670 type == GL_UNSIGNED_INT_SAMPLER_BUFFER ||
671 type == GL_UNSIGNED_INT_SAMPLER_2D_RECT){
672 GLint size2 = 0;
673 glGetActiveUniformsiv(programId, 1, &i, GL_UNIFORM_SIZE, &size2);
674
675 std::string alt(nameBuf.data());
676 std::string name = alt.substr(0, alt.find('['));
677
678 {
679 auto samplerHash = Cogs::hash(name + "Sampler");
680 effect.samplers[samplerHash] = { effect.unitsInUse, size2 };
681 // LOG_INFO(logger, "ASamplers %s %zu: %u", StringView(name + "Sampler").data(), samplerHash, effect.unitsInUse);
682 }
683 {
684 auto samplerHash = Cogs::hash(name);
685 effect.samplers[samplerHash] = { effect.unitsInUse, size2 };
686 // LOG_INFO(logger, "ASamplers2 %s %zu: %u", StringView(name).data(), samplerHash, effect.unitsInUse);
687 }
688
689 // LOG_INFO(logger, "size %d", size2);
690 if(size2 == 1){
691 auto textureHash = Cogs::hash(StringView(nameBuf.data(), length));
692 effect.textures[textureHash] = effect.unitsInUse;
693 effect.samplers[textureHash] = { effect.unitsInUse, 1 };
694 // LOG_INFO(logger, "Samplers %s %zu: %u", StringView(nameBuf.data(), length).data(), textureHash, effect.unitsInUse);
695
696 GLint location = glGetUniformLocation(programId, nameBuf.data());
697 assert(0 <= location);
698 glUniform1i(location, effect.unitsInUse);
699
700 effect.unitsInUse++;
701 }
702 else{
703 for(GLint j=0; j<size2; j++){
704 std::string namea = name + '[' + std::to_string(j) + ']';
705 auto textureHash = Cogs::hash(namea);
706 effect.textures[textureHash] = effect.unitsInUse;
707 effect.samplers[textureHash] = { effect.unitsInUse, 1 };
708 // LOG_INFO(logger, "Samplers %s %zu: %u", namea.c_str(), textureHash, effect.unitsInUse);
709
710 GLint location = glGetUniformLocation(programId, namea.c_str());
711 assert(0 <= location);
712 glUniform1i(location, effect.unitsInUse);
713
714 effect.unitsInUse++;
715 }
716 }
717 } else {
718 if (logInputs) LOG_DEBUG(logger, "Program %d: Active uniform %d: type='%s', symbol='%s'.", programId, i, getShaderUniformTypeString(type), nameBuf.data());
719 }
720 }
721
722 ::memset(&effect.attributeMap, InvalidAttributeLocationGL20, MaxVertexAttributesGL20);
723
724 GLint activeAttributes = 0;
725 glGetProgramiv(programId, GL_ACTIVE_ATTRIBUTES, &activeAttributes);
726
727 GLint maxLength = 0;
728 glGetProgramiv(programId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxLength);
729
730 std::vector<char> buffer(maxLength);
731
732 for (int i = 0; i < activeAttributes; ++i) {
733 GLsizei length = 0;
734 GLint size = 0;
735 GLenum type = GL_INVALID_ENUM;
736
737 glGetActiveAttrib(programId, static_cast<GLsizei>(i), static_cast<GLsizei>(buffer.size()), &length, &size, &type, buffer.data());
738
739 const GLint index = this->attributes.getAttributeIndex(std::string(buffer.data()), hlsl);
740 const GLint location = glGetAttribLocation(programId, buffer.data());
741
742 if (uint32_t(index) != GL_INVALID_INDEX && uint32_t(location) != GL_INVALID_INDEX) {
743 assert(location >= 0 && location <= 255 && "Attribute location out of range.");
744 effect.attributeMap[index] = static_cast<unsigned char>(location);
745 }
746
747 if (logInputs) LOG_DEBUG(logger, "Program %d: Active attribute %d: type='%s', symbol='%s'.", programId, i, getShaderUniformTypeString(type), buffer.data());
748 }
749
750 glUseProgram(savedProgram);
751 return this->effects.addResource(std::move(effect));
752}
753
754void Cogs::EffectsGL20::releaseEffect(EffectHandle handle)
755{
756 if (!HandleIsValid(handle)) return;
757 ContextGL20 *context = (ContextGL20*)graphicsDevice->getImmediateContext();
758 if(context->getEffect() == handle)
759 context->setEffect(EffectHandle::NoHandle);
760
761 auto & effect = this->effects[handle];
762
763 for (auto & s : effect.shaders) {
764 if (HandleIsValid(s.shaderHandle)) {
765 releaseShader(s.shaderHandle);
766 }
767 }
768
769 glDeleteProgram(this->effects[handle].programId);
770
771 for (auto & b : effect.atomicCounterBuffers) {
772 auto name = this->backingBuffers[b.backingBuffer];
773 glDeleteBuffers(1, &name);
774 this->backingBuffers.removeResource(b.backingBuffer);
775 }
776
777 for(auto smap : effect.sampler_map){
778 delete smap.second;
779 }
780
781 this->effects.removeResource(handle);
782}
783
784void Cogs::EffectsGL20::releaseShader(ShaderHandle shaderHandle)
785{
786 glDeleteShader(this->shaderIds[shaderHandle]);
787 this->shaderIds.removeResource(shaderHandle);
788}
789
790Cogs::ConstantBufferBindingHandle Cogs::EffectsGL20::getConstantBufferBinding(EffectHandle effectHandle, const StringView & name)
791{
792 assert(HandleIsValid(effectHandle) && this->effects.hasResource(effectHandle) && "Effect handle not valid.");
793
794 const GLuint programId = this->effects[effectHandle].programId;
795
796 auto index = glGetUniformBlockIndex(programId, name.data());
797
798 if (index == GL_INVALID_INDEX) {
799 return ConstantBufferBindingHandle::InvalidHandle;
800 }
801
802 ConstantBufferBindingHandle handle((uint64_t)programId << 32 | index);
803
804 return handle;
805}
806
807BufferBindingHandle Cogs::EffectsGL20::getBufferBinding(EffectHandle effectHandle, const StringView & name_view)
808{
809 assert(HandleIsValid(effectHandle) && this->effects.hasResource(effectHandle) && "Effect handle not valid.");
810
811#ifndef __APPLE__
812 std::string name = std::string(name_view);
813 const auto& effect = this->effects[effectHandle];
814 const auto programId = effect.programId;
815
816 auto index = glGetProgramResourceIndex(programId, GL_SHADER_STORAGE_BLOCK, name.c_str());
817 if (index == GL_INVALID_INDEX) {
818 auto alt_name = "_" + name;
819 index = glGetProgramResourceIndex(programId, GL_SHADER_STORAGE_BLOCK, alt_name.c_str());
820 if (index == GL_INVALID_INDEX) {
821 LOG_DEBUG(logger, "Failed to get index of shader storage block '%s'.", name.c_str());
822 return BufferBindingHandle::InvalidHandle;
823 }
824 }
825
826 GLenum props[] = {GL_BUFFER_BINDING};
827 GLint shaderStorageBinding = -1;
828 glGetProgramResourceiv(programId, GL_SHADER_STORAGE_BLOCK, index,
829 1, props,
830 static_cast<GLsizei>(sizeof(shaderStorageBinding)), nullptr, &shaderStorageBinding);
831
832 uint32_t atomicCounterBinding = 0;
833 auto counterName = name + "_Store_counter";
834 for (uint32_t i = 0; i < effect.atomicCounterVariables.size(); i++) {
835 if (effect.atomicCounterVariables[i].name == counterName) {
836 atomicCounterBinding = i;
837 //LOG_INFO(logger, "Found atomic counter binding '%s'at %d.", counterName.c_str(), i);
838 break;
839 }
840 }
841
842 BufferBindingHandle handle((uint64_t(shaderStorageBinding) + 1) << 32 | (uint64_t(atomicCounterBinding) + 1));
843
844 return handle;
845#else
846 (void)effectHandle;
847 (void)name_view;
848 assert(false);
849 return BufferBindingHandle::InvalidHandle;
850#endif
851}
852
853void Cogs::EffectsGL20::releaseBufferBinding(BufferBindingHandle /*bufferBindingHandle*/)
854{
855
856}
857
858
859void Cogs::EffectsGL20::releaseResources()
860{
861 auto context = graphicsDevice->getImmediateContext();
862 context->setEffect(EffectHandle::NoHandle);
863 std::vector<EffectHandle> handles;
864 for (auto & effect : effects) {
865 auto handle = effects.getHandle(effect);
866 if (!effects.pinned(handle)) {
867 handles.emplace_back(handle);
868 }
869 }
870
871 for (auto & handle : handles) {
872 releaseEffect(handle);
873 }
874}
875
876Cogs::EffectHandle Cogs::EffectsGL20::loadComputeEffect(const StringView & fileName, EffectFlags::EEffectFlags effectFlags)
877{
878 return this->loadComputeEffect(fileName, PreprocessorDefinitions(), effectFlags);
879}
880
881Cogs::EffectHandle Cogs::EffectsGL20::load(
882 const ProcessedContent & vsSource,
883 const ProcessedContent & hsSource,
884 const ProcessedContent & dsSource,
885 const ProcessedContent & gsSource,
886 const ProcessedContent & psSource,
887 const StringView & vsEntryPoint,
888 const StringView & hsEntryPoint,
889 const StringView & dsEntryPoint,
890 const StringView & gsEntryPoint,
891 const StringView & psEntryPoint,
892 const EffectDescription & desc)
893{
894 const bool isHlsl = !(desc.flags & EffectFlags::GLSL);
895 bool hlslAttr = false;
896
897 ShaderSource processedSource;
898
899 if (&vsSource == &psSource) {
900 processedSource.shaderSource = vsSource.content;
901 } else {
902 processedSource.vsSource = vsSource.content;
903 processedSource.gsSource = gsSource.content;
904 processedSource.psSource = psSource.content;
905 }
906
907 ShaderReflectionInfo reflectionInfo[(size_t)ShaderType::NumShaderSlots];
908
909 ShaderHandle vertexShader = ShaderHandle::InvalidHandle;
910 ShaderHandle hullShader = ShaderHandle::InvalidHandle;
911 ShaderHandle domainShader = ShaderHandle::InvalidHandle;
912 ShaderHandle geometryShader = ShaderHandle::InvalidHandle;
913 ShaderHandle pixelShader = ShaderHandle::InvalidHandle;
914
915 std::unordered_map<size_t, std::vector<size_t>> real_sampler;
916
917 if (isHlsl) {
918#ifdef COGS_ENABLE_GLSLANG
919 glslang::InitializeProcess();
920
921 struct ShaderInput
922 {
923 ShaderType::EShaderType type;
924 const char * stage;
925 const std::string & source;
926 const StringView & entryPoint;
927 EShLanguage language;
928 int num;
929 };
930
931 int targetVersion =
932 capabilities->getDeviceCapabilities().featureLevelMajor * 100 +
933 capabilities->getDeviceCapabilities().featureLevelMinor * 10;
934
935 std::vector<ShaderInput> inputs;
936 if(vsSource.content.size()){
937 inputs.push_back(
938 {ShaderType::VertexShader, "VS", vsSource.content, vsEntryPoint, EShLangVertex, shader_num++ });
939 }
940 if(hsSource.content.size()){
941 targetVersion = std::max(targetVersion, 410);
942 inputs.push_back(
943 { ShaderType::HullShader, "HS", hsSource.content, hsEntryPoint, EShLangTessControl, shader_num++ });
944 }
945 if(dsSource.content.size()){
946 targetVersion = std::max(targetVersion, 410);
947 inputs.push_back(
948 { ShaderType::DomainShader, "DS", dsSource.content, dsEntryPoint, EShLangTessEvaluation, shader_num++ });
949 }
950 if(gsSource.content.size()){
951 targetVersion = std::max(targetVersion, 410);
952 inputs.push_back(
953 { ShaderType::GeometryShader, "GS", gsSource.content, gsEntryPoint, EShLangGeometry, shader_num++ });
954 }
955 if(psSource.content.size()){
956 inputs.push_back(
957 { ShaderType::PixelShader, "PS", psSource.content, psEntryPoint, EShLangFragment, shader_num++ });
958 }
959
960 std::string strings[ShaderType::NumShaderTypes];
961
962 glslang::TProgram program;
963 std::vector<std::unique_ptr<glslang::TShader>> shaders(ShaderType::NumShaderTypes);
964 std::unordered_map<size_t, std::string> variableMap;
965
966 for (auto & shaderSource : inputs) {
967 shaders[shaderSource.language] = std::make_unique<glslang::TShader>(shaderSource.language);
968 auto & shader = *shaders[shaderSource.language];
969
970 std::vector<std::string> definitions(desc.definitions.size()+1);
971 std::vector<const char *> shaderStrings(desc.definitions.size()+3);
972
973 shaderStrings[0] = "#pragma pack_matrix(row_major)\n";
974 for (size_t i = 0; i < desc.definitions.size(); ++i) {
975 auto & d = desc.definitions[i];
976 auto str = "#define " + d.first + " " + d.second + "\n";
977 definitions[i] = str;
978 shaderStrings[i+1] = definitions[i].c_str();
979 }
980 {
981 size_t i = definitions.size()-1;
982 auto str = "#define GLSLANG\n";
983 definitions[i] = str;
984 shaderStrings[i+1] = definitions[i].c_str();
985 }
986
987 shaderStrings[shaderStrings.size()-1] = shaderSource.source.c_str();
988
989#ifdef COGS_DUMP_SHADERS
990 {
991 char num[8] = {};
992 sprintf(num, "%04d", shaderSource.num);
993 std::string file = IO::getTempPath() + num + ".hlsl";
994 FILE *fp = fopen(file.c_str(), "wb");
995 if(fp){
996 LOG_INFO(logger, "Write HLSL to %s", file.c_str());
997 for(auto &t : shaderStrings){
998 fprintf(fp, "%s", t);
999 }
1000 fclose(fp);
1001 }
1002 }
1003#endif
1004
1005 shader.setStrings(shaderStrings.data(), (int)shaderStrings.size());
1006 shader.setEntryPoint(shaderSource.entryPoint.data());
1007 shader.setSourceEntryPoint(shaderSource.entryPoint.data());
1008 // shader.setAutoMapBindings(true);
1009 // shader.setAutoMapLocations(true);
1010 shader.setHlslIoMapping(true);
1011 shader.setEnvInput(glslang::EShSourceHlsl, shaderSource.language, glslang::EShClientOpenGL, 100);
1012 shader.setEnvTarget(glslang::EshTargetSpv, glslang::EShTargetSpv_1_3);
1013 shader.setEnvClient(glslang::EShClientOpenGL, glslang::EShTargetOpenGL_450);
1014 shader.setEnvTargetHlslFunctionality1();
1015
1016 int defaultVersion = 460;
1017 bool forwardCompatible = true;
1018
1019 EShMessages messages = EShMsgDefault;
1020 std::string pOutput;
1021 glslang::TShader::ForbidIncluder includer;
1022 //shader.preprocess(&resources, defaultVersion, ECoreProfile, false, forwardCompatible, messages, &pOutput, includer);
1023 shader.parse(&resources, defaultVersion, ECoreProfile, false, forwardCompatible, messages, includer);
1024
1025 auto infoLog = StringView(shader.getInfoLog());
1026 if(!infoLog.empty()){
1027 LOG_INFO(logger, "glslang info_log: %s", infoLog.data());
1028 }
1029
1030 auto infoDebugLog = StringView(shader.getInfoDebugLog());
1031 if(!infoDebugLog.empty()){
1032 LOG_INFO(logger, "glslang info_debug_log: %s", infoDebugLog.data());
1033 }
1034
1035 program.addShader(&shader);
1036 }
1037
1038 EShMessages messages = EShMsgDefault;
1039 program.link(messages);
1040
1041 auto linkInfo = StringView(program.getInfoLog());
1042 if (!linkInfo.empty()) {
1043 LOG_WARNING(logger, "%s", linkInfo.data());
1044 }
1045
1046 program.mapIO();
1047
1048 auto ioInfo = StringView(program.getInfoLog());
1049 if (!ioInfo.empty()) {
1050 LOG_WARNING(logger, "%s", ioInfo.data());
1051 }
1052
1053 program.buildReflection();
1054
1055 auto reflectionInfoLog = StringView(program.getInfoLog());
1056 if (!reflectionInfoLog.empty()) {
1057 LOG_WARNING(logger, "%s", reflectionInfoLog.data());
1058 }
1059
1060 for (auto & shaderSource : inputs) {
1061 std::vector<unsigned int> spirv;
1062
1063 spv::SpvBuildLogger buildLogger;
1064
1065 glslang::SpvOptions spvOptions;
1066 spvOptions.generateDebugInfo = false;
1067 spvOptions.disableOptimizer = false;
1068 spvOptions.optimizeSize = false;
1069
1070 auto intermediateShader = program.getIntermediate(shaderSource.language);
1071 glslang::GlslangToSpv(*intermediateShader, spirv, &buildLogger, &spvOptions);
1072 if(!spirv.size())
1073 continue;
1074
1075#ifdef COGS_DUMP_SHADERS
1076 {
1077 char num[8] = {};
1078 sprintf(num, "%04d", shaderSource.num);
1079 std::string file = IO::getTempPath() + num + ".spv";
1080 std::ofstream out(file.c_str(), std::ofstream::out);
1081 if(out){
1082 LOG_INFO(logger, "Write SPV to %s", file.c_str());
1083 spv::Disassemble(out, spirv);
1084 }
1085 }
1086#endif
1087
1088 spirv_cross::CompilerGLSL glsl(std::move(spirv));
1089 glsl.build_dummy_sampler_for_combined_images();
1090 glsl.build_combined_image_samplers();
1091
1092 spirv_cross::ShaderResources shaderResources;
1093 auto active = glsl.get_active_interface_variables();
1094 shaderResources = glsl.get_shader_resources(active);
1095 glsl.set_enabled_interface_variables(move(active));
1096
1097 for (auto & input : shaderResources.stage_inputs) {
1098 auto location = glsl.get_decoration(input.id, spv::DecorationLocation);
1099 auto hlslSemantic = glsl.get_decoration_string(input.id, spv::DecorationHlslSemanticGOOGLE);
1100 auto[semantic, semanticIndex] = getSemanticWithIndex(hlslSemantic);
1101 auto isBuiltIn = glsl.get_decoration(input.id, spv::DecorationBuiltIn);
1102
1103 if (!isBuiltIn) {
1104 std::string newName;
1105
1106 // Assign _a to VS input attributes and _v to PS input varyings.
1107 switch (shaderSource.type) {
1108 case ShaderType::GeometryShader: newName = "vsOutput"; break;
1109 case ShaderType::PixelShader: newName = gsSource.content.empty() ? "vsOutput" : "gsOutput"; break;
1110 case ShaderType::VertexShader: newName = "a_"; break;
1111 }
1112 glsl.set_name(input.id, newName + std::string(semantic) + std::to_string(semanticIndex));
1113 }
1114
1115 LOG_TRACE(logger, "%s Input: %s, [%s] %d", shaderSource.stage, input.name.c_str(), hlslSemantic.c_str(), location);
1116 }
1117
1118 auto & combinedSamplers = glsl.get_combined_image_samplers();
1119
1120 for (auto & c : combinedSamplers) {
1121 auto & tex = glsl.get_name(c.image_id);
1122 glsl.set_name(c.combined_id, tex);
1123 auto & sampler = glsl.get_name(c.sampler_id);
1124 auto & combined = glsl.get_name(c.combined_id);
1125
1126 auto samplerHash = Cogs::hash(sampler);
1127 // LOG_INFO(logger, " %s Image %s, Sampler: %s: Combined %s", shaderSource.stage, tex.c_str(), sampler.c_str(), combined.c_str());
1128 // LOG_INFO(logger, " real_sampler %zu:%zu", samplerHash, Cogs::hash(combined));
1129 real_sampler[samplerHash].push_back(Cogs::hash(StringView(combined.c_str())));
1130
1131 variableMap[Cogs::hash(tex)] = sampler;
1132 }
1133
1134 for (auto & input : shaderResources.uniform_buffers) {
1135 auto loc = glsl.get_decoration(input.id, spv::DecorationBinding);
1136
1137 LOG_TRACE(logger, "%s Uniform buffer: %s, %d", shaderSource.stage, input.name.c_str(), loc);
1138
1139 glsl.set_name(input.id, "_" + input.name);
1140
1141 auto activeMembers = glsl.get_active_buffer_ranges(input.id);
1142 auto & baseType = glsl.get_type(input.base_type_id);
1143
1144 for (auto & m : activeMembers) {
1145 auto & member = glsl.get_member_name(input.base_type_id, m.index);
1146 auto & memberTypeId = baseType.member_types[m.index];
1147 auto & memberType = glsl.get_type(memberTypeId);
1148 auto & memberBase = memberType.parent_type ? glsl.get_type(memberType.parent_type) : memberType;
1149
1150 auto size = glsl.get_declared_struct_member_size(baseType, m.index);
1151
1152 LOG_TRACE(logger, " %s, size: %zu", member.c_str(), size);
1153
1154 if (!memberType.array.empty()) {
1155 for (size_t i = 0; i < memberType.array[0]; ++i) {
1156 if (memberBase.basetype == spirv_cross::SPIRType::Struct) {
1157 for (uint32_t j = 0; j < memberBase.member_types.size(); ++j) {
1158 auto & nestedMember = glsl.get_member_name(memberType.parent_type, j);
1159
1160 auto mn = member + "[" + std::to_string(i) + "]." + nestedMember;
1161 auto nn = "_" + input.name + "." + mn;
1162
1163 variableMap[Cogs::hash(mn)] = nn;
1164 }
1165 } else {
1166 auto mn = member + "[" + std::to_string(i) + "]";
1167 auto nn = "_" + input.name + "." + mn;
1168 variableMap[Cogs::hash(mn)] = nn;
1169 }
1170 }
1171 } else {
1172 variableMap[Cogs::hash(member)] = "_" + input.name + "." + member;
1173 }
1174 }
1175 }
1176
1177 for (auto & output : shaderResources.stage_outputs) {
1178 auto location = glsl.get_decoration(output.id, spv::DecorationLocation);
1179 auto hlslSemantic = glsl.get_decoration_string(output.id, spv::DecorationHlslSemanticGOOGLE);
1180 auto[semantic, semanticIndex] = getSemanticWithIndex(hlslSemantic);
1181 auto isBuiltIn = glsl.get_decoration(output.id, spv::DecorationBuiltIn);
1182
1183 if (!isBuiltIn) {
1184 std::string newName;
1185
1186 switch (shaderSource.type) {
1187 case ShaderType::GeometryShader: newName = "gsOutput"; break;
1188 case ShaderType::VertexShader: newName = "vsOutput"; break;
1189 }
1190 glsl.set_name(output.id, newName + std::string(semantic) + std::to_string(semanticIndex));
1191 }
1192
1193 LOG_TRACE(logger, "%s Output: %s, [%s] %d", shaderSource.stage, output.name.c_str(), hlslSemantic.c_str(), location);
1194 }
1195
1196 spirv_cross::CompilerGLSL::Options options;
1197#if defined( __APPLE__ )
1198 options.enable_420pack_extension = false;
1199#endif
1200 options.version = targetVersion;
1201 options.es = false;
1202 glsl.set_common_options(options);
1203
1204 auto glslSource = glsl.compile();
1205 strings[shaderSource.type] = glslSource;
1206
1207#ifdef COGS_DUMP_SHADERS
1208 {
1209 char num[8] = {};
1210 sprintf(num, "%04d", shaderSource.num);
1211 std::string file = IO::getTempPath() + num + ".glsl";
1212 FILE *fp = fopen(file.c_str(), "wb");
1213 if(fp){
1214 LOG_INFO(logger, "Write GLSL to %s", file.c_str());
1215 fprintf(fp, "%s", glslSource.c_str());
1216 fclose(fp);
1217 }
1218 }
1219#endif
1220
1221 if(shaderSource.type == ShaderType::VertexShader){
1222 vertexShader = loadShader(GL_VERTEX_SHADER, glslSource.c_str(), {});
1223 }
1224 if(shaderSource.type == ShaderType::HullShader){
1225 hullShader = loadShader(GL_TESS_CONTROL_SHADER, glslSource.c_str(), {});
1226 }
1227 if(shaderSource.type == ShaderType::DomainShader){
1228 domainShader = loadShader(GL_TESS_EVALUATION_SHADER, glslSource.c_str(), {});
1229 }
1230 if(shaderSource.type == ShaderType::GeometryShader){
1231 geometryShader = loadShader(GL_GEOMETRY_SHADER, glslSource.c_str(), {});
1232 }
1233 if(shaderSource.type == ShaderType::PixelShader){
1234 pixelShader = loadShader(GL_FRAGMENT_SHADER, glslSource.c_str(), {});
1235 }
1236 }
1237
1238 glslang::FinalizeProcess();
1239#else
1240 LOG_WARNING(logger, "Cross compilation requested, but cross compilation is not supported.");
1241#endif
1242 }
1243#ifdef COGS_ENABLE_GLSLANG
1244 else{
1245#else
1246 {
1247#endif
1248 auto usedDefinitions = isHlsl ? PreprocessorDefinitions() : desc.definitions;
1249 vertexShader = loadShader(GL_VERTEX_SHADER, processedSource.vsSource.c_str(), desc.flags, usedDefinitions);
1250 if(processedSource.gsSource.size())
1251 geometryShader = loadShader(GL_GEOMETRY_SHADER, processedSource.gsSource.c_str(), desc.flags, usedDefinitions);
1252 if(processedSource.psSource.size())
1253 pixelShader = loadShader(GL_FRAGMENT_SHADER, processedSource.psSource.c_str(), desc.flags, usedDefinitions);
1254 }
1255
1256 if (HandleIsValid(vertexShader)) {
1257 auto effectHandle = loadProgram(vertexShader, hullShader, domainShader, geometryShader, pixelShader, desc.flags, hlslAttr);
1258
1259 if (HandleIsValid(effectHandle)) {
1260 auto & effect = effects[effectHandle];
1261 effect.real_sampler = std::move(real_sampler);
1262
1263 if (desc.flags & EffectFlags::Pinned) effects.pin(effectHandle);
1264
1265 if(!isHlsl || true){ // Reflect GLSL (TODO)
1266 GLint attributes;
1267 glGetProgramiv(effect.programId, GL_ACTIVE_ATTRIBUTES, &attributes);
1268 GLint uniforms;
1269 glGetProgramiv(effect.programId, GL_ACTIVE_UNIFORMS, &uniforms);
1270 GLint uniformBlocks;
1271 glGetProgramiv(effect.programId, GL_ACTIVE_UNIFORM_BLOCKS, &uniformBlocks);
1272
1273 for (size_t i = 0; i < (size_t)ShaderType::NumShaderSlots; ++i) {
1274 ShaderReflectionInfo & shader(reflectionInfo[i]);
1275 shader.constantBuffers.resize(uniformBlocks);
1276
1277 for (unsigned int l = 0; l < unsigned(uniformBlocks); ++l) {
1278 GLchar blockName[256];
1279 GLsizei length;
1280 glGetActiveUniformBlockName(effect.programId, l, static_cast<GLsizei>(sizeof(blockName)), &length, blockName);
1281 blockName[255] = '\0';
1282
1283 GLint block_size;
1284 glGetActiveUniformBlockiv(effect.programId, l, GL_UNIFORM_BLOCK_DATA_SIZE, &block_size);
1285 GLint block_uniforms;
1286 glGetActiveUniformBlockiv(effect.programId, l, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &block_uniforms);
1287 GLuint *indices = new GLuint[block_uniforms];
1288 glGetActiveUniformBlockiv(effect.programId, l, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, (GLint*)indices);
1289
1290 auto & constantBuffer = shader.constantBuffers[l];
1291 constantBuffer.slot = l;
1292 constantBuffer.dirty = true;
1293 shader.slots[StringId(blockName)] = l;
1294 constantBuffer.name = blockName;
1295
1296 constantBuffer.offsets.resize(0);
1297 constantBuffer.sizes.resize(0);
1298 constantBuffer.size = block_size;
1299
1300 GLint *uOffset = new GLint[block_uniforms];
1301 GLint *uSize = new GLint[block_uniforms];
1302 GLint *uArrayStride = new GLint[block_uniforms];
1303 glGetActiveUniformsiv(effect.programId, block_uniforms, indices, GL_UNIFORM_OFFSET, uOffset);
1304 glGetActiveUniformsiv(effect.programId, block_uniforms, indices, GL_UNIFORM_SIZE, uSize);
1305
1306 glGetActiveUniformsiv(effect.programId, block_uniforms, indices, GL_UNIFORM_ARRAY_STRIDE, uArrayStride);
1307 for(unsigned int j=0; j<unsigned(block_uniforms); j++){
1308 GLchar uniformName[256];
1309 GLsizei uniformNameLength;
1310 glGetActiveUniformName(effect.programId, indices[j], static_cast<GLsizei>(sizeof(uniformName)), &uniformNameLength, uniformName);
1311 uniformName[255] = '\0';
1312
1313 if(uSize[j] > 1){
1314 strchr(uniformName, '[')[0] = '\0';
1315 GLchar *n = strchr(uniformName, '.');
1316 if(!n) n = uniformName;
1317 else n++;
1318 std::string nn(n);
1319
1320 for (unsigned int k = 0; k<unsigned(uSize[j]); k++) {
1321 std::string indexedUniformName(nn+"["+std::to_string(k)+"]");
1322 constantBuffer.variables[StringId(indexedUniformName)] = static_cast<uint16_t>(constantBuffer.offsets.size());
1323 constantBuffer.offsets.push_back(static_cast<uint64_t>(uOffset[j]) + static_cast<uint64_t>(uArrayStride[j])* k);
1324 constantBuffer.sizes.push_back(static_cast<uint64_t>(uArrayStride[j]));
1325 }
1326 }
1327 else{
1328 GLchar *n = strchr(uniformName, '.');
1329 if(!n) n = uniformName;
1330 else n++;
1331
1332 constantBuffer.variables[StringId(n)] = static_cast<uint16_t>(constantBuffer.offsets.size());
1333 constantBuffer.offsets.push_back(uOffset[j]);
1334 constantBuffer.sizes.push_back(1);
1335 }
1336 }
1337 delete [] uOffset;
1338 delete [] uSize;
1339 delete [] uArrayStride;
1340 delete [] indices;
1341 }
1342 }
1343 }
1344
1345 for (size_t i = 0; i < (size_t)ShaderType::NumShaderSlots; ++i) {
1346 effect.shaders[i].reflection = reflectionInfo[i];
1347 }
1348
1349 for (size_t i = 0; i < (size_t)ShaderType::NumShaderSlots; ++i) {
1350 for (auto & cb : effect.shaders[i].reflection.constantBuffers) {
1351 // Create backing store for all constants.
1352 if (cb.size && !HandleIsValid(cb.buffer)) {
1353 cb.memoryBuffer.resize(cb.size);
1354 cb.buffer = buffers->loadBuffer(nullptr, cb.size, Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
1355 }
1356
1357 if (cb.name == "$Globals") {
1358 // "$Globals" from HLSL is renamed to "Globals" by HLSLcc.
1359 cb.index = glGetUniformBlockIndex(effect.programId, "Globals");
1360 } else {
1361 cb.index = glGetUniformBlockIndex(effect.programId, cb.name.c_str());
1362 }
1363 }
1364 }
1365 }
1366
1367 return effectHandle;
1368 } else {
1369 return EffectHandle::InvalidHandle;
1370 }
1371}
1372
1373Cogs::EffectHandle Cogs::EffectsGL20::loadComputeEffect(const StringView & fileName, const PreprocessorDefinitions & definitions, EffectFlags::EEffectFlags effectFlags)
1374{
1375 if (!glDispatchCompute) {
1376 return EffectHandle::InvalidHandle;
1377 }
1378
1379 ProcessedContent csSourceProcessed;
1380 Utilities::preprocessFile(handler, fileName, csSourceProcessed);
1381
1382 ShaderSource source;
1383 source.shaderSource = csSourceProcessed.content;
1384
1385 std::unordered_map<size_t, std::vector<size_t>> real_sampler;
1386
1387 if (fileName.find(".hlsl") != std::string::npos || fileName.find(".fx") != std::string::npos) {
1388#ifdef COGS_ENABLE_GLSLANG
1389 glslang::InitializeProcess();
1390
1391 struct ShaderInput
1392 {
1393 ShaderType::EShaderType type;
1394 const char * stage;
1395 const std::string & source;
1396 const StringView & entryPoint;
1397 EShLanguage language;
1398 int num;
1399 };
1400
1401 int targetVersion =
1402 capabilities->getDeviceCapabilities().featureLevelMajor * 100 +
1403 capabilities->getDeviceCapabilities().featureLevelMinor * 10;
1404 targetVersion = std::max(targetVersion, 430);
1405
1406 ShaderInput shaderSource = {ShaderType::ComputeShader, "CS", source.shaderSource, "main", EShLangCompute, shader_num++ };
1407
1408 glslang::TProgram program;
1409 std::unique_ptr<glslang::TShader> shaderp;
1410 std::unordered_map<size_t, std::string> variableMap;
1411
1412 {
1413 shaderp = std::make_unique<glslang::TShader>(shaderSource.language);
1414 auto & shader = *shaderp;
1415
1416 std::vector<std::string> defs(definitions.size());
1417 std::vector<const char *> shaderStrings(definitions.size()+1);
1418
1419 shaderStrings[0] = "#pragma pack_matrix(row_major)\n";
1420 for (size_t i = 0; i < definitions.size(); ++i) {
1421 auto & d = definitions[i];
1422 auto str = "#define " + d.first + " " + d.second + "\n";
1423 defs[i] = str;
1424 shaderStrings[i+1] = defs[i].c_str();
1425 }
1426
1427 shaderStrings.emplace_back(shaderSource.source.c_str());
1428
1429#ifdef COGS_DUMP_SHADERS
1430 {
1431 char num[8] = {};
1432 sprintf(num, "%04d", shaderSource.num);
1433 std::string file = IO::getTempPath() + num + ".hlsl";
1434 FILE *fp = fopen(file.c_str(), "wb");
1435 if(fp){
1436 LOG_INFO(logger, "Write HLSL to %s", file.c_str());
1437 for(auto &t : shaderStrings){
1438 fprintf(fp, "%s", t);
1439 }
1440 fclose(fp);
1441 }
1442 }
1443#endif
1444
1445 shader.setStrings(shaderStrings.data(), (int)shaderStrings.size());
1446 shader.setEntryPoint(shaderSource.entryPoint.data());
1447 shader.setSourceEntryPoint(shaderSource.entryPoint.data());
1448 shader.setAutoMapBindings(true);
1449 // shader.setAutoMapLocations(true);
1450 shader.setHlslIoMapping(true);
1451 shader.setEnvInput(glslang::EShSourceHlsl, shaderSource.language, glslang::EShClientOpenGL, 100);
1452 shader.setEnvTarget(glslang::EshTargetSpv, glslang::EShTargetSpv_1_3);
1453 shader.setEnvClient(glslang::EShClientOpenGL, glslang::EShTargetOpenGL_450);
1454 shader.setEnvTargetHlslFunctionality1();
1455
1456 int defaultVersion = 460;
1457 bool forwardCompatible = true;
1458
1459 EShMessages messages = EShMsgDefault;
1460 std::string pOutput;
1461 glslang::TShader::ForbidIncluder includer;
1462 //shader.preprocess(&resources, defaultVersion, ECoreProfile, false, forwardCompatible, messages, &pOutput, includer);
1463 shader.parse(&resources, defaultVersion, ECoreProfile, false, forwardCompatible, messages, includer);
1464
1465 auto infoLog = StringView(shader.getInfoLog());
1466 if(!infoLog.empty()){
1467 LOG_INFO(logger, "glslang info_log: %s", infoLog.data());
1468 }
1469
1470 auto infoDebugLog = StringView(shader.getInfoDebugLog());
1471 if(!infoDebugLog.empty()){
1472 LOG_INFO(logger, "glslang info_debug_log: %s", infoDebugLog.data());
1473 }
1474
1475 program.addShader(&shader);
1476 }
1477
1478 EShMessages messages = EShMsgDefault;
1479 program.link(messages);
1480
1481 auto linkInfo = StringView(program.getInfoLog());
1482 if (!linkInfo.empty()) {
1483 LOG_WARNING(logger, "%s", linkInfo.data());
1484 }
1485
1486 program.mapIO();
1487
1488 auto ioInfo = StringView(program.getInfoLog());
1489 if (!ioInfo.empty()) {
1490 LOG_WARNING(logger, "%s", ioInfo.data());
1491 }
1492
1493 program.buildReflection();
1494
1495 auto reflectionInfoLog = StringView(program.getInfoLog());
1496 if (!reflectionInfoLog.empty()) {
1497 LOG_WARNING(logger, "%s", reflectionInfoLog.data());
1498 }
1499
1500 {
1501 std::vector<unsigned int> spirv;
1502
1503 spv::SpvBuildLogger buildLogger;
1504
1505 glslang::SpvOptions spvOptions;
1506 spvOptions.generateDebugInfo = false;
1507 spvOptions.disableOptimizer = false;
1508 spvOptions.optimizeSize = false;
1509
1510 auto intermediateShader = program.getIntermediate(shaderSource.language);
1511 glslang::GlslangToSpv(*intermediateShader, spirv, &buildLogger, &spvOptions);
1512 if(!spirv.size())
1513 return EffectHandle::InvalidHandle;
1514
1515#ifdef COGS_DUMP_SHADERS
1516 {
1517 char num[8] = {};
1518 sprintf(num, "%04d", shaderSource.num);
1519 std::string file = IO::getTempPath() + num + ".spv";
1520 std::ofstream out(file.c_str(), std::ofstream::out);
1521 if(out){
1522 LOG_INFO(logger, "Write SPV to %s", file.c_str());
1523 spv::Disassemble(out, spirv);
1524 }
1525 }
1526#endif
1527
1528 spirv_cross::CompilerGLSL glsl(std::move(spirv));
1529 glsl.build_dummy_sampler_for_combined_images();
1530 glsl.build_combined_image_samplers();
1531
1532 spirv_cross::ShaderResources shaderResources;
1533 auto active = glsl.get_active_interface_variables();
1534 shaderResources = glsl.get_shader_resources(active);
1535 glsl.set_enabled_interface_variables(move(active));
1536
1537 auto & combinedSamplers = glsl.get_combined_image_samplers();
1538
1539 for (auto & c : combinedSamplers) {
1540 auto & tex = glsl.get_name(c.image_id);
1541 glsl.set_name(c.combined_id, tex);
1542 auto & sampler = glsl.get_name(c.sampler_id);
1543 auto & combined = glsl.get_name(c.combined_id);
1544
1545 LOG_TRACE(logger, " %s Image %s, Sampler: %s: Combined %s", shaderSource.stage, tex.c_str(), sampler.c_str(), combined.c_str());
1546
1547 auto samplerHash = Cogs::hash(sampler);
1548 real_sampler[samplerHash].push_back(Cogs::hash(combined));
1549
1550 variableMap[Cogs::hash(tex)] = sampler;
1551 }
1552
1553 for (auto & input : shaderResources.uniform_buffers) {
1554 auto loc = glsl.get_decoration(input.id, spv::DecorationBinding);
1555
1556 LOG_TRACE(logger, "%s Uniform buffer: %s, %d", shaderSource.stage, input.name.c_str(), loc);
1557
1558 glsl.set_name(input.id, "_" + input.name);
1559
1560 auto activeMembers = glsl.get_active_buffer_ranges(input.id);
1561 auto & baseType = glsl.get_type(input.base_type_id);
1562
1563 for (auto & m : activeMembers) {
1564 auto & member = glsl.get_member_name(input.base_type_id, m.index);
1565 auto & memberTypeId = baseType.member_types[m.index];
1566 auto & memberType = glsl.get_type(memberTypeId);
1567 auto & memberBase = memberType.parent_type ? glsl.get_type(memberType.parent_type) : memberType;
1568
1569 auto size = glsl.get_declared_struct_member_size(baseType, m.index);
1570
1571 LOG_TRACE(logger, " %s, size: %zu", member.c_str(), size);
1572
1573 if (!memberType.array.empty()) {
1574 for (size_t i = 0; i < memberType.array[0]; ++i) {
1575 if (memberBase.basetype == spirv_cross::SPIRType::Struct) {
1576 for (uint32_t j = 0; j < memberBase.member_types.size(); ++j) {
1577 auto & nestedMember = glsl.get_member_name(memberType.parent_type, j);
1578
1579 auto mn = member + "[" + std::to_string(i) + "]." + nestedMember;
1580 auto nn = "_" + input.name + "." + mn;
1581
1582 variableMap[Cogs::hash(mn)] = nn;
1583 }
1584 } else {
1585 auto mn = member + "[" + std::to_string(i) + "]";
1586 auto nn = "_" + input.name + "." + mn;
1587 variableMap[Cogs::hash(mn)] = nn;
1588 }
1589 }
1590 } else {
1591 variableMap[Cogs::hash(member)] = "_" + input.name + "." + member;
1592 }
1593 }
1594 }
1595
1596 for (auto & input : shaderResources.storage_buffers) {
1597 auto loc = glsl.get_decoration(input.id, spv::DecorationBinding);
1598
1599 LOG_TRACE(logger, "%s Storage buffer: %s, %d", shaderSource.stage, input.name.c_str(), loc);
1600
1601 glsl.set_name(input.id, "_" + input.name);
1602
1603 auto activeMembers = glsl.get_active_buffer_ranges(input.id);
1604 auto & baseType = glsl.get_type(input.base_type_id);
1605
1606 for (auto & m : activeMembers) {
1607 auto & member = glsl.get_member_name(input.base_type_id, m.index);
1608 auto & memberTypeId = baseType.member_types[m.index];
1609 auto & memberType = glsl.get_type(memberTypeId);
1610 auto & memberBase = memberType.parent_type ? glsl.get_type(memberType.parent_type) : memberType;
1611
1612 auto size = glsl.get_declared_struct_member_size(baseType, m.index);
1613
1614 LOG_TRACE(logger, " %s, size: %zu", member.c_str(), size);
1615
1616 if (!memberType.array.empty()) {
1617 for (size_t i = 0; i < memberType.array[0]; ++i) {
1618 if (memberBase.basetype == spirv_cross::SPIRType::Struct) {
1619 for (uint32_t j = 0; j < memberBase.member_types.size(); ++j) {
1620 auto & nestedMember = glsl.get_member_name(memberType.parent_type, j);
1621
1622 auto mn = member + "[" + std::to_string(i) + "]." + nestedMember;
1623 auto nn = "_" + input.name + "." + mn;
1624
1625 variableMap[Cogs::hash(mn)] = nn;
1626 }
1627 } else {
1628 auto mn = member + "[" + std::to_string(i) + "]";
1629 auto nn = "_" + input.name + "." + mn;
1630 variableMap[Cogs::hash(mn)] = nn;
1631 }
1632 }
1633 } else {
1634 variableMap[Cogs::hash(member)] = "_" + input.name + "." + member;
1635 }
1636 }
1637 }
1638
1639 for (auto & output : shaderResources.stage_outputs) {
1640 auto location = glsl.get_decoration(output.id, spv::DecorationLocation);
1641 auto hlslSemantic = glsl.get_decoration_string(output.id, spv::DecorationHlslSemanticGOOGLE);
1642 auto[semantic, semanticIndex] = getSemanticWithIndex(hlslSemantic);
1643 auto isBuiltIn = glsl.get_decoration(output.id, spv::DecorationBuiltIn);
1644
1645 if (!isBuiltIn) {
1646 std::string newName;
1647
1648 switch (shaderSource.type) {
1649 case ShaderType::GeometryShader: newName = "gsOutput"; break;
1650 case ShaderType::VertexShader: newName = "vsOutput"; break;
1651 }
1652 glsl.set_name(output.id, newName + std::string(semantic) + std::to_string(semanticIndex));
1653 }
1654
1655 LOG_TRACE(logger, "%s Output: %s, [%s] %d", shaderSource.stage, output.name.c_str(), hlslSemantic.c_str(), location);
1656 }
1657
1658 spirv_cross::CompilerGLSL::Options options;
1659 options.version = targetVersion;
1660 options.es = false;
1661 glsl.set_common_options(options);
1662
1663 auto glslSource = glsl.compile();
1664 source.shaderSource = glslSource;
1665
1666#ifdef COGS_DUMP_SHADERS
1667 {
1668 char num[8] = {};
1669 sprintf(num, "%04d", shaderSource.num);
1670 std::string file = IO::getTempPath() + num + ".glsl";
1671 FILE *fp = fopen(file.c_str(), "wb");
1672 if(fp){
1673 LOG_INFO(logger, "Write GLSL to %s", file.c_str());
1674 fprintf(fp, "%s", glslSource.c_str());
1675 fclose(fp);
1676 }
1677 }
1678#endif
1679
1680 //computeShader = loadShader(GL_COMPUTE_SHADER, glslSource.c_str(), {});
1681 }
1682
1683 glslang::FinalizeProcess();
1684#else
1685 LOG_WARNING(logger, "HLSL shader detected but cross compilation of shaders disabled.");
1686#endif
1687 }
1688
1689 EffectGL20 effect;
1690 effect.real_sampler = std::move(real_sampler);
1691 effect.computeShader.shaderHandle = loadShader(GL_COMPUTE_SHADER, source.shaderSource.c_str(), effectFlags);
1692
1693 const GLuint programId = glCreateProgram();
1694
1695 if (programId == GL_INVALID_INDEX) {
1696 return EffectHandle::InvalidHandle;
1697 }
1698
1699 glAttachShader(programId, this->shaderIds[effect.computeShader.shaderHandle]);
1700 checkGLError("glAttachShader");
1701
1702 glLinkProgram(programId);
1703
1704 GLint linkStatus = GL_FALSE;
1705 glGetProgramiv(programId, GL_LINK_STATUS, &linkStatus);
1706
1707 if (linkStatus != GL_TRUE) {
1708 printProgramError(programId, effectFlags);
1709
1710 glDeleteProgram(programId);
1711
1712 return EffectHandle::InvalidHandle;
1713 } else {
1714 printProgramError(programId, effectFlags, false);
1715 }
1716
1717 effect.programId = programId;
1718
1719 {
1720 if(true){ // Reflect GLSL (TODO)
1721 GLint attributes;
1722 glGetProgramiv(effect.programId, GL_ACTIVE_ATTRIBUTES, &attributes);
1723 GLint uniforms2;
1724 glGetProgramiv(effect.programId, GL_ACTIVE_UNIFORMS, &uniforms2);
1725 GLint uniformBlocks;
1726 glGetProgramiv(effect.programId, GL_ACTIVE_UNIFORM_BLOCKS, &uniformBlocks);
1727
1728 {
1729 ShaderReflectionInfo shader = {};
1730 shader.constantBuffers.resize(uniformBlocks);
1731
1732 for (GLint i = 0; i < uniformBlocks; ++i) {
1733 GLchar name2[256];
1734 GLsizei length2;
1735 glGetActiveUniformBlockName(effect.programId, i, static_cast<GLsizei>(sizeof(name2)), &length2, name2);
1736 name2[255] = '\0';
1737
1738 GLint size;
1739 glGetActiveUniformBlockiv(effect.programId, i, GL_UNIFORM_BLOCK_DATA_SIZE, &size);
1740 GLint uniforms;
1741 glGetActiveUniformBlockiv(effect.programId, i, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &uniforms);
1742 GLuint *indices = new GLuint[uniforms];
1743 glGetActiveUniformBlockiv(effect.programId, i, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, (GLint*)indices);
1744
1745 auto & constantBuffer = shader.constantBuffers[i];
1746 constantBuffer.slot = i;
1747 constantBuffer.dirty = true;
1748 shader.slots[StringId(name2)] = i;
1749 constantBuffer.name = name2;
1750
1751 constantBuffer.offsets.resize(0);
1752 constantBuffer.sizes.resize(0);
1753 constantBuffer.size = size;
1754
1755 GLint *uOffset = new GLint[uniforms];
1756 GLint *uSize = new GLint[uniforms];
1757 GLint *uArrayStride = new GLint[uniforms];
1758 glGetActiveUniformsiv(effect.programId, uniforms, indices, GL_UNIFORM_OFFSET, uOffset);
1759 glGetActiveUniformsiv(effect.programId, uniforms, indices, GL_UNIFORM_SIZE, uSize);
1760
1761 glGetActiveUniformsiv(effect.programId, uniforms, indices, GL_UNIFORM_ARRAY_STRIDE, uArrayStride);
1762 for(GLint j=0; j<uniforms; j++){
1763 GLchar name3[256];
1764 GLsizei length;
1765 glGetActiveUniformName(effect.programId, indices[j], static_cast<GLsizei>(sizeof(name3)), &length, name3);
1766 name3[255] = '\0';
1767
1768 if(uSize[j] > 1){
1769 strchr(name3, '[')[0] = '\0';
1770 GLchar *n = strchr(name3, '.');
1771 if(!n) n = name3;
1772 else n++;
1773 std::string nn(n);
1774
1775 for(GLint k=0; k<uSize[j]; k++){
1776 std::string name(nn+"["+std::to_string(k)+"]");
1777 constantBuffer.variables[StringId(name)] = static_cast<uint16_t>(constantBuffer.offsets.size());
1778 constantBuffer.offsets.push_back(static_cast<uint64_t>(uOffset[j]) + static_cast<uint64_t>(uArrayStride[j])*k);
1779 constantBuffer.sizes.push_back(uArrayStride[j]);
1780 }
1781 }
1782 else{
1783 GLchar *n = strchr(name3, '.');
1784 if(!n) n = name3;
1785 else n++;
1786
1787 constantBuffer.variables[StringId(n)] = static_cast<uint16_t>(constantBuffer.offsets.size());
1788 constantBuffer.offsets.push_back(static_cast<uint64_t>(uOffset[j]));
1789 constantBuffer.sizes.push_back(1);
1790 }
1791 }
1792 delete [] uOffset;
1793 delete [] uSize;
1794 delete [] uArrayStride;
1795 delete [] indices;
1796 }
1797 effect.shaders[ShaderType::ComputeShader].reflection = shader;
1798 }
1799 }
1800
1801 {
1802 size_t i = ShaderType::ComputeShader;
1803 for (auto & cb : effect.shaders[i].reflection.constantBuffers) {
1804 // Create backing store for all constants.
1805 if (cb.size && !HandleIsValid(cb.buffer)) {
1806 cb.memoryBuffer.resize(cb.size);
1807 cb.buffer = buffers->loadBuffer(nullptr, cb.size, Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
1808 }
1809
1810 if (cb.name == "$Globals") {
1811 // "$Globals" from HLSL is renamed to "Globals" by HLSLcc.
1812 cb.index = glGetUniformBlockIndex(effect.programId, "Globals");
1813 } else {
1814 cb.index = glGetUniformBlockIndex(effect.programId, cb.name.c_str());
1815 }
1816 }
1817 }
1818 }
1819
1820 return this->effects.addResource(std::move(effect));
1821}
1822
1823Cogs::TextureBindingHandle Cogs::EffectsGL20::getTextureBinding(EffectHandle effectHandle, const StringView & name, const unsigned int)
1824{
1825 if (!HandleIsValid(effectHandle)) {
1826 LOG_ERROR(logger, "Tried to fetch texture variable from invalid/empty effect handle.");
1827 return TextureBindingHandle::InvalidHandle;
1828 }
1829 auto & effect = effects[effectHandle];
1830 auto hash = Cogs::hash(name);
1831 auto it = effect.textures.find(hash);
1832 if (it != effect.textures.end()) {
1833 auto unit = it->second;
1834 return TextureBindingHandle(unit | (1 << 16)); // make sure that it is non-zero
1835 }
1836 return TextureBindingHandle::InvalidHandle;
1837}
1838
1839Cogs::SamplerStateBindingHandle Cogs::EffectsGL20::getSamplerStateBinding(EffectHandle effectHandle, const StringView & name, const unsigned int)
1840{
1841 if (!HandleIsValid(effectHandle)) {
1842 LOG_WARNING(logger, "Tried to fetch sampler variable from invalid/empty effect handle.");
1843 return SamplerStateBindingHandle::InvalidHandle;
1844 }
1845 auto & effect = effects[effectHandle];
1846 auto hash = Cogs::hash(name);
1847 auto it = effect.samplers.find(hash);
1848 auto it2 = effect.real_sampler.find(hash);
1849 if (it != effect.samplers.end() || it2 != effect.real_sampler.end()) {
1850 if(!effect.sampler_map.count(hash)){
1851 auto tmp = new SamplerMapGL20;
1852 tmp->effectHandle = effectHandle;
1853 tmp->name = hash;
1854 effect.sampler_map[hash] = tmp;
1855 }
1856 return SamplerStateBindingHandle((size_t)(SamplerMapGL20*)effect.sampler_map[hash]);
1857 }
1858 return SamplerStateBindingHandle::InvalidHandle;
1859}
1860
1861void Cogs::EffectsGL20::annotate(EffectHandle handle, const StringView & name)
1862{
1863#ifndef __APPLE__
1864 if(name.empty()) return;
1865 auto & effect = this->effects[handle];
1866 glObjectLabel(GL_PROGRAM, effect.programId, static_cast<GLsizei>(name.size()), name.data());
1867#else
1868 (void)handle;
1869 (void)name;
1870#endif
1871}
1872void Cogs::EffectsGL20::annotateVS(EffectHandle handle, const StringView & name)
1873{
1874#ifndef __APPLE__
1875 if(name.empty()) return;
1876 auto & effect = this->effects[handle];
1877 auto & shaderHandle = effect.shaders[ShaderType::VertexShader].shaderHandle;
1878 if(shaderHandle != ShaderHandle::InvalidHandle){
1879 auto & shader = this->shaderIds[shaderHandle];
1880 glObjectLabel(GL_SHADER, shader, static_cast<GLsizei>(name.size()), name.data());
1881 }
1882#else
1883 (void)handle;
1884 (void)name;
1885#endif
1886}
1887void Cogs::EffectsGL20::annotateGS(EffectHandle handle, const StringView & name)
1888{
1889#ifndef __APPLE__
1890 if(name.empty()) return;
1891 auto & effect = this->effects[handle];
1892 auto & shaderHandle = effect.shaders[ShaderType::GeometryShader].shaderHandle;
1893 if(shaderHandle != ShaderHandle::InvalidHandle){
1894 auto & shader = this->shaderIds[shaderHandle];
1895 glObjectLabel(GL_SHADER, shader, static_cast<GLsizei>(name.size()), name.data());
1896 }
1897#else
1898 (void)handle;
1899 (void)name;
1900#endif
1901}
1902void Cogs::EffectsGL20::annotatePS(EffectHandle handle, const StringView & name)
1903{
1904#ifndef __APPLE__
1905 if(name.empty()) return;
1906 auto & effect = this->effects[handle];
1907 auto & shaderHandle = effect.shaders[ShaderType::PixelShader].shaderHandle;
1908 if(shaderHandle != ShaderHandle::InvalidHandle){
1909 auto & shader = this->shaderIds[shaderHandle];
1910 glObjectLabel(GL_SHADER, shader, static_cast<GLsizei>(name.size()), name.data());
1911 }
1912#else
1913 (void)handle;
1914 (void)name;
1915#endif
1916}
1917void Cogs::EffectsGL20::annotateCS(EffectHandle handle, const StringView & name)
1918{
1919#ifndef __APPLE__
1920 if(name.empty()) return;
1921 auto & effect = this->effects[handle];
1922 auto & shaderHandle = effect.shaders[ShaderType::ComputeShader].shaderHandle;
1923 if(shaderHandle != ShaderHandle::InvalidHandle){
1924 auto & shader = this->shaderIds[shaderHandle];
1925 glObjectLabel(GL_SHADER, shader, static_cast<GLsizei>(name.size()), name.data());
1926 }
1927#else
1928 (void)handle;
1929 (void)name;
1930#endif
1931}
Cogs::Logging::Log
Log implementation class.
Definition: LogManager.h:139
Cogs::StringView
Provides a weakly referenced view over the contents of a string.
Definition: StringView.h:24
Cogs::StringView::data
constexpr const char * data() const noexcept
Get the sequence of characters referenced by the string view.
Definition: StringView.h:171
Cogs::StringView::size
constexpr size_t size() const noexcept
Get the size of the string.
Definition: StringView.h:178
Cogs::StringView::empty
constexpr bool empty() const noexcept
Check if the string is empty.
Definition: StringView.h:122
Cogs::StringView::substr
constexpr StringView substr(size_t offset, size_t count=NoPosition) const noexcept
Get the given sub string.
Definition: StringView.h:258
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::Logging::getLogger
constexpr Log getLogger(const char(&name)[LEN]) noexcept
Definition: LogManager.h:180
Cogs
Contains all Cogs related functionality.
Definition: FieldSetter.h:23
Cogs::hash
constexpr size_t hash() noexcept
Simple getter function that returns the initial value for fnv1a hashing.
Definition: HashFunctions.h:62
Cogs::PreprocessorDefinitions
std::vector< PreprocessorDefinition > PreprocessorDefinitions
A set of preprocessor definitions.
Definition: IEffects.h:13
Cogs::AccessMode::Write
@ Write
The buffer can be mapped and written to by the CPU after creation.
Definition: Flags.h:50
Cogs::BindFlags::ConstantBuffer
@ ConstantBuffer
The buffer can be bound as input to effects as a constant buffer.
Definition: Flags.h:72
Cogs::CapabilitiesGL20::getDeviceCapabilities
const GraphicsDeviceCapabilities & getDeviceCapabilities() const
Gets the device capabilities in a structure.
Definition: CapabilitiesGL20.h:31
Cogs::ContextGL20::setEffect
void setEffect(EffectHandle effectHandle) override
Set the current effect.
Definition: ContextGL20.cpp:644
Cogs::EffectDescription
Contains an effect description used to load a single effect.
Definition: IEffects.h:55
Cogs::EffectFlags::EEffectFlags
EEffectFlags
Effect source flags.
Definition: IEffects.h:20
Cogs::EffectFlags::LogShaderSource
@ LogShaderSource
Log the contents of the shader on error.
Definition: IEffects.h:34
Cogs::EffectFlags::GLSL
@ GLSL
Effect source is GLSL.
Definition: IEffects.h:26
Cogs::EffectFlags::Pinned
@ Pinned
Effect can only be released explicitly, not using releaseResources().
Definition: IEffects.h:30
Cogs::EffectsGL20::getSamplerStateBinding
SamplerStateBindingHandle getSamplerStateBinding(EffectHandle effectHandle, const StringView &name, const unsigned int slot) override
Get a handle to a sampler state object binding, mapping how to bind the sampler state to the given ef...
Definition: EffectsGL20.cpp:1839
Cogs::EffectsGL20::getBufferBinding
BufferBindingHandle getBufferBinding(EffectHandle effectHandle, const StringView &name) override
Get a handle to a buffer binding.
Definition: EffectsGL20.cpp:807
Cogs::EffectsGL20::getConstantBufferBinding
ConstantBufferBindingHandle getConstantBufferBinding(EffectHandle effectHandle, const StringView &name) override
Get a handle to a constant buffer binding, mapping how to bind a constant buffer to the given effect.
Definition: EffectsGL20.cpp:790
Cogs::EffectsGL20::annotate
void annotate(EffectHandle handle, const StringView &name) override
Associate a name with an object for use in graphics debugging.
Definition: EffectsGL20.cpp:1861
Cogs::EffectsGL20::getTextureBinding
TextureBindingHandle getTextureBinding(EffectHandle effectHandle, const StringView &name, const unsigned int slot) override
Get a handle to a texture object binding, mapping how to bind textures to the given effect.
Definition: EffectsGL20.cpp:1823
Cogs::EffectsGL20::annotateGS
void annotateGS(EffectHandle handle, const StringView &name) override
Associate a name with an object for use in graphics debugging.
Definition: EffectsGL20.cpp:1887
Cogs::EffectsGL20::annotateVS
void annotateVS(EffectHandle handle, const StringView &name) override
Associate a name with an object for use in graphics debugging.
Definition: EffectsGL20.cpp:1872
Cogs::EffectsGL20::annotatePS
void annotatePS(EffectHandle handle, const StringView &name) override
Associate a name with an object for use in graphics debugging.
Definition: EffectsGL20.cpp:1902
Cogs::EffectsGL20::releaseResources
void releaseResources() override
Release all allocated effect resources.
Definition: EffectsGL20.cpp:859
Cogs::EffectsGL20::annotateCS
void annotateCS(EffectHandle handle, const StringView &name) override
Associate a name with an object for use in graphics debugging.
Definition: EffectsGL20.cpp:1917
Cogs::EffectsGL20::releaseEffect
void releaseEffect(EffectHandle handle) override
Release the effect with the given handle, freeing all resources generated during program loading.
Definition: EffectsGL20.cpp:754
Cogs::EffectsGL20::releaseBufferBinding
void releaseBufferBinding(BufferBindingHandle bufferBindingHandle) override
Release a handle to a buffer binding.
Definition: EffectsGL20.cpp:853
Cogs::EffectsGL20::loadComputeEffect
EffectHandle loadComputeEffect(const StringView &fileName, EffectFlags::EEffectFlags effectFlags) override
Load the compute shader with the given file name and create an effect.
Definition: EffectsGL20.cpp:876
Cogs::GraphicsDeviceSettings
Settings for graphics device initialization.
Definition: IGraphicsDevice.h:89
Cogs::GraphicsDeviceSettings::featureLevelMajor
int featureLevelMajor
Major feature level.
Definition: IGraphicsDevice.h:100
Cogs::GraphicsDeviceSettings::featureLevelMinor
int featureLevelMinor
Minor feature level.
Definition: IGraphicsDevice.h:111
Cogs::Handle_t< ShaderTag >
Cogs::Handle_t< ShaderTag >::NoHandle
static const Handle_t NoHandle
Represents a handle to nothing.
Definition: Common.h:77
Cogs::Handle_t< ShaderTag >::InvalidHandle
static const Handle_t InvalidHandle
Represents an invalid handle.
Definition: Common.h:80
Cogs::IBuffers
Provides buffer management functionality.
Definition: IBuffers.h:13
Cogs::IBuffers::loadBuffer
virtual BufferHandle loadBuffer(const void *data, const size_t size, Usage::EUsage usage, uint32_t accessMode, uint32_t bindFlags, uint32_t stride=0)=0
Loads a new buffer using the given data to populate the buffer.
Cogs::Usage::Dynamic
@ Dynamic
Buffer will be loaded and modified with some frequency.
Definition: Flags.h:30
Generated by doxygen 1.9.6