Files
LNXRNT/Kinc/Backends/Graphics4/OpenGL/Sources/kinc/backend/graphics4/compute.c.h
2026-06-09 12:45:01 -07:00

203 lines
6.1 KiB
C

#include <kinc/graphics4/compute.h>
#include <kinc/graphics4/graphics.h>
#include <kinc/graphics4/rendertarget.h>
#include <kinc/graphics4/texture.h>
#include <kinc/image.h>
#include <kinc/log.h>
#include <kinc/math/core.h>
#include <kinc/backend/graphics4/ogl.h>
#include <stdio.h>
#include <string.h>
#if defined(KINC_WINDOWS) || (defined(KINC_LINUX) && defined(GL_VERSION_4_3)) || (defined(KINC_ANDROID) && defined(GL_ES_VERSION_3_1))
#define HAS_COMPUTE
bool kinc_internal_gl_has_compute = true;
#else
bool kinc_internal_gl_has_compute = false;
#endif
#ifdef HAS_COMPUTE
static int convertInternalImageFormat(kinc_image_format_t format) {
switch (format) {
case KINC_IMAGE_FORMAT_RGBA128:
return GL_RGBA32F;
case KINC_IMAGE_FORMAT_RGBA64:
return GL_RGBA16F;
case KINC_IMAGE_FORMAT_RGBA32:
default:
return GL_RGBA8;
case KINC_IMAGE_FORMAT_A32:
return GL_R32F;
case KINC_IMAGE_FORMAT_A16:
return GL_R16F;
case KINC_IMAGE_FORMAT_GREY8:
return GL_R8;
}
}
static int convertInternalRTFormat(kinc_g4_render_target_format_t format) {
switch (format) {
case KINC_G4_RENDER_TARGET_FORMAT_64BIT_FLOAT:
return GL_RGBA16F;
case KINC_G4_RENDER_TARGET_FORMAT_32BIT_RED_FLOAT:
return GL_R32F;
case KINC_G4_RENDER_TARGET_FORMAT_128BIT_FLOAT:
return GL_RGBA32F;
case KINC_G4_RENDER_TARGET_FORMAT_16BIT_DEPTH:
return GL_DEPTH_COMPONENT16;
case KINC_G4_RENDER_TARGET_FORMAT_8BIT_RED:
return GL_RED;
case KINC_G4_RENDER_TARGET_FORMAT_16BIT_RED_FLOAT:
return GL_R16F;
case KINC_G4_RENDER_TARGET_FORMAT_32BIT:
default:
return GL_RGBA;
}
}
#endif
void kinc_g4_compute_shader_init(kinc_g4_compute_shader *shader, void *source, int length) {
shader->impl._length = length;
shader->impl.textureCount = 0;
shader->impl._source = (char *)malloc(sizeof(char) * (length + 1));
for (int i = 0; i < length; ++i) {
shader->impl._source[i] = ((char *)source)[i];
}
shader->impl._source[length] = 0;
#ifdef HAS_COMPUTE
shader->impl._id = glCreateShader(GL_COMPUTE_SHADER);
glCheckErrors();
glShaderSource(shader->impl._id, 1, (const GLchar **)&shader->impl._source, NULL);
glCompileShader(shader->impl._id);
int result;
glGetShaderiv(shader->impl._id, GL_COMPILE_STATUS, &result);
if (result != GL_TRUE) {
int length;
glGetShaderiv(shader->impl._id, GL_INFO_LOG_LENGTH, &length);
char *errormessage = (char *)malloc(sizeof(char) * length);
glGetShaderInfoLog(shader->impl._id, length, NULL, errormessage);
kinc_log(KINC_LOG_LEVEL_ERROR, "GLSL compiler error: %s\n", errormessage);
free(errormessage);
}
shader->impl._programid = glCreateProgram();
glAttachShader(shader->impl._programid, shader->impl._id);
glLinkProgram(shader->impl._programid);
glGetProgramiv(shader->impl._programid, GL_LINK_STATUS, &result);
if (result != GL_TRUE) {
int length;
glGetProgramiv(shader->impl._programid, GL_INFO_LOG_LENGTH, &length);
char *errormessage = (char *)malloc(sizeof(char) * length);
glGetProgramInfoLog(shader->impl._programid, length, NULL, errormessage);
kinc_log(KINC_LOG_LEVEL_ERROR, "GLSL linker error: %s\n", errormessage);
free(errormessage);
}
#endif
// TODO: Get rid of allocations
shader->impl.textures = (char **)malloc(sizeof(char *) * 16);
for (int i = 0; i < 16; ++i) {
shader->impl.textures[i] = (char *)malloc(sizeof(char) * 128);
shader->impl.textures[i][0] = 0;
}
shader->impl.textureValues = (int *)malloc(sizeof(int) * 16);
}
void kinc_g4_compute_shader_destroy(kinc_g4_compute_shader *shader) {
free(shader->impl._source);
shader->impl._source = NULL;
#ifdef HAS_COMPUTE
glDeleteProgram(shader->impl._programid);
glDeleteShader(shader->impl._id);
#endif
}
kinc_g4_constant_location_t kinc_g4_compute_shader_get_constant_location(kinc_g4_compute_shader *shader, const char *name) {
kinc_g4_constant_location_t location;
#ifdef HAS_COMPUTE
location.impl.location = glGetUniformLocation(shader->impl._programid, name);
location.impl.type = GL_FLOAT;
GLint count = 0;
glGetProgramiv(shader->impl._programid, GL_ACTIVE_UNIFORMS, &count);
char arrayName[1024];
strcpy(arrayName, name);
strcat(arrayName, "[0]");
for (GLint i = 0; i < count; ++i) {
GLenum type;
char uniformName[1024];
GLsizei length;
GLint size;
glGetActiveUniform(shader->impl._programid, i, 1024 - 1, &length, &size, &type, uniformName);
if (strcmp(uniformName, name) == 0 || strcmp(uniformName, arrayName) == 0) {
location.impl.type = type;
break;
}
}
glCheckErrors();
if (location.impl.location < 0) {
kinc_log(KINC_LOG_LEVEL_WARNING, "Uniform %s not found.", name);
}
#endif
return location;
}
static int compute_findTexture(kinc_g4_compute_shader *shader, const char *name) {
for (int index = 0; index < shader->impl.textureCount; ++index) {
if (strcmp(shader->impl.textures[index], name) == 0)
return index;
}
return -1;
}
kinc_g4_texture_unit_t kinc_g4_compute_shader_get_texture_unit(kinc_g4_compute_shader *shader, const char *name) {
int index = compute_findTexture(shader, name);
if (index < 0) {
int location = glGetUniformLocation(shader->impl._programid, name);
glCheckErrors();
index = shader->impl.textureCount;
shader->impl.textureValues[index] = location;
strcpy(shader->impl.textures[index], name);
++shader->impl.textureCount;
}
kinc_g4_texture_unit_t unit;
for (int i = 0; i < KINC_G4_SHADER_TYPE_COUNT; ++i) {
unit.stages[i] = -1;
}
unit.stages[KINC_G4_SHADER_TYPE_COMPUTE] = index;
return unit;
}
void kinc_g4_set_shader_storage_buffer(kinc_shader_storage_buffer_t *buffer, int index) {
#ifdef HAS_COMPUTE
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, buffer->impl.bufferId);
glCheckErrors();
#endif
}
void kinc_g4_set_compute_shader(kinc_g4_compute_shader *shader) {
#ifdef HAS_COMPUTE
glUseProgram(shader->impl._programid);
glCheckErrors();
for (int index = 0; index < shader->impl.textureCount; ++index) {
glUniform1i(shader->impl.textureValues[index], index);
glCheckErrors();
}
#endif
}
void kinc_g4_compute(int x, int y, int z) {
#ifdef HAS_COMPUTE
glDispatchCompute(x, y, z);
glCheckErrors();
glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
glCheckErrors();
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
glCheckErrors();
#endif
}