266 lines
9.0 KiB
C++
266 lines
9.0 KiB
C++
#include "canvas.h"
|
|
|
|
static void _canvas_framebuffer_set(Canvas* self, const ivec2& size)
|
|
{
|
|
self->size = size;
|
|
self->previousSize = size;
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, self->fbo);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, self->framebuffer);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self->size.x, self->size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->framebuffer, 0);
|
|
|
|
glBindRenderbuffer(GL_RENDERBUFFER, self->rbo);
|
|
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, self->size.x, self->size.y);
|
|
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, self->rbo);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
}
|
|
|
|
void canvas_init(Canvas* self, const ivec2& size)
|
|
{
|
|
// Axis
|
|
glGenVertexArrays(1, &self->axisVAO);
|
|
glGenBuffers(1, &self->axisVBO);
|
|
|
|
glBindVertexArray(self->axisVAO);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->axisVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(CANVAS_AXIS_VERTICES), CANVAS_AXIS_VERTICES, GL_STATIC_DRAW);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(f32), (void*)0);
|
|
|
|
// Grid
|
|
glGenVertexArrays(1, &self->gridVAO);
|
|
glGenBuffers(1, &self->gridVBO);
|
|
|
|
glBindVertexArray(self->gridVAO);
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->gridVBO);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(f32), (void*)0);
|
|
|
|
// Rect
|
|
glGenVertexArrays(1, &self->rectVAO);
|
|
glGenBuffers(1, &self->rectVBO);
|
|
|
|
glBindVertexArray(self->rectVAO);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->rectVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(CANVAS_RECT_VERTICES), CANVAS_RECT_VERTICES, GL_STATIC_DRAW);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(f32), (void*)0);
|
|
|
|
// Grid
|
|
glGenVertexArrays(1, &self->gridVAO);
|
|
glBindVertexArray(self->gridVAO);
|
|
|
|
glGenBuffers(1, &self->gridVBO);
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->gridVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(CANVAS_GRID_VERTICES), CANVAS_GRID_VERTICES, GL_STATIC_DRAW);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, (void*)0);
|
|
|
|
glBindVertexArray(0);
|
|
|
|
// Texture
|
|
glGenVertexArrays(1, &self->textureVAO);
|
|
glGenBuffers(1, &self->textureVBO);
|
|
glGenBuffers(1, &self->textureEBO);
|
|
|
|
glBindVertexArray(self->textureVAO);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->textureVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(f32) * 4 * 4, nullptr, GL_DYNAMIC_DRAW);
|
|
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self->textureEBO);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GL_TEXTURE_INDICES), GL_TEXTURE_INDICES, GL_DYNAMIC_DRAW);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(f32), (void*)0);
|
|
|
|
glEnableVertexAttribArray(1);
|
|
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(f32), (void*)(2 * sizeof(f32)));
|
|
|
|
glBindVertexArray(0);
|
|
|
|
// Framebuffer
|
|
glGenTextures(1, &self->framebuffer);
|
|
glGenFramebuffers(1, &self->fbo);
|
|
glGenRenderbuffers(1, &self->rbo);
|
|
_canvas_framebuffer_set(self, size);
|
|
}
|
|
|
|
mat4 canvas_transform_get(Canvas* self, vec2 pan, f32 zoom, OriginType origin)
|
|
{
|
|
f32 zoomFactor = PERCENT_TO_UNIT(zoom);
|
|
mat4 projection = glm::ortho(0.0f, (f32)self->size.x, 0.0f, (f32)self->size.y, -1.0f, 1.0f);
|
|
mat4 view = mat4{1.0f};
|
|
vec2 size = vec2(self->size.x, self->size.y);
|
|
|
|
switch (origin)
|
|
{
|
|
case ORIGIN_TOP_LEFT:
|
|
view = glm::translate(view, vec3(pan, 0.0f));
|
|
break;
|
|
default:
|
|
view = glm::translate(view, vec3((size * 0.5f) + pan, 0.0f));
|
|
break;
|
|
}
|
|
|
|
view = glm::scale(view, vec3(zoomFactor, zoomFactor, 1.0f));
|
|
|
|
return projection * view;
|
|
}
|
|
|
|
void canvas_clear(vec4& color)
|
|
{
|
|
glClearColor(color.r, color.g, color.b, color.a);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
}
|
|
|
|
void canvas_viewport_set(Canvas* self)
|
|
{
|
|
glViewport(0, 0, (s32)self->size.x, (s32)self->size.y);
|
|
}
|
|
|
|
void canvas_framebuffer_resize_check(Canvas* self)
|
|
{
|
|
if (self->previousSize != self->size)
|
|
_canvas_framebuffer_set(self, self->size);
|
|
}
|
|
|
|
void canvas_grid_draw(Canvas* self, GLuint& shader, mat4& transform, ivec2& size, ivec2& offset, vec4& color)
|
|
{
|
|
mat4 inverseTransform = glm::inverse(transform);
|
|
|
|
glUseProgram(shader);
|
|
|
|
glUniformMatrix4fv(glGetUniformLocation(shader, SHADER_UNIFORM_MODEL), 1, GL_FALSE, glm::value_ptr(inverseTransform));
|
|
glUniform2f(glGetUniformLocation(shader, SHADER_UNIFORM_SIZE), size.x, size.y);
|
|
glUniform2f(glGetUniformLocation(shader, SHADER_UNIFORM_OFFSET), offset.x, offset.y);
|
|
glUniform4f(glGetUniformLocation(shader, SHADER_UNIFORM_COLOR), color.r, color.g, color.b, color.a);
|
|
|
|
glBindVertexArray(self->gridVAO);
|
|
glDrawArrays(GL_TRIANGLES, 0, 3);
|
|
glBindVertexArray(0);
|
|
|
|
glUseProgram(0);
|
|
}
|
|
|
|
void canvas_texture_draw(Canvas* self, GLuint& shader, GLuint& texture, mat4& transform, const f32* vertices, vec4 tint, vec3 colorOffset)
|
|
{
|
|
glUseProgram(shader);
|
|
|
|
glBindVertexArray(self->textureVAO);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->textureVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(CANVAS_TEXTURE_VERTICES), vertices, GL_DYNAMIC_DRAW);
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, texture);
|
|
|
|
glUniform1i(glGetUniformLocation(shader, SHADER_UNIFORM_TEXTURE), 0);
|
|
glUniform3fv(glGetUniformLocation(shader, SHADER_UNIFORM_COLOR_OFFSET), 1, value_ptr(colorOffset));
|
|
glUniform4fv(glGetUniformLocation(shader, SHADER_UNIFORM_TINT), 1, value_ptr(tint));
|
|
glUniformMatrix4fv(glGetUniformLocation(shader, SHADER_UNIFORM_TRANSFORM), 1, GL_FALSE, value_ptr(transform));
|
|
|
|
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
|
|
|
|
glBindVertexArray(0);
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
glUseProgram(0);
|
|
}
|
|
|
|
void canvas_rect_draw(Canvas* self, const GLuint& shader, const mat4& transform, const vec4& color)
|
|
{
|
|
glUseProgram(shader);
|
|
|
|
glBindVertexArray(self->rectVAO);
|
|
|
|
glUniformMatrix4fv(glGetUniformLocation(shader, SHADER_UNIFORM_TRANSFORM), 1, GL_FALSE, value_ptr(transform));
|
|
glUniform4fv(glGetUniformLocation(shader, SHADER_UNIFORM_COLOR), 1, value_ptr(color));
|
|
|
|
glDrawArrays(GL_LINE_LOOP, 0, 4);
|
|
|
|
glBindVertexArray(0);
|
|
glUseProgram(0);
|
|
}
|
|
|
|
void canvas_axes_draw(Canvas* self, GLuint& shader, mat4& transform, vec4& color)
|
|
{
|
|
glUseProgram(shader);
|
|
glBindVertexArray(self->axisVAO);
|
|
glUniformMatrix4fv(glGetUniformLocation(shader, SHADER_UNIFORM_TRANSFORM), 1, GL_FALSE, value_ptr(transform));
|
|
glUniform4f(glGetUniformLocation(shader, SHADER_UNIFORM_COLOR), color.r, color.g, color.b, color.a);
|
|
glDrawArrays(GL_LINES, 0, 4);
|
|
glBindVertexArray(0);
|
|
glUseProgram(0);
|
|
}
|
|
|
|
void canvas_bind(Canvas* self)
|
|
{
|
|
glBindFramebuffer(GL_FRAMEBUFFER, self->fbo);
|
|
}
|
|
|
|
void canvas_unbind(void)
|
|
{
|
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
}
|
|
|
|
void canvas_free(Canvas* self)
|
|
{
|
|
glDeleteFramebuffers(1, &self->fbo);
|
|
glDeleteRenderbuffers(1, &self->rbo);
|
|
glDeleteTextures(1, &self->framebuffer);
|
|
glDeleteVertexArrays(1, &self->axisVAO);
|
|
glDeleteVertexArrays(1, &self->rectVAO);
|
|
glDeleteVertexArrays(1, &self->gridVAO);
|
|
glDeleteVertexArrays(1, &self->textureVAO);
|
|
glDeleteBuffers(1, &self->axisVBO);
|
|
glDeleteBuffers(1, &self->rectVBO);
|
|
glDeleteBuffers(1, &self->gridVBO);
|
|
glDeleteBuffers(1, &self->textureVBO);
|
|
glDeleteBuffers(1, &self->textureEBO);
|
|
}
|
|
|
|
mat4 canvas_model_get(vec2 size, vec2 position, vec2 pivot, vec2 scale, f32 rotation)
|
|
{
|
|
vec2 scaleAbsolute = glm::abs(scale);
|
|
vec2 scaleSign = glm::sign(scale);
|
|
vec2 pivotScaled = pivot * scaleAbsolute;
|
|
vec2 sizeScaled = size * scaleAbsolute;
|
|
|
|
mat4 model(1.0f);
|
|
model = glm::translate(model, vec3(position - pivotScaled, 0.0f));
|
|
model = glm::translate(model, vec3(pivotScaled, 0.0f));
|
|
model = glm::scale(model, vec3(scaleSign, 1.0f));
|
|
model = glm::rotate(model, glm::radians(rotation), vec3(0, 0, 1));
|
|
model = glm::translate(model, vec3(-pivotScaled, 0.0f));
|
|
model = glm::scale(model, vec3(sizeScaled, 1.0f));
|
|
return model;
|
|
}
|
|
|
|
mat4 canvas_parent_model_get(vec2 position, vec2 pivot, vec2 scale, f32 rotation)
|
|
{
|
|
vec2 scaleSign = glm::sign(scale);
|
|
vec2 scaleAbsolute = glm::abs(scale);
|
|
f32 handedness = (scaleSign.x * scaleSign.y) < 0.0f ? -1.0f : 1.0f;
|
|
|
|
mat4 local(1.0f);
|
|
local = glm::translate(local, vec3(pivot, 0.0f));
|
|
local = glm::scale(local, vec3(scaleSign, 1.0f));
|
|
local = glm::rotate(local, glm::radians(rotation) * handedness, vec3(0, 0, 1));
|
|
local = glm::translate(local, vec3(-pivot, 0.0f));
|
|
local = glm::scale(local, vec3(scaleAbsolute, 1.0f));
|
|
|
|
return glm::translate(mat4(1.0f), vec3(position, 0.0f)) * local;
|
|
} |