309 lines
11 KiB
C++
309 lines
11 KiB
C++
#include "editor.h"
|
|
|
|
static s32 _editor_grid_set(Editor* self);
|
|
|
|
static s32
|
|
_editor_grid_set(Editor* self)
|
|
{
|
|
std::vector<f32> vertices;
|
|
|
|
s32 verticalLineCount = (s32)(EDITOR_SIZE.x / MIN(self->settings->editorGridSizeX, EDITOR_GRID_MIN));
|
|
s32 horizontalLineCount = (s32)(EDITOR_SIZE.y / MIN(self->settings->editorGridSizeY, EDITOR_GRID_MIN));
|
|
|
|
/* Vertical */
|
|
for (s32 i = 0; i <= verticalLineCount; i++)
|
|
{
|
|
s32 x = i * self->settings->editorGridSizeX - self->settings->editorGridOffsetX;
|
|
f32 normX = (2.0f * x) / EDITOR_SIZE.x - 1.0f;
|
|
|
|
vertices.push_back(normX);
|
|
vertices.push_back(-1.0f);
|
|
vertices.push_back(normX);
|
|
vertices.push_back(1.0f);
|
|
}
|
|
|
|
/* Horizontal */
|
|
for (s32 i = 0; i <= horizontalLineCount; i++)
|
|
{
|
|
s32 y = i * self->settings->editorGridSizeY - self->settings->editorGridOffsetY;
|
|
f32 normY = (2.0f * y) / EDITOR_SIZE.y - 1.0f;
|
|
|
|
vertices.push_back(-1.0f);
|
|
vertices.push_back(normY);
|
|
vertices.push_back(1.0f);
|
|
vertices.push_back(normY);
|
|
}
|
|
|
|
glBindVertexArray(self->gridVAO);
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->gridVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(f32), vertices.data(), GL_DYNAMIC_DRAW);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(f32), (void*)0);
|
|
|
|
return (s32)vertices.size();
|
|
}
|
|
|
|
void
|
|
editor_init
|
|
(
|
|
Editor* self,
|
|
Anm2* anm2,
|
|
Anm2Reference* reference,
|
|
s32* animationID,
|
|
s32* spritesheetID,
|
|
Resources* resources,
|
|
Settings* settings
|
|
)
|
|
{
|
|
self->anm2 = anm2;
|
|
self->reference = reference;
|
|
self->animationID = animationID;
|
|
self->spritesheetID = spritesheetID;
|
|
self->resources = resources;
|
|
self->settings = settings;
|
|
|
|
/* Framebuffer + texture */
|
|
glGenFramebuffers(1, &self->fbo);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, self->fbo);
|
|
|
|
glGenTextures(1, &self->texture);
|
|
glBindTexture(GL_TEXTURE_2D, self->texture);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (s32)EDITOR_SIZE.x, (s32)EDITOR_SIZE.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
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->texture, 0);
|
|
|
|
glGenRenderbuffers(1, &self->rbo);
|
|
glBindRenderbuffer(GL_RENDERBUFFER, self->rbo);
|
|
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, (s32)EDITOR_SIZE.x, (s32)EDITOR_SIZE.y);
|
|
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, self->rbo);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
|
|
/* Grid */
|
|
glGenVertexArrays(1, &self->gridVAO);
|
|
glGenBuffers(1, &self->gridVBO);
|
|
|
|
/* Border */
|
|
glGenVertexArrays(1, &self->borderVAO);
|
|
glGenBuffers(1, &self->borderVBO);
|
|
|
|
glBindVertexArray(self->borderVAO);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->borderVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(GL_VERTICES), GL_VERTICES, GL_STATIC_DRAW);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(f32), (void*)0);
|
|
|
|
/* Viewing 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, NULL, GL_DYNAMIC_DRAW);
|
|
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self->textureEBO);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GL_TEXTURE_INDICES), GL_TEXTURE_INDICES, GL_STATIC_DRAW);
|
|
|
|
/* Position */
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(f32), (void*)0);
|
|
|
|
/* UV */
|
|
glEnableVertexAttribArray(1);
|
|
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(f32), (void*)(2 * sizeof(f32)));
|
|
|
|
glBindVertexArray(0);
|
|
|
|
_editor_grid_set(self);
|
|
}
|
|
|
|
void
|
|
editor_draw(Editor* self)
|
|
{
|
|
GLuint shaderLine = self->resources->shaders[SHADER_LINE];
|
|
GLuint shaderLineDotted = self->resources->shaders[SHADER_LINE_DOTTED];
|
|
GLuint shaderTexture = self->resources->shaders[SHADER_TEXTURE];
|
|
f32 zoomFactor = self->settings->editorZoom / 100.0f;
|
|
|
|
/* Convert pan to pixels */
|
|
glm::vec2 ndcPan = glm::vec2(-self->settings->editorPanX / (EDITOR_SIZE.x / 2.0f), -self->settings->editorPanY / (EDITOR_SIZE.y / 2.0f));
|
|
|
|
/* Transformation matrix */
|
|
glm::mat4 editorTransform = glm::translate(glm::mat4(1.0f), glm::vec3(ndcPan, 0.0f));
|
|
editorTransform = glm::scale(editorTransform, glm::vec3(zoomFactor, zoomFactor, 1.0f));
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, self->fbo);
|
|
glViewport(0, 0, EDITOR_SIZE.x, EDITOR_SIZE.y);
|
|
|
|
glClearColor
|
|
(
|
|
self->settings->editorBackgroundColorR,
|
|
self->settings->editorBackgroundColorG,
|
|
self->settings->editorBackgroundColorB,
|
|
self->settings->editorBackgroundColorA
|
|
);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
if (*self->spritesheetID > -1)
|
|
{
|
|
Texture* texture = &self->resources->textures[*self->spritesheetID];
|
|
|
|
glm::mat4 spritesheetTransform = editorTransform;
|
|
glm::vec2 ndcScale = glm::vec2(texture->size.x, texture->size.y) / (EDITOR_SIZE * 0.5f);
|
|
|
|
spritesheetTransform = glm::scale(spritesheetTransform, glm::vec3(ndcScale, 1.0f));
|
|
|
|
glUseProgram(shaderTexture);
|
|
|
|
glBindVertexArray(self->textureVAO);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->textureVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(GL_UV_VERTICES), GL_UV_VERTICES, GL_DYNAMIC_DRAW);
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, texture->id);
|
|
|
|
glUniform1i(glGetUniformLocation(shaderTexture, SHADER_UNIFORM_TEXTURE), 0);
|
|
glUniform4fv(glGetUniformLocation(shaderTexture, SHADER_UNIFORM_TINT), 1, value_ptr(COLOR_OPAQUE));
|
|
glUniform3fv(glGetUniformLocation(shaderTexture, SHADER_UNIFORM_COLOR_OFFSET), 1, value_ptr(COLOR_OFFSET_NONE));
|
|
glUniformMatrix4fv(glGetUniformLocation(shaderTexture, SHADER_UNIFORM_TRANSFORM), 1, GL_FALSE, value_ptr(spritesheetTransform));
|
|
|
|
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
glBindVertexArray(0);
|
|
glUseProgram(0);
|
|
|
|
if (self->settings->editorIsBorder)
|
|
{
|
|
glUseProgram(shaderLineDotted);
|
|
|
|
glBindVertexArray(self->borderVAO);
|
|
|
|
glUniformMatrix4fv(glGetUniformLocation(shaderLine, SHADER_UNIFORM_TRANSFORM), 1, GL_FALSE, glm::value_ptr(spritesheetTransform));
|
|
glUniform4fv(glGetUniformLocation(shaderLine, SHADER_UNIFORM_COLOR), 1, glm::value_ptr(EDITOR_BORDER_TINT));
|
|
|
|
glDrawArrays(GL_LINE_LOOP, 0, 4);
|
|
|
|
glBindVertexArray(0);
|
|
glUseProgram(0);
|
|
}
|
|
|
|
Anm2Frame* frame = (Anm2Frame*)anm2_frame_from_reference(self->anm2, self->reference, *self->animationID);
|
|
|
|
/* Draw the layer frame's crop and pivot */
|
|
if (frame && self->reference->type == ANM2_LAYER)
|
|
{
|
|
/* Rect */
|
|
glm::mat4 rectTransform = editorTransform;
|
|
|
|
glm::vec2 rectNDCPos = frame->crop / (EDITOR_SIZE / 2.0f);
|
|
glm::vec2 rectNDCScale = frame->size / (EDITOR_SIZE / 2.0f);
|
|
|
|
rectTransform = glm::translate(rectTransform, glm::vec3(rectNDCPos, 0.0f));
|
|
rectTransform = glm::scale(rectTransform, glm::vec3(rectNDCScale, 1.0f));
|
|
|
|
glUseProgram(shaderLineDotted);
|
|
|
|
glBindVertexArray(self->borderVAO);
|
|
|
|
glUniformMatrix4fv(glGetUniformLocation(shaderLine, SHADER_UNIFORM_TRANSFORM), 1, GL_FALSE, glm::value_ptr(rectTransform));
|
|
glUniform4fv(glGetUniformLocation(shaderLine, SHADER_UNIFORM_COLOR), 1, glm::value_ptr(EDITOR_FRAME_TINT));
|
|
|
|
glDrawArrays(GL_LINE_LOOP, 0, 4);
|
|
|
|
glBindVertexArray(0);
|
|
glUseProgram(0);
|
|
|
|
/* Pivot */
|
|
glm::mat4 pivotTransform = editorTransform;
|
|
glm::vec2 pivotNDCPos = ((frame->crop + frame->pivot) - (EDITOR_PIVOT_SIZE / 2.0f)) / (EDITOR_SIZE / 2.0f);
|
|
glm::vec2 pivotNDCScale = EDITOR_PIVOT_SIZE / (EDITOR_SIZE / 2.0f);
|
|
|
|
pivotTransform = glm::translate(pivotTransform, glm::vec3(pivotNDCPos, 0.0f));
|
|
pivotTransform = glm::scale(pivotTransform, glm::vec3(pivotNDCScale, 1.0f));
|
|
|
|
glUseProgram(shaderTexture);
|
|
|
|
glBindVertexArray(self->textureVAO);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->textureVBO);
|
|
|
|
f32 vertices[] = ATLAS_UV_VERTICES(TEXTURE_PIVOT);
|
|
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_DYNAMIC_DRAW);
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, self->resources->atlas.id);
|
|
|
|
glUniform1i(glGetUniformLocation(shaderTexture, SHADER_UNIFORM_TEXTURE), 0);
|
|
glUniform4fv(glGetUniformLocation(shaderTexture, SHADER_UNIFORM_TINT), 1, value_ptr(EDITOR_FRAME_TINT));
|
|
glUniform3fv(glGetUniformLocation(shaderTexture, SHADER_UNIFORM_COLOR_OFFSET), 1, value_ptr(COLOR_OFFSET_NONE));
|
|
glUniformMatrix4fv(glGetUniformLocation(shaderTexture, SHADER_UNIFORM_TRANSFORM), 1, GL_FALSE, value_ptr(pivotTransform));
|
|
|
|
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
|
|
|
|
glBindVertexArray(0);
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
glUseProgram(0);
|
|
}
|
|
}
|
|
|
|
if (self->settings->editorIsGrid)
|
|
{
|
|
static ivec2 previousGridSize = {-1, -1};
|
|
static ivec2 previousGridOffset = {-1, -1};
|
|
static s32 gridVertexCount = -1;
|
|
ivec2 gridSize = ivec2(self->settings->editorGridSizeX, self->settings->editorGridSizeY);
|
|
ivec2 gridOffset = ivec2(self->settings->editorGridOffsetX, self->settings->editorGridOffsetY);
|
|
|
|
if (previousGridSize != gridSize || previousGridOffset != gridOffset)
|
|
{
|
|
gridVertexCount = _editor_grid_set(self);
|
|
previousGridSize = gridSize;
|
|
previousGridOffset = gridOffset;
|
|
}
|
|
|
|
glUseProgram(shaderLine);
|
|
glBindVertexArray(self->gridVAO);
|
|
glUniformMatrix4fv(glGetUniformLocation(shaderLine, SHADER_UNIFORM_TRANSFORM), 1, GL_FALSE, (f32*)value_ptr(editorTransform));
|
|
|
|
glUniform4f
|
|
(
|
|
glGetUniformLocation(shaderLine, SHADER_UNIFORM_COLOR),
|
|
self->settings->editorGridColorR, self->settings->editorGridColorG, self->settings->editorGridColorB, self->settings->editorGridColorA
|
|
);
|
|
|
|
glDrawArrays(GL_LINES, 0, gridVertexCount);
|
|
|
|
glBindVertexArray(0);
|
|
glUseProgram(0);
|
|
}
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
}
|
|
|
|
void
|
|
editor_tick(Editor* self)
|
|
{
|
|
self->settings->editorZoom = CLAMP(self->settings->editorZoom, EDITOR_ZOOM_MIN, EDITOR_ZOOM_MAX);
|
|
}
|
|
|
|
void
|
|
editor_free(Editor* self)
|
|
{
|
|
glDeleteTextures(1, &self->texture);
|
|
glDeleteFramebuffers(1, &self->fbo);
|
|
glDeleteRenderbuffers(1, &self->rbo);
|
|
} |