Moved spritesheet texture handling to anm2 instead of resources; added undoing for spritesheet texture changes; refactoring

README.md

@@ -26,7 +26,7 @@ Note, to render animations, you'll need to download [FFmpeg](https://ffmpeg.org/
 
 After cloning and enter the repository's directory, make sure to initialize the submodules:
 
-```git submodules update --init```
+```git submodule update --init```
 
 Then:
 

src/COMMON.h

@@ -44,6 +44,8 @@ typedef double f64;
 
 using namespace glm; 
 
+#define PREFERENCES_DIRECTORY "anm2ed"
+
 #define ROUND_NEAREST_MULTIPLE(value, multiple) (roundf((value) / (multiple)) * (multiple))
 #define FLOAT_TO_U8(x) (static_cast<u8>((x) * 255.0f))
 #define U8_TO_FLOAT(x) ((x) / 255.0f)
@@ -54,40 +56,20 @@ using namespace glm;
 #define ID_NONE -1
 #define INDEX_NONE -1
 #define TIME_NONE -1.0f
+#define GL_ID_NONE 0
 
 #if defined(_WIN32)
   #define POPEN  _popen
   #define PCLOSE _pclose
   #define PWRITE_MODE "wb"
+  #define PREAD_MODE "r"
 #else
   #define POPEN  popen
   #define PCLOSE pclose
   #define PWRITE_MODE "w"
+  #define PREAD_MODE "r"
 #endif
 
-#define UV_VERTICES(uvMin, uvMax) \
-{ \
-  0, 0, uvMin.x, uvMin.y, \
-  1, 0, uvMax.x, uvMin.y, \
-  1, 1, uvMax.x, uvMax.y, \
-  0, 1, uvMin.x, uvMax.y  \
-}
-
-static const f32 GL_VERTICES[] =
-{
-    0, 0,  
-    1, 0,  
-    1, 1,  
-    0, 1  
-};
-
-constexpr f32 GL_UV_VERTICES[] = 
-{
-    0, 0, 0.0f, 0.0f,
-    1, 0, 1.0f, 0.0f,
-    1, 1, 1.0f, 1.0f,
-    0, 1, 0.0f, 1.0f
-};
 
 static const GLuint GL_TEXTURE_INDICES[] = {0, 1, 2, 2, 3, 0};
 static const vec4 COLOR_RED = {1.0f, 0.0f, 0.0f, 1.0f};
@@ -98,19 +80,12 @@ static const vec4 COLOR_OPAQUE = {1.0f, 1.0f, 1.0f, 1.0f};
 static const vec4 COLOR_TRANSPARENT = {0.0f, 0.0f, 0.0f, 0.0f};
 static const vec3 COLOR_OFFSET_NONE = {0.0f, 0.0f, 0.0f};
 
-static inline void log_error(const std::string& string)
+static inline std::string preferences_path_get(void)
 {
-    std::println("[ERROR] {}", string);
+    char* preferencesPath = SDL_GetPrefPath("", PREFERENCES_DIRECTORY);
-}
+    std::string preferencesPathString = preferencesPath;
-
+    SDL_free(preferencesPath);
-static inline void log_info(const std::string& string)
+    return preferencesPathString;
-{
-    std::println("[INFO] {}", string);
-}
-
-static inline void log_warning(const std::string& string)
-{
-    std::println("[WARNING] {}", string);
 }
 
 static inline bool string_to_bool(const std::string& string) 
@@ -367,38 +342,7 @@ static inline void map_insert_shift(std::map<int, T>& map, s32 index, const T& v
     map[insertIndex] = value;
 }
 
-static inline mat4 quad_model_get(vec2 size, vec2 position, vec2 pivot, f32 rotation, vec2 scale)
-{
-    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;
-}
-
-static inline mat4 quad_parent_model_get(vec2 position, vec2 pivot, f32 rotation, vec2 scale)
-{
-    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)); // mirror if needed
-    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;
-}
 
 #define DEFINE_ENUM_TO_STRING_FUNCTION(function, array, count) \
     static inline std::string function(s32 index)              \

src/PACKED.h

@@ -275,21 +275,19 @@ const std::string SHADER_GRID_FRAGMENT = R"(
 #version 330 core
 in vec2 clip;
 
-uniform mat4 u_model;   // inverse of your world->clip matrix (MVP)
+uniform mat4 u_model;
-uniform vec2 u_size;     // world-space cell size (e.g. 64,64)
+uniform vec2 u_size; 
-uniform vec2 u_offset;   // world-space grid offset (shifts entire grid)
+uniform vec2 u_offset;
-uniform vec4 u_color;    // RGBA
+uniform vec4 u_color;
 
 out vec4 o_fragColor;
 
 void main() 
 {
-    // clip -> world on z=0 plane
     vec4 w = u_model * vec4(clip, 0.0, 1.0);
     w /= w.w;
     vec2 world = w.xy;
 
-    // grid space
     vec2 g = (world - u_offset) / u_size;
 
     vec2 d = abs(fract(g) - 0.5);

src/anm2.cpp

@@ -303,7 +303,7 @@ bool anm2_serialize(Anm2* self, const std::string& path)
 	return true;
 }
 
-bool anm2_deserialize(Anm2* self, Resources* resources, const std::string& path)
+bool anm2_deserialize(Anm2* self, const std::string& path)
 {
 	XMLDocument xmlDocument;
 	XMLError xmlError;
@@ -588,8 +588,8 @@ bool anm2_deserialize(Anm2* self, Resources* resources, const std::string& path)
 			xmlAttribute = xmlAttribute->Next();
 		}
 
-		if (anm2Element == ANM2_ELEMENT_SPRITESHEET && resources) 
+		if (anm2Element == ANM2_ELEMENT_SPRITESHEET)
-			resources_texture_init(resources, spritesheet->path, id);
+			texture_from_path_init(&spritesheet->texture, spritesheet->path);
 
 		xmlChild = xmlElement->FirstChildElement();
 
@@ -620,6 +620,10 @@ bool anm2_deserialize(Anm2* self, Resources* resources, const std::string& path)
 		if (animation.name == defaultAnimation)
 			self->defaultAnimationID = id;
 
+	// Copy texture data to pixels (used for snapshots)
+	anm2_spritesheet_texture_pixels_download(self);
+
+	// Read
 	log_info(std::format(ANM2_READ_INFO, path));
 	
 	// Return to old working directory
@@ -706,7 +710,6 @@ void anm2_null_remove(Anm2* self, s32 id)
     }
 }
 
-
 s32 anm2_animation_add(Anm2* self)
 {
     s32 id  = map_next_id_get(self->animations);
@@ -1168,3 +1171,39 @@ void anm2_generate_from_grid(Anm2* self, Anm2Reference* reference, vec2 startPos
 		frameReference.frameIndex++;
 	}
 }
+
+void anm2_free(Anm2* self)
+{
+	for (auto& [id, spritesheet] : self->spritesheets)
+		texture_free(&spritesheet.texture);
+}
+
+void anm2_spritesheet_texture_pixels_upload(Anm2* self)
+{
+    for (auto& [_, spritesheet] : self->spritesheets)
+    {
+        Texture& texture = spritesheet.texture;
+
+        if (texture.id != GL_ID_NONE && !texture.isInvalid)
+        {
+            assert(!spritesheet.pixels.empty());
+            glBindTexture(GL_TEXTURE_2D, texture.id);
+            glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture.size.x, texture.size.y, GL_RGBA, GL_UNSIGNED_BYTE, spritesheet.pixels.data());
+        }
+    }
+}
+
+void anm2_spritesheet_texture_pixels_download(Anm2* self)
+{
+    for (auto& [_, spritesheet] : self->spritesheets)
+    {
+        Texture& texture = spritesheet.texture;
+
+        if (texture.id != GL_ID_NONE && !texture.isInvalid)
+        {
+            spritesheet.pixels.resize(texture.size.x * texture.size.y * texture.channels);
+            glBindTexture(GL_TEXTURE_2D, texture.id);
+            glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, spritesheet.pixels.data());
+        }
+    }
+}

src/anm2.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "COMMON.h"
 #include "resources.h"
 
 #define ANM2_SCALE_CONVERT(x) ((f32)x / 100.0f)
@@ -131,6 +130,8 @@ enum Anm2Type
 struct Anm2Spritesheet
 {
     std::string path{};
+    Texture texture;
+    std::vector<u8> pixels; 
 };
 
 struct Anm2Layer
@@ -163,8 +164,8 @@ struct Anm2Frame
 	vec2 position{};
 	vec2 size{};
 	vec2 scale = {100, 100};
-	vec3 offsetRGB{};
+	vec3 offsetRGB = COLOR_OFFSET_NONE;
-	vec4 tintRGBA = {1.0f, 1.0f, 1.0f, 1.0f};
+	vec4 tintRGBA = COLOR_OPAQUE;
 };
 
 struct Anm2FrameChange
@@ -262,12 +263,12 @@ void anm2_layer_remove(Anm2* self, s32 id);
 void anm2_null_add(Anm2* self);
 void anm2_null_remove(Anm2* self, s32 id);
 bool anm2_serialize(Anm2* self, const std::string& path);
-bool anm2_deserialize(Anm2* self, Resources* resources, const std::string& path);
+bool anm2_deserialize(Anm2* self, const std::string& path);
 void anm2_new(Anm2* self);
+void anm2_free(Anm2* self);
 void anm2_created_on_set(Anm2* self);
 s32 anm2_animation_add(Anm2* self);
 void anm2_animation_remove(Anm2* self, s32 id);
-void anm2_spritesheet_texture_load(Anm2* self, Resources* resources, const std::string& path, s32 id);
 Anm2Animation* anm2_animation_from_reference(Anm2* self, Anm2Reference* reference);
 Anm2Item* anm2_item_from_reference(Anm2* self, Anm2Reference* reference);
 Anm2Frame* anm2_frame_from_reference(Anm2* self, Anm2Reference* reference);
@@ -285,3 +286,5 @@ void anm2_frame_bake(Anm2* self, Anm2Reference* reference, s32 interval, bool is
 void anm2_item_frame_set(Anm2* self, Anm2Reference* reference, const Anm2FrameChange& change, Anm2ChangeType type, s32 start, s32 count);
 void anm2_scale(Anm2* self, f32 scale);
 void anm2_generate_from_grid(Anm2* self, Anm2Reference* reference, vec2 startPosition, vec2 size, vec2 pivot, s32 columns, s32 count, s32 delay);
+void anm2_spritesheet_texture_pixels_upload(Anm2* self);
+void anm2_spritesheet_texture_pixels_download(Anm2* self);

src/canvas.cpp

@@ -1,32 +1,19 @@
 #include "canvas.h"
 
-static void _canvas_texture_free(Canvas* self)
+static void _canvas_framebuffer_set(Canvas* self, const ivec2& size)
 {
-    if (self->fbo != 0)     glDeleteFramebuffers(1, &self->fbo);
-    if (self->rbo != 0)     glDeleteRenderbuffers(1, &self->rbo);
-    if (self->texture != 0) glDeleteTextures(1, &self->texture);
-}
-
-static void _canvas_texture_init(Canvas* self, const ivec2& size)
-{
-    _canvas_texture_free(self);
-
     self->size = size;
     self->previousSize = size;
     
-    glGenFramebuffers(1, &self->fbo);
-
     glBindFramebuffer(GL_FRAMEBUFFER, self->fbo);
 
-    glGenTextures(1, &self->texture);
+    glBindTexture(GL_TEXTURE_2D, self->framebuffer);
-    glBindTexture(GL_TEXTURE_2D, self->texture);
     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->texture, 0);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->framebuffer, 0);
 
-    glGenRenderbuffers(1, &self->rbo);
     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);
@@ -65,7 +52,7 @@ void canvas_init(Canvas* self, const ivec2& size)
     glBindVertexArray(self->rectVAO);
 
     glBindBuffer(GL_ARRAY_BUFFER, self->rectVBO);
-    glBufferData(GL_ARRAY_BUFFER, sizeof(GL_VERTICES), GL_VERTICES, GL_STATIC_DRAW);
+    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);
@@ -104,7 +91,11 @@ void canvas_init(Canvas* self, const ivec2& size)
     
     glBindVertexArray(0);
 
-    _canvas_texture_init(self, size);
+    // 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)
@@ -140,10 +131,10 @@ void canvas_viewport_set(Canvas* self)
     glViewport(0, 0, (s32)self->size.x, (s32)self->size.y);
 }
 
-void canvas_texture_set(Canvas* self)
+void canvas_framebuffer_resize_check(Canvas* self)
 {
     if (self->previousSize != self->size)
-        _canvas_texture_init(self, self->size);
+        _canvas_framebuffer_set(self, self->size);
 }
 
 void canvas_grid_draw(Canvas* self, GLuint& shader, mat4& transform, ivec2& size, ivec2& offset, vec4& color)
@@ -171,7 +162,7 @@ void canvas_texture_draw(Canvas* self, GLuint& shader, GLuint& texture, mat4& tr
     glBindVertexArray(self->textureVAO);
     
     glBindBuffer(GL_ARRAY_BUFFER, self->textureVBO);
-    glBufferData(GL_ARRAY_BUFFER, sizeof(GL_UV_VERTICES), vertices, GL_DYNAMIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(CANVAS_TEXTURE_VERTICES), vertices, GL_DYNAMIC_DRAW);
     
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, texture);
@@ -227,30 +218,49 @@ void canvas_unbind(void)
 
 void canvas_free(Canvas* self)
 {
-    _canvas_texture_free(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_mvp_get(mat4& transform, vec2 size, vec2 position, vec2 pivot, f32 rotation, vec2 scale, vec2 pivotAlt, f32 rotationAlt)
+mat4 canvas_model_get(vec2 size, vec2 position, vec2 pivot, vec2 scale, f32 rotation)
 {
     vec2 scaleAbsolute  = glm::abs(scale);
     vec2 scaleSign = glm::sign(scale);
-    f32 usedSign = (scaleSign.x * scaleSign.y) < 0.0f ? -1.0f : 1.0f;
-
-    vec2 sizeScaled = size * scaleAbsolute;
     vec2 pivotScaled = pivot * scaleAbsolute;
-    vec2 pivotAltScaled = pivotAlt * scaleAbsolute;
+    vec2 sizeScaled  = size  * scaleAbsolute;
 
-    vec2 pivotAltMirrored = pivotScaled + (pivotAltScaled - pivotScaled) * scaleSign;
+    mat4 model(1.0f);
-
+    model = glm::translate(model, vec3(position - pivotScaled, 0.0f));
-    mat4 model = glm::translate(mat4(1.0f), 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) * usedSign, vec3(0,0,1));
+    model = glm::rotate(model, glm::radians(rotation), vec3(0, 0, 1));
     model = glm::translate(model, vec3(-pivotScaled, 0.0f));
-    model = glm::translate(model, vec3(pivotAltMirrored, 0.0f));
-    model = glm::rotate(model, glm::radians(rotationAlt) * usedSign, vec3(0,0,1));
-    model = glm::translate(model, vec3(-pivotAltMirrored, 0.0f));
     model = glm::scale(model, vec3(sizeScaled, 1.0f));
-
+    return model;
-    return transform * 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;
 }

src/canvas.h

@@ -12,10 +12,10 @@
 #define CANVAS_GRID_DEFAULT 32
 #define CANVAS_LINE_LENGTH (FLT_MAX * 0.001f)
 
-static const vec2 CANVAS_PIVOT_SIZE = {8, 8};
+const inline vec2 CANVAS_PIVOT_SIZE = {8, 8};
-static const vec2 CANVAS_SCALE_DEFAULT = {1.0f, 1.0f};
+const inline vec2 CANVAS_SCALE_DEFAULT = {1.0f, 1.0f};
 
-const f32 CANVAS_AXIS_VERTICES[] = 
+const inline f32 CANVAS_AXIS_VERTICES[] = 
 {
     -CANVAS_LINE_LENGTH, 0.0f,
     CANVAS_LINE_LENGTH, 0.0f,
@@ -23,13 +23,29 @@ const f32 CANVAS_AXIS_VERTICES[] =
     0.0f, CANVAS_LINE_LENGTH
 };
 
-const f32 CANVAS_GRID_VERTICES[] =
+const inline f32 CANVAS_GRID_VERTICES[] =
 {
    -1.0f, -1.0f,
     3.0f, -1.0f,
    -1.0f,  3.0f
 };
 
+const inline f32 CANVAS_RECT_VERTICES[] =
+{
+    0, 0,  
+    1, 0,  
+    1, 1,  
+    0, 1  
+};
+
+const inline f32 CANVAS_TEXTURE_VERTICES[] = 
+{
+    0, 0, 0.0f, 0.0f,
+    1, 0, 1.0f, 0.0f,
+    1, 1, 1.0f, 1.0f,
+    0, 1, 0.0f, 1.0f
+};
+
 struct Canvas
 {
     GLuint fbo{};
@@ -40,38 +56,36 @@ struct Canvas
     GLuint rectVBO{};
     GLuint gridVAO{};
     GLuint gridVBO{};
-    GLuint texture{};
+    GLuint framebuffer{};
-    GLuint textureEBO{};
     GLuint textureVAO{};
     GLuint textureVBO{};
+    GLuint textureEBO{};
     ivec2 size{};
     ivec2 previousSize{};
 };
 
-void canvas_init(Canvas* self, const ivec2& size);
+#define UV_VERTICES(uvMin, uvMax) \
-mat4 canvas_transform_get(Canvas* self, vec2 pan, f32 zoom, OriginType origin);
+{ \
-void canvas_clear(vec4& color);
+  0, 0, uvMin.x, uvMin.y, \
-void canvas_bind(Canvas* self);
+  1, 0, uvMax.x, uvMin.y, \
-void canvas_viewport_set(Canvas* self);
+  1, 1, uvMax.x, uvMax.y, \
-void canvas_unbind(void);
+  0, 1, uvMin.x, uvMax.y  \
-void canvas_texture_set(Canvas* self);
+}
-void canvas_grid_draw(Canvas* self, GLuint& shader, mat4& transform, ivec2& size, ivec2& offset, vec4& color);
-void canvas_axes_draw(Canvas* self, GLuint& shader, mat4& transform, vec4& color);
-void canvas_rect_draw(Canvas* self, const GLuint& shader, const mat4& transform, const vec4& color);
-void canvas_free(Canvas* self);
-void canvas_draw(Canvas* self);
 
-mat4 canvas_mvp_get
+mat4 canvas_transform_get(Canvas* self, vec2 pan, f32 zoom, OriginType origin);
-(
+void canvas_axes_draw(Canvas* self, GLuint& shader, mat4& transform, vec4& color);
-    mat4& transform, 
+void canvas_bind(Canvas* self);
-    vec2 size,
+void canvas_clear(vec4& color);
-    vec2 position = {0.0f, 0.0f}, 
+void canvas_draw(Canvas* self);
-    vec2 pivot = {0.0f, 0.0f}, 
+void canvas_free(Canvas* self);
-    f32 rotation = {0.0f},
+void canvas_grid_draw(Canvas* self, GLuint& shader, mat4& transform, ivec2& size, ivec2& offset, vec4& color);
-    vec2 scale = {1.0f, 1.0f},
+void canvas_init(Canvas* self, const ivec2& size);
-    vec2 pivotAlt = {0.0f, 0.0f},
+void canvas_rect_draw(Canvas* self, const GLuint& shader, const mat4& transform, const vec4& color);
-    f32 rotationAlt = {0.0f}
+void canvas_framebuffer_resize_check(Canvas* self);
-);
+void canvas_unbind(void);
+void canvas_viewport_set(Canvas* self);
+mat4 canvas_model_get(vec2 size = {}, vec2 position = {}, vec2 pivot = {}, vec2 scale = vec2(1.0f), f32 rotation = {});
+mat4 canvas_parent_model_get(vec2 position = {}, vec2 pivot = {}, vec2 scale = vec2(1.0f), f32 rotation = {});
 
 void canvas_texture_draw
 (
@@ -79,7 +93,7 @@ void canvas_texture_draw
     GLuint& shader, 
     GLuint& texture, 
     mat4& transform, 
-    const f32* vertices = GL_UV_VERTICES,
+    const f32* vertices = CANVAS_TEXTURE_VERTICES, 
     vec4 tint = COLOR_OPAQUE, 
     vec3 colorOffset = COLOR_OFFSET_NONE
 );

src/dialog.cpp

@@ -73,11 +73,11 @@ void dialog_ffmpeg_path_set(Dialog* self)
 void dialog_explorer_open(const std::string& path)
 {
 #ifdef _WIN32
-		ShellExecuteA(NULL, "open", path.c_str(), NULL, NULL, SW_SHOWNORMAL);
+		ShellExecuteA(NULL, DIALOG_FILE_EXPLORER_COMMAND, path.c_str(), NULL, NULL, SW_SHOWNORMAL);
 #else 
-		char cmd[512];
+		char command[DIALOG_FILE_EXPLORER_COMMAND_SIZE];
-		snprintf(cmd, sizeof(cmd), "xdg-open \"%s\" &", path.c_str());
+		snprintf(command, sizeof(command), DIALOG_FILE_EXPLORER_COMMAND, path.c_str());
-		system(cmd);
+		system(command);
 #endif
 }
 

src/dialog.h

@@ -3,6 +3,14 @@
 #include "render.h"
 #include "window.h"
 
+#define DIALOG_FILE_EXPLORER_COMMAND_SIZE 512
+
+#ifdef _WIN32
+#define DIALOG_FILE_EXPLORER_COMMAND "open"
+#else 
+#define DIALOG_FILE_EXPLORER_COMMAND "xdg-open \"%s\" &"
+#endif
+
 const SDL_DialogFileFilter DIALOG_FILE_FILTER_ANM2[] =
 {
     {"Anm2 file", "anm2;xml"}

src/editor.cpp

@@ -20,7 +20,7 @@ void editor_draw(Editor* self)
     GLuint& shaderGrid = self->resources->shaders[SHADER_GRID];
     mat4 transform = canvas_transform_get(&self->canvas, self->settings->editorPan, self->settings->editorZoom, ORIGIN_TOP_LEFT);
     
-    canvas_texture_set(&self->canvas);
+    canvas_framebuffer_resize_check(&self->canvas);
     
     canvas_bind(&self->canvas);
     canvas_viewport_set(&self->canvas);
@@ -28,23 +28,24 @@ void editor_draw(Editor* self)
 
     if (self->spritesheetID != ID_NONE)
     {
-        Texture texture = self->resources->textures[self->spritesheetID];
+        Texture& texture = self->anm2->spritesheets[self->spritesheetID].texture;
-        mat4 mvp = canvas_mvp_get(transform, texture.size);
+        
-        canvas_texture_draw(&self->canvas, shaderTexture, texture.id, mvp);
+        mat4 spritesheetTransform = transform * canvas_model_get(texture.size);
+        canvas_texture_draw(&self->canvas, shaderTexture, texture.id, spritesheetTransform);
 
         if (self->settings->editorIsBorder)
-            canvas_rect_draw(&self->canvas, shaderLine, mvp, EDITOR_BORDER_COLOR);
+            canvas_rect_draw(&self->canvas, shaderLine, spritesheetTransform, EDITOR_BORDER_COLOR);
 
         Anm2Frame* frame = (Anm2Frame*)anm2_frame_from_reference(self->anm2, self->reference);
     
         if (frame)
         {
-            mvp = canvas_mvp_get(transform, frame->size, frame->crop);
+            mat4 cropTransform = transform * canvas_model_get(frame->size, frame->crop);
-            canvas_rect_draw(&self->canvas, shaderLine, mvp, EDITOR_FRAME_COLOR);
+            canvas_rect_draw(&self->canvas, shaderLine, cropTransform, EDITOR_FRAME_COLOR);
 
-            mvp = canvas_mvp_get(transform, CANVAS_PIVOT_SIZE, frame->crop + frame->pivot, CANVAS_PIVOT_SIZE * 0.5f);
+            mat4 pivotTransform = transform * canvas_model_get(CANVAS_PIVOT_SIZE, frame->crop + frame->pivot, CANVAS_PIVOT_SIZE * 0.5f);
             f32 vertices[] = ATLAS_UV_VERTICES(ATLAS_PIVOT);
-            canvas_texture_draw(&self->canvas, shaderTexture, self->resources->atlas.id, mvp, vertices, EDITOR_PIVOT_COLOR);
+            canvas_texture_draw(&self->canvas, shaderTexture, self->resources->atlas.id, pivotTransform, vertices, EDITOR_PIVOT_COLOR);
         }
     }
 

src/ffmpeg.cpp

@@ -1,5 +1,10 @@
 #include "ffmpeg.h"
 
+static std::string ffmpeg_log_path_get(void)
+{
+    return preferences_path_get() + FFMPEG_LOG_PATH;
+}
+
 bool 
 ffmpeg_render
 (
@@ -30,20 +35,33 @@ ffmpeg_render
             break;
     }
 
+    // ffmpeg output will be piped into the log
+    std::string logOutput = " 2>> \"" + ffmpeg_log_path_get() + "\"";
+
 #if _WIN32
-    command = string_quote(command);
+    command = string_quote(command) + logOutput;
+#else
+    command += logOutput;
 #endif
 
+    log_command(command);
+
     FILE* fp = POPEN(command.c_str(), PWRITE_MODE);
 
     if (!fp) 
     {
-        log_info(std::format(FFMPEG_POPEN_ERROR, strerror(errno)));
+        log_error(std::format(FFMPEG_POPEN_ERROR, strerror(errno)));
         return false;
     }
 
+    
     size_t frameBytes = size.x * size.y * TEXTURE_CHANNELS;
 
+// supposedly, might help with video corruption issues on windows?
+#if _WIN32
+    _setmode(_fileno(stdout), _O_BINARY);
+#endif
+
     for (const auto& frame : frames) 
     {
         std::vector<u8> rgba = texture_download(&frame);

src/ffmpeg.h

@@ -4,6 +4,8 @@
 #include "texture.h"
 
 #define FFMPEG_POPEN_ERROR "popen() (for FFmpeg) failed!\n{}"
+#define FFMPEG_LOG_BUFFER_SIZE 256
+#define FFMPEG_LOG_PATH "ffmpeg.txt"
 
 static constexpr const char* FFMPEG_GIF_FORMAT =
 "\"{0}\" -y "

src/generate_preview.cpp

@@ -26,23 +26,21 @@ void generate_preview_draw(GeneratePreview* self)
     canvas_clear(self->settings->previewBackgroundColor);
  
     Anm2Item* item = anm2_item_from_reference(self->anm2, self->reference);
-    Texture* texture = map_find(self->resources->textures, self->anm2->layers[self->reference->itemID].spritesheetID);
+    Texture& texture = self->anm2->spritesheets[self->anm2->layers[self->reference->itemID].spritesheetID].texture;
         
-    if (item && texture && !texture->isInvalid)
+    if (item && !texture.isInvalid)
     {
         const s32 index = std::clamp((s32)(self->time * count), 0, count);
         const s32 row = index / columns;
         const s32 column = index % columns;
         vec2 crop = startPosition + vec2(size.x * column, size.y * row);
 
-        vec2 uvMin = crop / vec2(texture->size);
+        vec2 uvMin = crop / vec2(texture.size);
-        vec2 uvMax = (crop + size) / vec2(texture->size);
+        vec2 uvMax = (crop + size) / vec2(texture.size);
         f32 vertices[] = UV_VERTICES(uvMin, uvMax);
 
-        mat4 model = quad_model_get(size, {}, pivot, {}, CANVAS_SCALE_DEFAULT);
+        mat4 generateTransform = transform * canvas_model_get(size, {}, pivot);
-        mat4 generateTransform = transform * model;
+        canvas_texture_draw(&self->canvas, shaderTexture, texture.id, generateTransform, vertices, COLOR_OPAQUE, COLOR_OFFSET_NONE);
-
-        canvas_texture_draw(&self->canvas, shaderTexture, texture->id, generateTransform, vertices, COLOR_OPAQUE, COLOR_OFFSET_NONE);
     }
     
     canvas_unbind();

src/imgui.cpp

@@ -19,11 +19,11 @@ static bool _imgui_window_color_from_position_get(SDL_Window* self, const vec2&
     return true;
 }
 
-static void _imgui_anm2_new(Imgui* self, const std::string& path)
+static void _imgui_anm2_open(Imgui* self, const std::string& path)
 {
-	*self->reference = Anm2Reference{};
+	imgui_file_new(self);
-	resources_textures_free(self->resources);
+
-	if (anm2_deserialize(self->anm2, self->resources, path))
+	if (anm2_deserialize(self->anm2, path))
 	{
 		window_title_from_path_set(self->window, path);
 		snapshots_reset(self->snapshots);
@@ -36,13 +36,18 @@ static void _imgui_anm2_new(Imgui* self, const std::string& path)
 static void _imgui_spritesheet_add(Imgui* self, const std::string& path)
 {
 	std::filesystem::path workingPath = std::filesystem::current_path();
-	std::string anm2WorkingPath = working_directory_from_file_set(self->anm2->path);
+	std::string spritesheetPath = path;
-	std::string spritesheetPath = std::filesystem::relative(path, anm2WorkingPath).string();
 
-	s32 id = map_next_id_get(self->resources->textures);
+	if (!self->anm2->path.empty())
+	{
+		std::string anm2WorkingPath = working_directory_from_file_set(self->anm2->path);
+		spritesheetPath = std::filesystem::relative(path, anm2WorkingPath).string();
+	}
+
+	s32 id = map_next_id_get(self->anm2->spritesheets);
 	self->anm2->spritesheets[id] = Anm2Spritesheet{};
 	self->anm2->spritesheets[id].path = spritesheetPath;
-	resources_texture_init(self->resources, spritesheetPath, id);
+	texture_from_path_init(&self->anm2->spritesheets[id].texture, spritesheetPath);
 	
 	std::filesystem::current_path(workingPath);
 }
@@ -202,7 +207,7 @@ static void _imgui_item_post(const ImguiItem& self, Imgui* imgui, ImguiItemType
 	if (isActivated)
 	{
 		if (self.is_undoable()) 
-			imgui_undo_push(imgui, self.undoAction);
+			imgui_snapshot(imgui, self.snapshotAction);
 
 		if (self.function) self.function(imgui);
 
@@ -528,12 +533,16 @@ IMGUI_ITEM_ATLAS_FUNCTION(_imgui_atlas_selectable, _imgui_selectable(self, imgui
 IMGUI_ITEM_ATLAS_VALUE_FUNCTION(_imgui_atlas_selectable_input_int, s32, _imgui_selectable_input_int(self, imgui, value));
 IMGUI_ITEM_ATLAS_VALUE_FUNCTION(_imgui_atlas_selectable_input_text, std::string, _imgui_selectable_input_text(self, imgui, value));
 
-static bool _imgui_option_popup(ImguiItem self, Imgui* imgui)
+static bool _imgui_option_popup(ImguiItem self, Imgui* imgui, ImguiPopupState* state = nullptr)
 {
 	ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
 	
+	if (state) *state = IMGUI_POPUP_STATE_CLOSED;
+
 	if (imgui_begin_popup_modal(self.label_get(), imgui))
 	{
+		if (state) *state = IMGUI_POPUP_STATE_OPEN;
+		
 		ImGui::Text(self.text_get());
 		ImGui::Separator();
 
@@ -541,13 +550,17 @@ static bool _imgui_option_popup(ImguiItem self, Imgui* imgui)
 		{
 			imgui_close_current_popup(imgui);
 			imgui_end_popup(imgui);
+			if (state) *state = IMGUI_POPUP_STATE_CONFIRM;
 			return true;
 		}
 
 		ImGui::SameLine();
 		
 		if (_imgui_button(IMGUI_POPUP_CANCEL, imgui))
+		{
 			imgui_close_current_popup(imgui);
+			if (state) *state = IMGUI_POPUP_STATE_CANCEL;
+		}
 
 		imgui_end_popup(imgui);
 	}
@@ -658,7 +671,7 @@ static void _imgui_timeline(Imgui* self)
 		if (ImGui::IsMouseDown(0) && _imgui_is_window_hovered()) 
 		{
 			if (!isPlayheadDrag)
-				imgui_undo_push(self, IMGUI_ACTION_MOVE_PLAYHEAD);
+				imgui_snapshot(self, IMGUI_ACTION_MOVE_PLAYHEAD);
 			isPlayheadDrag = true;
 		}
 
@@ -970,6 +983,12 @@ static void _imgui_timeline(Imgui* self)
 
 		std::function<void(s32, Anm2Frame&)> timeline_item_frame = [&](s32 i, Anm2Frame& frame)
 		{
+			static s32 frameDelayStart{};
+			static f32 frameDelayTimeStart{};
+			const bool isModCtrl = ImGui::IsKeyDown(IMGUI_INPUT_CTRL);
+			static Anm2Frame* draggingFrame = nullptr;
+			static Anm2Type draggingFrameType = ANM2_NONE;
+
 			ImGui::PushID(i);
 			reference.frameIndex = i;
 			ImVec2 framePos = ImGui::GetCursorPos();
@@ -986,8 +1005,7 @@ static void _imgui_timeline(Imgui* self)
 
 			ImGui::SetCursorPos(framePos);
 			
-			if (_imgui_atlas_button(frameButton, self))
+			if (_imgui_atlas_button(frameButton, self)) *self->reference = reference;
-				*self->reference = reference;
 
 			if (ImGui::IsItemHovered())
 			{
@@ -995,23 +1013,47 @@ static void _imgui_timeline(Imgui* self)
 				_imgui_clipboard_hovered_item_set(self, frameWithReference);
 			}
 
-			if (type == ANM2_TRIGGERS)
+			if (ImGui::IsItemActivated())
 			{
-				if (ImGui::IsItemActivated()) imgui_undo_push(self, IMGUI_ACTION_TRIGGER_MOVE);
+				if (type == ANM2_TRIGGERS || isModCtrl)
+				{
+					draggingFrame = &frame;
+					draggingFrameType = type;
+					*self->reference = reference;
+				}
 
-				if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_SourceNoPreviewTooltip))
+				if (type == ANM2_TRIGGERS)
+					imgui_snapshot(self, IMGUI_ACTION_TRIGGER_MOVE);
+				else if (isModCtrl)
 				{
-					frame.atFrame = std::max(frameTime, 0);
+					imgui_snapshot(self, IMGUI_ACTION_FRAME_DELAY);
+					frameDelayStart = draggingFrame->delay;
+					frameDelayTimeStart = frameTime;
+				}
+			}
+
+			if (draggingFrame)
+			{
+				if (draggingFrameType == ANM2_TRIGGERS)
+				{
+					draggingFrame->atFrame = std::max(frameTime, 0);
 					for (auto& frameCheck : animation->triggers.frames)
 					{
-						if (&frame == &frameCheck) continue;
+						if (draggingFrame == &frameCheck) continue;
-						if (frame.atFrame == frameCheck.atFrame)
+						if (draggingFrame->atFrame == frameCheck.atFrame)
 						{
-							frame.atFrame++;
+							draggingFrame->atFrame++;
 							break;
 						}
 					}
-					ImGui::EndDragDropSource();
+				}
+				else if (isModCtrl)
+					draggingFrame->delay = std::max(frameDelayStart + (s32)(frameTime - frameDelayTimeStart), ANM2_FRAME_NUM_MIN);
+
+				if (ImGui::IsMouseReleased(0))
+				{
+					draggingFrame = nullptr;
+					draggingFrameType = ANM2_NONE;
 				}
 			}
 			else
@@ -1022,7 +1064,6 @@ static void _imgui_timeline(Imgui* self)
 					timeline_item_frame(i, frame);
 					ImGui::EndDragDropSource();
 				}
-			}
 
 				if (ImGui::BeginDragDropTarget())
 				{
@@ -1031,7 +1072,7 @@ static void _imgui_timeline(Imgui* self)
 						Anm2Reference swapReference = *(Anm2Reference*)payload->Data;
 						if (swapReference != reference)
 						{
-						imgui_undo_push(self, IMGUI_ACTION_FRAME_SWAP);
+							imgui_snapshot(self, IMGUI_ACTION_FRAME_SWAP);
 
 							Anm2Frame* swapFrame = anm2_frame_from_reference(self->anm2, &reference);
 							Anm2Frame* dragFrame = anm2_frame_from_reference(self->anm2, &swapReference);
@@ -1049,6 +1090,7 @@ static void _imgui_timeline(Imgui* self)
 					}
 					ImGui::EndDragDropTarget();
 				}
+			}
 					
 			if (i < (s32)item->frames.size() - 1) ImGui::SameLine();
 
@@ -1211,6 +1253,8 @@ static void _imgui_timeline(Imgui* self)
 
 static void _imgui_taskbar(Imgui* self)
 {
+	static ImguiPopupState exitConfirmState = IMGUI_POPUP_STATE_CLOSED;
+
 	ImGuiViewport* viewport = ImGui::GetMainViewport();
 	ImguiItem taskbar = IMGUI_TASKBAR;
 	ImGui::SetNextWindowSize({viewport->Size.x, IMGUI_TASKBAR.size.y});
@@ -1235,7 +1279,7 @@ static void _imgui_taskbar(Imgui* self)
 
 	if (self->dialog->isSelected && self->dialog->type == DIALOG_ANM2_OPEN)
 	{
-		_imgui_anm2_new(self, self->dialog->path);
+		_imgui_anm2_open(self, self->dialog->path);
 		dialog_reset(self->dialog);
 	}			
 
@@ -1249,10 +1293,15 @@ static void _imgui_taskbar(Imgui* self)
 
 	if (self->isTryQuit) imgui_open_popup(IMGUI_EXIT_CONFIRMATION.label);
 
-	if (_imgui_option_popup(IMGUI_EXIT_CONFIRMATION, self))
+	_imgui_option_popup(IMGUI_EXIT_CONFIRMATION, self, &exitConfirmState);
-		self->isQuit = true;
+
-	else
+	switch (exitConfirmState)
-		self->isTryQuit = false;
+	{
+		case IMGUI_POPUP_STATE_CLOSED: self->isTryQuit = false; break;
+		case IMGUI_POPUP_STATE_OPEN: self->isTryQuit = true; break;
+		case IMGUI_POPUP_STATE_CONFIRM: self->isQuit = true; break;
+		case IMGUI_POPUP_STATE_CANCEL: self->isTryQuit = false; break;
+	}
 
 	_imgui_selectable(IMGUI_WIZARD.copy({}), self);
 	
@@ -1292,7 +1341,7 @@ static void _imgui_taskbar(Imgui* self)
 		_imgui_begin_child(IMGUI_GENERATE_ANIMATION_FROM_GRID_PREVIEW_CHILD, self);
 		
 		generate_preview_draw(self->generatePreview);
-		ImGui::Image(self->generatePreview->canvas.texture, GENERATE_PREVIEW_SIZE);
+		ImGui::Image(self->generatePreview->canvas.framebuffer, GENERATE_PREVIEW_SIZE);
 
 		_imgui_begin_child(IMGUI_GENERATE_ANIMATION_FROM_GRID_SLIDER_CHILD, self);
 		_imgui_slider_float(IMGUI_GENERATE_ANIMATION_FROM_GRID_SLIDER, self, time);
@@ -1686,7 +1735,7 @@ static void _imgui_animations(Imgui* self)
 				s32 sourceID = *(s32*)payload->Data;
 				if (sourceID != id)
 				{
-					imgui_undo_push(self, IMGUI_ACTION_ANIMATION_SWAP);
+					imgui_snapshot(self, IMGUI_ACTION_ANIMATION_SWAP);
 					map_swap(self->anm2->animations, sourceID, id);
 				}
 			}
@@ -1919,7 +1968,7 @@ static void _imgui_spritesheets(Imgui* self)
 	{
 		ImGui::PushID(id);
 		
-		Texture* texture = &self->resources->textures[id];
+		Texture& texture = spritesheet.texture;
 		bool isContains = selectedIDs.contains(id);
 		
 		_imgui_begin_child(IMGUI_SPRITESHEET_CHILD, self);
@@ -1948,26 +1997,23 @@ static void _imgui_spritesheets(Imgui* self)
 			{
 				s32 sourceID = *(s32*)payload->Data;
 				if (sourceID != id)
-				{
 					map_swap(self->anm2->spritesheets, sourceID, id);
-					map_swap(self->resources->textures, sourceID, id);
-				}
 			}
 			ImGui::EndDragDropTarget();
 		}
 
 		ImVec2 spritesheetPreviewSize = IMGUI_SPRITESHEET_PREVIEW_SIZE;
-		f32 spritesheetAspect = (f32)self->resources->textures[id].size.x / self->resources->textures[id].size.y;
+		f32 spritesheetAspect = (f32)texture.size.x / texture.size.y;
 
 		if ((IMGUI_SPRITESHEET_PREVIEW_SIZE.x / IMGUI_SPRITESHEET_PREVIEW_SIZE.y) > spritesheetAspect)
 			spritesheetPreviewSize.x = IMGUI_SPRITESHEET_PREVIEW_SIZE.y * spritesheetAspect;
 		else
 			spritesheetPreviewSize.y = IMGUI_SPRITESHEET_PREVIEW_SIZE.x / spritesheetAspect;
 
-		if (texture->isInvalid)
+		if (texture.isInvalid)
 			_imgui_atlas(ATLAS_NONE, self);
 		else
-			ImGui::Image(texture->id, spritesheetPreviewSize);
+			ImGui::Image(texture.id, spritesheetPreviewSize);
 			
 		_imgui_end_child(); // IMGUI_SPRITESHEET_CHILD
 
@@ -1992,11 +2038,16 @@ static void _imgui_spritesheets(Imgui* self)
 	
 	if (_imgui_button(IMGUI_SPRITESHEETS_RELOAD.copy({selectedIDs.empty()}), self))
 	{
+		if (selectedIDs.size() > 0) 
+			imgui_snapshot(self, IMGUI_ACTION_RELOAD_SPRITESHEET);
+
 		for (auto& id : selectedIDs)
 		{
 			std::filesystem::path workingPath = std::filesystem::current_path();
 			working_directory_from_file_set(self->anm2->path);
-			resources_texture_init(self->resources, self->anm2->spritesheets[id].path, id);
+			Texture texture;
+			texture_from_path_init(&texture, self->anm2->spritesheets[id].path);
+			self->anm2->spritesheets[id].texture = texture;
 			std::filesystem::current_path(workingPath);
 		}
 	}
@@ -2006,14 +2057,17 @@ static void _imgui_spritesheets(Imgui* self)
 
 	if (self->dialog->isSelected && self->dialog->type == DIALOG_SPRITESHEET_REPLACE)
 	{
+		imgui_snapshot(self, IMGUI_ACTION_REPLACE_SPRITESHEET);
+		
 		std::filesystem::path workingPath = std::filesystem::current_path();
 		std::string anm2WorkingPath = working_directory_from_file_set(self->anm2->path);
 		std::string spritesheetPath = std::filesystem::relative(self->dialog->path, anm2WorkingPath).string();
 	
 		self->anm2->spritesheets[self->dialog->replaceID].path = spritesheetPath;
-		resources_texture_init(self->resources, spritesheetPath, self->dialog->replaceID);
+		Texture texture;
+		texture_from_path_init(&texture, spritesheetPath);
+		self->anm2->spritesheets[self->dialog->replaceID].texture = texture; 
 		dialog_reset(self->dialog);
-
 		std::filesystem::current_path(workingPath);
 	}
 
@@ -2029,8 +2083,8 @@ static void _imgui_spritesheets(Imgui* self)
 		{
 			if (!usedSpritesheetIDs.count(it->first))
 			{
+				texture_free(&self->anm2->spritesheets[it->first].texture);
 				it = self->anm2->spritesheets.erase(it);
-				texture_free(&self->resources->textures[it->first]);
 			}
 			else
 				it++;
@@ -2048,12 +2102,11 @@ static void _imgui_spritesheets(Imgui* self)
 	{
 		for (auto& id : selectedIDs)
 		{
-			Anm2Spritesheet* spritesheet = &self->anm2->spritesheets[id];
+			Anm2Spritesheet& spritesheet = self->anm2->spritesheets[id];
-			Texture* texture = &self->resources->textures[id];
 			std::filesystem::path workingPath = std::filesystem::current_path();
 			working_directory_from_file_set(self->anm2->path);
-			texture_from_gl_write(texture, spritesheet->path);
+			texture_from_gl_write(&spritesheet.texture, spritesheet.path);
-			imgui_log_push(self, std::format(IMGUI_LOG_SPRITESHEET_SAVE_FORMAT, id, spritesheet->path));
+			imgui_log_push(self, std::format(IMGUI_LOG_SPRITESHEET_SAVE_FORMAT, id, spritesheet.path));
 			std::filesystem::current_path(workingPath);
 		}
 	}
@@ -2072,7 +2125,6 @@ static void _imgui_animation_preview(Imgui* self)
 	static ivec2& size = self->preview->canvas.size;
 	static vec2 mousePos{};
 	static vec2 previewPos{};
-	static ImVec2 previewScreenPos{};
 
 	std::string mousePositionString = std::format(IMGUI_POSITION_FORMAT, (s32)mousePos.x, (s32)mousePos.y);
 	
@@ -2138,13 +2190,10 @@ static void _imgui_animation_preview(Imgui* self)
 	_imgui_checkbox(IMGUI_CANVAS_BORDER, self, self->settings->previewIsBorder);
 	_imgui_end_child(); // IMGUI_CANVAS_HELPER_CHILD
 
-	previewPos = vec2(ImGui::GetCursorPos());
+	ImVec2 previewCursorScreenPos = ImGui::GetCursorScreenPos();
-	previewScreenPos = vec2(ImGui::GetCursorScreenPos());
+	size = ivec2(vec2(ImGui::GetContentRegionAvail()));
-	
-	vec2 imageSize = ImGui::GetContentRegionAvail();
-	size = ivec2(imageSize);
 	preview_draw(self->preview);
-	ImGui::Image(self->preview->canvas.texture, imageSize);
+	ImGui::Image(self->preview->canvas.framebuffer, vec2(size));
 	
 	if (self->settings->previewIsTriggers)
 	{
@@ -2154,7 +2203,7 @@ static void _imgui_animation_preview(Imgui* self)
 		if (trigger.eventID != ID_NONE)
 		{
 			f32 textScale = ImGui::GetCurrentWindow()->FontWindowScale;
-			ImVec2 textPos = previewScreenPos + ImGui::GetStyle().ItemSpacing;
+			ImVec2 textPos = previewCursorScreenPos + ImGui::GetStyle().ItemSpacing;
 			ImGui::SetWindowFontScale(IMGUI_TRIGGERS_FONT_SCALE);
 			ImGui::GetWindowDrawList()->AddText(textPos, IMGUI_TRIGGERS_EVENT_COLOR, self->anm2->events[trigger.eventID].name.c_str());
 			ImGui::SetWindowFontScale(textScale);
@@ -2171,7 +2220,7 @@ static void _imgui_animation_preview(Imgui* self)
 
 	_imgui_end(); // IMGUI_ANIMATION_PREVIEW
 
-	mousePos = (vec2((ImGui::GetMousePos()) - (ImGui::GetWindowPos() + previewPos)) - (imageSize * 0.5f) - pan) / PERCENT_TO_UNIT(zoom);
+	mousePos = vec2(ImGui::GetMousePos() - previewCursorScreenPos - pan - (vec2(size) * 0.5f)) / PERCENT_TO_UNIT(zoom);
 	
 	const bool isLeft = ImGui::IsKeyPressed(IMGUI_INPUT_LEFT);
 	const bool isRight = ImGui::IsKeyPressed(IMGUI_INPUT_RIGHT);
@@ -2188,7 +2237,7 @@ static void _imgui_animation_preview(Imgui* self)
 	
 	if (tool == TOOL_MOVE || tool == TOOL_SCALE || tool == TOOL_ROTATE)
 		if (isMouseClick || isLeft || isRight || isUp || isDown)
-			imgui_undo_push(self, IMGUI_ACTION_FRAME_TRANSFORM);
+			imgui_snapshot(self, IMGUI_ACTION_FRAME_TRANSFORM);
 	
 	if ((tool == TOOL_PAN && isMouseDown) || isMouseMiddleDown)
 		pan += vec2(mouseDelta.x, mouseDelta.y);
@@ -2288,11 +2337,10 @@ static void _imgui_spritesheet_editor(Imgui* self)
 	_imgui_checkbox(IMGUI_CANVAS_BORDER, self, self->settings->editorIsBorder);
 	_imgui_end_child(); // IMGUI_CANVAS_VISUAL_CHILD
 	
-	ImVec2 editorPos = ImGui::GetCursorPos();
+	ImVec2 editorCursorScreenPos = ImGui::GetCursorScreenPos();
-	vec2 imageSize = ImGui::GetContentRegionAvail();
+	size = ivec2(vec2(ImGui::GetContentRegionAvail()));
-	size = ivec2(imageSize);
 	editor_draw(self->editor);
-	ImGui::Image(self->editor->canvas.texture, imageSize);
+	ImGui::Image(self->editor->canvas.framebuffer, vec2(size));
 	
 	if (ImGui::IsItemHovered()) 
 		self->pendingCursor = TOOL_CURSORS[tool];
@@ -2304,7 +2352,7 @@ static void _imgui_spritesheet_editor(Imgui* self)
 
 	_imgui_end(); // IMGUI_SPRITESHEET_EDITOR
 
-	mousePos = (vec2((ImGui::GetMousePos()) - (ImGui::GetWindowPos() + editorPos)) - pan) / PERCENT_TO_UNIT(zoom);
+	mousePos = vec2(ImGui::GetMousePos() - editorCursorScreenPos - pan) / PERCENT_TO_UNIT(zoom);
 
 	const bool isMouseClick = ImGui::IsMouseClicked(ImGuiMouseButton_Left);
 	const bool isMouseDown = ImGui::IsMouseDown(ImGuiMouseButton_Left);
@@ -2322,7 +2370,8 @@ static void _imgui_spritesheet_editor(Imgui* self)
 	if (self->reference->itemType == ANM2_LAYER) 
 		frame = anm2_frame_from_reference(self->anm2, self->reference);
 
-	Texture* texture = map_find(self->resources->textures, self->editor->spritesheetID);
+	Anm2Spritesheet* spritesheet = map_find(self->anm2->spritesheets, self->editor->spritesheetID);
+	Texture* texture = spritesheet ? &spritesheet->texture : nullptr;
 
 	vec2 position = mousePos;
 
@@ -2333,16 +2382,13 @@ static void _imgui_spritesheet_editor(Imgui* self)
 
 			if (self->settings->editorIsGridSnap)
 			{
-				position = 
+				position.x = roundf(position.x / gridSize.x) * gridSize.x + gridOffset.x - (gridSize.x * 0.5f);
-				{
+				position.y = roundf(position.y / gridSize.y) * gridSize.y + gridOffset.y - (gridSize.y * 0.5f);
-					(s32)((position.x - gridOffset.x) / gridSize.x) * gridSize.x + gridOffset.x,
-					(s32)((position.y - gridOffset.y) / gridSize.y) * gridSize.y + gridOffset.y
-				};
 			}
 			
 			if (isMouseClick)
 			{
-				imgui_undo_push(self, IMGUI_ACTION_FRAME_CROP);
+				imgui_snapshot(self, IMGUI_ACTION_FRAME_CROP);
 				frame->crop = position;
 				frame->size = ivec2(0,0);
 			}
@@ -2352,9 +2398,13 @@ static void _imgui_spritesheet_editor(Imgui* self)
 		case TOOL_DRAW:
 		case TOOL_ERASE:
 		{
-			if (!frame || !texture) break;
+			if (!texture) break;
+			
 			vec4 color = tool == TOOL_ERASE ? COLOR_TRANSPARENT : toolColor;
 			
+			if (isMouseClick)
+				imgui_snapshot(self, IMGUI_ACTION_DRAW);
+
 			if (isMouseDown)
 				texture_pixel_set(texture, position, color);
 			break;
@@ -2562,7 +2612,7 @@ void imgui_update(Imgui* self)
 		{
 			if (ImGui::IsKeyChordPressed(hotkey.chord))
 			{
-				if (hotkey.is_undoable()) imgui_undo_push(self, hotkey.undoAction);
+				if (hotkey.is_undoable()) imgui_snapshot(self, hotkey.snapshotAction);
 				if (hotkey.is_focus_window()) continue;
 				hotkey.function(self);
 			}
@@ -2590,9 +2640,11 @@ void imgui_update(Imgui* self)
             	const char* droppedFile = event.drop.data;
             	
 				if (path_is_extension(droppedFile, ANM2_EXTENSION))  
-					_imgui_anm2_new(self, droppedFile);
+					_imgui_anm2_open(self, droppedFile);
 				else if (path_is_extension(droppedFile, ANM2_SPRITESHEET_EXTENSION))
 					_imgui_spritesheet_add(self, droppedFile);
+				else
+					imgui_log_push(self, IMGUI_LOG_DRAG_DROP_ERROR);
             	
 				break;
 			}

src/imgui.h

@@ -66,13 +66,18 @@
 #define IMGUI_ACTION_FRAME_TRANSFORM "Frame Transform"
 #define IMGUI_ACTION_ANIMATION_SWAP "Animation Swap"
 #define IMGUI_ACTION_TRIGGER_MOVE "Trigger AtFrame"
+#define IMGUI_ACTION_FRAME_DELAY "Frame Delay"
 #define IMGUI_ACTION_MOVE_PLAYHEAD "Move Playhead"
+#define IMGUI_ACTION_DRAW "Draw"
+#define IMGUI_ACTION_RELOAD_SPRITESHEET "Reload Spritesheet(s)"
+#define IMGUI_ACTION_REPLACE_SPRITESHEET "Replace Spritesheet"
 
 #define IMGUI_POPUP_FLAGS ImGuiWindowFlags_NoMove
 #define IMGUI_POPUP_MODAL_FLAGS ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize
 
 #define IMGUI_LOG_FILE_OPEN_FORMAT "Opened anm2: {}" 
 #define IMGUI_LOG_FILE_SAVE_FORMAT "Saved anm2 to: {}" 
+#define IMGUI_LOG_SPRITESHEET_RELOAD "Reloaded selected spritesheets"
 #define IMGUI_LOG_RENDER_ANIMATION_FRAMES_SAVE_FORMAT "Saved rendered frames to: {}" 
 #define IMGUI_LOG_RENDER_ANIMATION_SAVE_FORMAT "Saved rendered animation to: {}" 
 #define IMGUI_LOG_RENDER_ANIMATION_NO_ANIMATION_ERROR "No animation selected; rendering cancelled."
@@ -82,6 +87,7 @@
 #define IMGUI_LOG_RENDER_ANIMATION_FFMPEG_PATH_ERROR "Invalid FFmpeg path! Make sure you have it installed and the path is correct."
 #define IMGUI_LOG_RENDER_ANIMATION_FFMPEG_ERROR "FFmpeg could not render animation! Check paths or your FFmpeg installation."
 #define IMGUI_LOG_SPRITESHEET_SAVE_FORMAT "Saved spritesheet #{} to: {}" 
+#define IMGUI_LOG_DRAG_DROP_ERROR "Invalid file for dragging/dropping!"
 
 #define IMGUI_NONE "None"
 #define IMGUI_ANIMATION_DEFAULT_FORMAT "(*) {}"
@@ -145,6 +151,14 @@ enum ImguiPopupType
     IMGUI_POPUP_CENTER_WINDOW
 };
 
+enum ImguiPopupState
+{
+    IMGUI_POPUP_STATE_CLOSED,
+    IMGUI_POPUP_STATE_OPEN,
+    IMGUI_POPUP_STATE_CONFIRM,
+    IMGUI_POPUP_STATE_CANCEL
+};
+
 struct ImguiColorSet 
 {
     ImVec4 normal{};
@@ -197,16 +211,16 @@ struct ImguiHotkey
     ImGuiKeyChord chord;
     ImguiFunction function;
     std::string focusWindow{};
-    std::string undoAction{};
+    std::string snapshotAction{};
 
     bool is_focus_window() const { return !focusWindow.empty(); }
-    bool is_undoable() const { return !undoAction.empty(); }
+    bool is_undoable() const { return !snapshotAction.empty(); }
 };
 
 static void imgui_log_push(Imgui* self, const std::string& text)
 {
     self->log.push_back({text, IMGUI_LOG_DURATION});
-    std::println("[IMGUI] {}", text);
+    log_imgui(text);
 }
 
 static std::vector<ImguiHotkey>& imgui_hotkey_registry()
@@ -218,8 +232,8 @@ static std::vector<ImguiHotkey>& imgui_hotkey_registry()
 static inline void imgui_file_new(Imgui* self)
 {
     anm2_reference_clear(self->reference);
+    anm2_free(self->anm2);
 	anm2_new(self->anm2);
-    resources_textures_free(self->resources);
 }
 
 static inline void imgui_file_open(Imgui* self)
@@ -258,9 +272,9 @@ static inline void imgui_explore(Imgui* self)
     dialog_explorer_open(parentPath.string());
 }
 
-static inline void imgui_undo_push(Imgui* self, const std::string& action = SNAPSHOT_ACTION)
+static inline void imgui_snapshot(Imgui* self, const std::string& action = SNAPSHOT_ACTION)
 {
-    Snapshot snapshot = {*self->anm2, *self->reference, self->preview->time, action};
+    Snapshot snapshot = snapshot_get(self->snapshots);
     snapshots_undo_push(self->snapshots, &snapshot);
 }
 
@@ -467,7 +481,7 @@ struct ImguiItem
     std::string label{};
     std::string tooltip{};
     std::string& text = tooltip;
-    std::string undoAction{};
+    std::string snapshotAction{};
     std::string popup{};
     std::string dragDrop{};
     std::string focusWindow{};
@@ -515,7 +529,7 @@ struct ImguiItem
                 label += std::format(IMGUI_LABEL_SHORTCUT_FORMAT, chordString);
             tooltip += std::format(IMGUI_TOOLTIP_SHORTCUT_FORMAT, chordString);
             if (function)
-                imgui_hotkey_registry().push_back({chord, function, focusWindow, undoAction});
+                imgui_hotkey_registry().push_back({chord, function, focusWindow, snapshotAction});
         }
 
         std::string labelNew{};
@@ -569,7 +583,7 @@ struct ImguiItem
     bool is_size() const { return size != ImVec2(); }
     bool is_popup_size() const { return popupSize != ImVec2(); }
     bool is_tooltip() const { return !tooltip.empty(); }
-    bool is_undoable() const { return !undoAction.empty(); }
+    bool is_undoable() const { return !snapshotAction.empty(); }
     bool is_mnemonic() const { return mnemonicKey != ImGuiKey_None; }
     bool is_range() const { return min != 0 || max != 0; }
     const char* label_get() const { return label.c_str(); }
@@ -602,7 +616,7 @@ IMGUI_ITEM(IMGUI_FOOTER_CHILD,
 );
 
 IMGUI_ITEM(IMGUI_TASKBAR,
-    self.label = "## Taskbar",
+    self.label = "Taskbar",
     self.size = {0, 32},
     self.flags = ImGuiWindowFlags_NoTitleBar        |
                  ImGuiWindowFlags_NoResize          |
@@ -783,7 +797,7 @@ IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_SLIDER,
 IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_GENERATE,
     self.label = "Generate",
     self.tooltip = "Generate an animation with the used settings.",
-    self.undoAction = "Generate Animation from Grid",
+    self.snapshotAction = "Generate Animation from Grid",
     self.rowCount = IMGUI_OPTION_POPUP_ROW_COUNT,
     self.isSameLine = true
 );
@@ -836,7 +850,7 @@ IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_NUMBER_FRAMES,
 IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_ADD,
     self.label = "Add",
     self.tooltip = "The specified values will be added to all specified frames.",
-    self.undoAction = "Add Frame Properties",
+    self.snapshotAction = "Add Frame Properties",
     self.rowCount = IMGUI_CHANGE_ALL_FRAME_PROPERTIES_OPTIONS_ROW_COUNT,
     self.isSameLine = true
 );
@@ -844,7 +858,7 @@ IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_ADD,
 IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_SUBTRACT,
     self.label = "Subtract",
     self.tooltip = "The specified values will be added to all selected frames.",
-    self.undoAction = "Subtract Frame Properties",
+    self.snapshotAction = "Subtract Frame Properties",
     self.rowCount = IMGUI_CHANGE_ALL_FRAME_PROPERTIES_OPTIONS_ROW_COUNT,
     self.isSameLine = true
 );
@@ -852,7 +866,7 @@ IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_SUBTRACT,
 IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_SET,
     self.label = "Set",
     self.tooltip = "The specified values will be set to the specified value in selected frames.",
-    self.undoAction = "Set Frame Properties",
+    self.snapshotAction = "Set Frame Properties",
     self.rowCount = IMGUI_CHANGE_ALL_FRAME_PROPERTIES_OPTIONS_ROW_COUNT,
     self.isSameLine = true
 );
@@ -890,7 +904,7 @@ IMGUI_ITEM(IMGUI_SCALE_ANM2_VALUE,
 IMGUI_ITEM(IMGUI_SCALE_ANM2_SCALE,
     self.label = "Scale",
     self.tooltip = "Scale the anm2 with the value specified.",
-    self.undoAction = "Scale Anm2",
+    self.snapshotAction = "Scale Anm2",
     self.rowCount = IMGUI_OPTION_POPUP_ROW_COUNT,
     self.isSameLine = true
 );
@@ -917,7 +931,7 @@ IMGUI_ITEM(IMGUI_RENDER_ANIMATION_LOCATION_BROWSE,
 IMGUI_ITEM(IMGUI_RENDER_ANIMATION_LOCATION,
     self.label = "Location",
     self.tooltip = "Select the location of the rendered animation.",
-    self.max = 255
+    self.max = 1024
 );
 
 IMGUI_ITEM(IMGUI_RENDER_ANIMATION_FFMPEG_BROWSE,
@@ -930,7 +944,7 @@ IMGUI_ITEM(IMGUI_RENDER_ANIMATION_FFMPEG_BROWSE,
 IMGUI_ITEM(IMGUI_RENDER_ANIMATION_FFMPEG_PATH,
     self.label = "FFmpeg Path",
     self.tooltip = "Sets the path FFmpeg currently resides in.\nFFmpeg is required for rendering animations.\nDownload it from https://ffmpeg.org/, your package manager, or wherever else.",
-    self.max = 255
+    self.max = 1024
 );
 
 IMGUI_ITEM(IMGUI_RENDER_ANIMATION_OUTPUT,
@@ -1007,7 +1021,7 @@ IMGUI_ITEM(IMGUI_ANIMATIONS_CHILD, self.label = "## Animations Child", self.flag
 
 IMGUI_ITEM(IMGUI_ANIMATION,
     self.label = "## Animation Item",
-    self.undoAction = "Select Animation",
+    self.snapshotAction = "Select Animation",
     self.dragDrop = "## Animation Drag Drop",
     self.atlas = ATLAS_ANIMATION,
     self.idOffset = 2000
@@ -1017,7 +1031,7 @@ IMGUI_ITEM(IMGUI_ANIMATION,
 IMGUI_ITEM(IMGUI_ANIMATION_ADD,
     self.label = "Add",
     self.tooltip = "Adds a new animation.",
-    self.undoAction = "Add Animation",
+    self.snapshotAction = "Add Animation",
     self.rowCount = IMGUI_ANIMATIONS_OPTIONS_ROW_COUNT,
     self.isSameLine = true
 );
@@ -1025,7 +1039,7 @@ IMGUI_ITEM(IMGUI_ANIMATION_ADD,
 IMGUI_ITEM(IMGUI_ANIMATION_DUPLICATE,
     self.label = "Duplicate",
     self.tooltip = "Duplicates the selected animation, placing it after.",
-    self.undoAction = "Duplicate Animation",
+    self.snapshotAction = "Duplicate Animation",
     self.rowCount = IMGUI_ANIMATIONS_OPTIONS_ROW_COUNT,
     self.isSameLine = true
 );
@@ -1093,7 +1107,7 @@ IMGUI_ITEM(IMGUI_MERGE_DELETE_ANIMATIONS_AFTER,
 IMGUI_ITEM(IMGUI_MERGE_CONFIRM,
     self.label = "Merge",
     self.tooltip = "Merge the selected animations with the options set.",
-    self.undoAction = "Merge Animations",
+    self.snapshotAction = "Merge Animations",
     self.rowCount = IMGUI_OPTION_POPUP_ROW_COUNT,
     self.isSameLine = true
 );
@@ -1101,7 +1115,7 @@ IMGUI_ITEM(IMGUI_MERGE_CONFIRM,
 IMGUI_ITEM(IMGUI_ANIMATION_REMOVE,
     self.label = "Remove",
     self.tooltip = "Remove the selected animation.",
-    self.undoAction = "Remove Animation",
+    self.snapshotAction = "Remove Animation",
     self.rowCount = IMGUI_ANIMATIONS_OPTIONS_ROW_COUNT,
     self.chord = ImGuiKey_Delete,
     self.focusWindow = IMGUI_ANIMATIONS.label,
@@ -1111,7 +1125,7 @@ IMGUI_ITEM(IMGUI_ANIMATION_REMOVE,
 IMGUI_ITEM(IMGUI_ANIMATION_DEFAULT,
     self.label = "Default",
     self.tooltip = "Set the selected animation as the default one.",
-    self.undoAction = "Default Animation",
+    self.snapshotAction = "Default Animation",
     self.rowCount = IMGUI_ANIMATIONS_OPTIONS_ROW_COUNT,
     self.isSameLine = true
 );
@@ -1134,7 +1148,7 @@ IMGUI_ITEM(IMGUI_EVENT,
 IMGUI_ITEM(IMGUI_EVENTS_ADD,
     self.label = "Add",
     self.tooltip = "Adds a new event.",
-    self.undoAction = "Add Event",
+    self.snapshotAction = "Add Event",
     self.rowCount = IMGUI_EVENTS_OPTIONS_ROW_COUNT,
     self.isSameLine = true
 );
@@ -1142,7 +1156,7 @@ IMGUI_ITEM(IMGUI_EVENTS_ADD,
 IMGUI_ITEM(IMGUI_EVENTS_REMOVE_UNUSED,
     self.label = "Remove Unused",
     self.tooltip = "Removes all unused events (i.e., not being used in any triggers in any animation).",
-    self.undoAction = "Remove Unused Events",
+    self.snapshotAction = "Remove Unused Events",
     self.rowCount = IMGUI_EVENTS_OPTIONS_ROW_COUNT
 );
 
@@ -1188,6 +1202,7 @@ IMGUI_ITEM(IMGUI_SPRITESHEET_ADD,
 IMGUI_ITEM(IMGUI_SPRITESHEETS_RELOAD,
     self.label = "Reload",
     self.tooltip = "Reload the selected spritesheet.",
+    self.snapshotAction = "Reload Spritesheet",
     self.rowCount = IMGUI_SPRITESHEETS_OPTIONS_FIRST_ROW_COUNT,
     self.isSameLine = true
 );
@@ -1364,35 +1379,35 @@ IMGUI_ITEM(IMGUI_FRAME_PROPERTIES, self.label = "Frame Properties");
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_POSITION,
     self.label = "Position",
     self.tooltip = "Change the position of the selected frame.",
-    self.undoAction = "Frame Position",
+    self.snapshotAction = "Frame Position",
     self.isUseItemActivated = true
 );
 
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_CROP,
     self.label = "Crop",
     self.tooltip = "Change the crop position of the selected frame.",
-    self.undoAction = "Frame Crop",
+    self.snapshotAction = "Frame Crop",
     self.isUseItemActivated = true
 );
 
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_SIZE,
     self.label = "Size",
     self.tooltip = "Change the size of the crop of the selected frame.",
-    self.undoAction = "Frame Size",
+    self.snapshotAction = "Frame Size",
     self.isUseItemActivated = true
 );
 
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_PIVOT,
     self.label = "Pivot",
     self.tooltip = "Change the pivot of the selected frame.",
-    self.undoAction = "Frame Pivot",
+    self.snapshotAction = "Frame Pivot",
     self.isUseItemActivated = true
 );
 
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_SCALE,
     self.label = "Scale",
     self.tooltip = "Change the scale of the selected frame.",
-    self.undoAction = "Frame Scale",
+    self.snapshotAction = "Frame Scale",
     self.isUseItemActivated = true,
     self.value = 100
 );
@@ -1400,14 +1415,14 @@ IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_SCALE,
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_ROTATION,
     self.label = "Rotation",
     self.tooltip = "Change the rotation of the selected frame.",
-    self.undoAction = "Frame Rotation",
+    self.snapshotAction = "Frame Rotation",
     self.isUseItemActivated = true
 );
 
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_DELAY,
     self.label = "Duration",
     self.tooltip = "Change the duration of the selected frame.",
-    self.undoAction = "Frame Duration",
+    self.snapshotAction = "Frame Duration",
     self.isUseItemActivated = true,
     self.min = ANM2_FRAME_NUM_MIN,
     self.max = ANM2_FRAME_NUM_MAX,
@@ -1417,7 +1432,7 @@ IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_DELAY,
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_TINT,
     self.label = "Tint",
     self.tooltip = "Change the tint of the selected frame.",
-    self.undoAction = "Frame Tint",
+    self.snapshotAction = "Frame Tint",
     self.isUseItemActivated = true,
     self.value = 1
 );
@@ -1425,7 +1440,7 @@ IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_TINT,
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_COLOR_OFFSET,
     self.label = "Color Offset",
     self.tooltip = "Change the color offset of the selected frame.",
-    self.undoAction = "Frame Color Offset",
+    self.snapshotAction = "Frame Color Offset",
     self.isUseItemActivated = true,
     self.value = 0
 );
@@ -1434,7 +1449,7 @@ const ImVec2 IMGUI_FRAME_PROPERTIES_FLIP_BUTTON_SIZE = {75, 0};
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_FLIP_X,
     self.label = "Flip X",
     self.tooltip = "Change the sign of the X scale, to cheat flipping the layer horizontally.\n(Anm2 doesn't support flipping directly.)",
-    self.undoAction = "Frame Flip X",
+    self.snapshotAction = "Frame Flip X",
     self.size = IMGUI_FRAME_PROPERTIES_FLIP_BUTTON_SIZE,
     self.isSameLine = true
 );
@@ -1442,14 +1457,14 @@ IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_FLIP_X,
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_FLIP_Y,
     self.label = "Flip Y",
     self.tooltip = "Change the sign of the Y scale, to cheat flipping the layer vertically.\n(Anm2 doesn't support flipping directly.)",
-    self.undoAction = "Frame Flip Y",
+    self.snapshotAction = "Frame Flip Y",
     self.size = IMGUI_FRAME_PROPERTIES_FLIP_BUTTON_SIZE 
 );
 
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_VISIBLE,
     self.label = "Visible",
     self.tooltip = "Toggles the visibility of the selected frame.",
-    self.undoAction = "Frame Visibility",
+    self.snapshotAction = "Frame Visibility",
     self.isSameLine = true,
     self.value = true
 );
@@ -1457,20 +1472,20 @@ IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_VISIBLE,
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_INTERPOLATED,
     self.label = "Interpolation",
     self.tooltip = "Toggles the interpolation of the selected frame.",
-    self.undoAction = "Frame Interpolation",
+    self.snapshotAction = "Frame Interpolation",
     self.value = true
 );
 
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_EVENT,
     self.label = "Event",
     self.tooltip = "Change the event the trigger uses.",
-    self.undoAction = "Trigger Event"
+    self.snapshotAction = "Trigger Event"
 );
 
 IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_AT_FRAME,
     self.label = "At Frame",
     self.tooltip = "Change the frame where the trigger occurs.",
-    self.undoAction = "Trigger At Frame"
+    self.snapshotAction = "Trigger At Frame"
 );
 
 IMGUI_ITEM(IMGUI_TOOLS, self.label = "Tools");
@@ -1665,7 +1680,7 @@ IMGUI_ITEM(IMGUI_TIMELINE_ITEM_SELECTABLE,
 IMGUI_ITEM(IMGUI_TIMELINE_ITEM_ROOT_SELECTABLE,
     self.label = "Root",
     self.tooltip = "The root item of an animation.\nChanging its properties will transform the rest of the animation.",
-    self.undoAction = "Root Item Select",
+    self.snapshotAction = "Root Item Select",
     self.atlas = ATLAS_ROOT,
     self.size = IMGUI_TIMELINE_ITEM_SELECTABLE_SIZE
 );
@@ -1673,7 +1688,7 @@ IMGUI_ITEM(IMGUI_TIMELINE_ITEM_ROOT_SELECTABLE,
 IMGUI_ITEM(IMGUI_TIMELINE_ITEM_LAYER_SELECTABLE,
     self.label = "## Layer Selectable",
     self.tooltip = "A layer item.\nA graphical item within the animation.",
-    self.undoAction = "Layer Item Select",
+    self.snapshotAction = "Layer Item Select",
     self.dragDrop = "## Layer Drag Drop",
     self.atlas = ATLAS_LAYER,
     self.size = IMGUI_TIMELINE_ITEM_SELECTABLE_SIZE
@@ -1682,7 +1697,7 @@ IMGUI_ITEM(IMGUI_TIMELINE_ITEM_LAYER_SELECTABLE,
 IMGUI_ITEM(IMGUI_TIMELINE_ITEM_NULL_SELECTABLE,
     self.label = "## Null Selectable",
     self.tooltip = "A null item.\nAn invisible item within the animation that is accessible via a game engine.",
-    self.undoAction = "Null Item Select",
+    self.snapshotAction = "Null Item Select",
     self.dragDrop = "## Null Drag Drop",
     self.atlas = ATLAS_NULL,
     self.size = IMGUI_TIMELINE_ITEM_SELECTABLE_SIZE
@@ -1691,7 +1706,7 @@ IMGUI_ITEM(IMGUI_TIMELINE_ITEM_NULL_SELECTABLE,
 IMGUI_ITEM(IMGUI_TIMELINE_ITEM_TRIGGERS_SELECTABLE,
     self.label = "Triggers",
     self.tooltip = "The animation's triggers.\nWill fire based on an event.",
-    self.undoAction = "Triggers Item Select",
+    self.snapshotAction = "Triggers Item Select",
     self.atlas = ATLAS_TRIGGERS,
     self.size = IMGUI_TIMELINE_ITEM_SELECTABLE_SIZE
 );
@@ -1708,28 +1723,28 @@ const inline ImguiItem* IMGUI_TIMELINE_ITEM_SELECTABLES[ANM2_COUNT]
 IMGUI_ITEM(IMGUI_TIMELINE_ITEM_VISIBLE,
     self.label = "## Visible",
     self.tooltip = "The item is visible.\nPress to set to invisible.",
-    self.undoAction = "Item Invisible",
+    self.snapshotAction = "Item Invisible",
     self.atlas = ATLAS_VISIBLE
 );
 
 IMGUI_ITEM(IMGUI_TIMELINE_ITEM_INVISIBLE,
     self.label = "## Invisible",
     self.tooltip = "The item is invisible.\nPress to set to visible.",
-    self.undoAction = "Item Visible",
+    self.snapshotAction = "Item Visible",
     self.atlas = ATLAS_INVISIBLE
 );
 
 IMGUI_ITEM(IMGUI_TIMELINE_ITEM_SHOW_RECT,
     self.label = "## Show Rect",
     self.tooltip = "The rect is shown.\nPress to hide rect.",
-    self.undoAction = "Hide Rect",
+    self.snapshotAction = "Hide Rect",
     self.atlas = ATLAS_SHOW_RECT
 );
 
 IMGUI_ITEM(IMGUI_TIMELINE_ITEM_HIDE_RECT,
     self.label = "## Hide Rect",
     self.tooltip = "The rect is hidden.\nPress to show rect.",
-    self.undoAction = "Show Rect",
+    self.snapshotAction = "Show Rect",
     self.atlas = ATLAS_HIDE_RECT
 );
 
@@ -1756,7 +1771,7 @@ IMGUI_ITEM(IMGUI_TIMELINE_FRAME, self.label = "## Frame");
 static const vec4 IMGUI_FRAME_BORDER_COLOR = {1.0f, 1.0f, 1.0f, 0.25f};
 IMGUI_ITEM(IMGUI_TIMELINE_ROOT_FRAME,
     self.label = "## Root Frame",
-    self.undoAction = "Root Frame Select",
+    self.snapshotAction = "Root Frame Select",
     self.color = {{0.14f, 0.27f, 0.39f, 1.0f}, {0.28f, 0.54f, 0.78f, 1.0f}, {0.36f, 0.70f, 0.95f, 1.0f}, IMGUI_FRAME_BORDER_COLOR},
     self.size = IMGUI_TIMELINE_FRAME_SIZE,
     self.atlasOffset = IMGUI_TIMELINE_FRAME_ATLAS_OFFSET,
@@ -1765,7 +1780,7 @@ IMGUI_ITEM(IMGUI_TIMELINE_ROOT_FRAME,
 
 IMGUI_ITEM(IMGUI_TIMELINE_LAYER_FRAME,
     self.label = "## Layer Frame",
-    self.undoAction = "Layer Frame Select",
+    self.snapshotAction = "Layer Frame Select",
     self.dragDrop = "## Layer Frame Drag Drop",
     self.color = {{0.45f, 0.18f, 0.07f, 1.0f}, {0.78f, 0.32f, 0.12f, 1.0f}, {0.95f, 0.40f, 0.15f, 1.0f}, IMGUI_FRAME_BORDER_COLOR},
     self.size = IMGUI_TIMELINE_FRAME_SIZE,
@@ -1775,7 +1790,7 @@ IMGUI_ITEM(IMGUI_TIMELINE_LAYER_FRAME,
 
 IMGUI_ITEM(IMGUI_TIMELINE_NULL_FRAME,
     self.label = "## Null Frame",
-    self.undoAction = "Null Frame Select",
+    self.snapshotAction = "Null Frame Select",
     self.dragDrop = "## Null Frame Drag Drop",
     self.color = {{0.17f, 0.33f, 0.17f, 1.0f}, {0.34f, 0.68f, 0.34f, 1.0f}, {0.44f, 0.88f, 0.44f, 1.0f}, IMGUI_FRAME_BORDER_COLOR},
     self.size = IMGUI_TIMELINE_FRAME_SIZE,
@@ -1785,7 +1800,7 @@ IMGUI_ITEM(IMGUI_TIMELINE_NULL_FRAME,
 
 IMGUI_ITEM(IMGUI_TIMELINE_TRIGGERS_FRAME,
     self.label = "## Triggers Frame",
-    self.undoAction = "Trigger Select",
+    self.snapshotAction = "Trigger Select",
     self.color = {{0.36f, 0.14f, 0.24f, 1.0f}, {0.72f, 0.28f, 0.48f, 1.0f}, {0.92f, 0.36f, 0.60f, 1.0f}, IMGUI_FRAME_BORDER_COLOR},
     self.size = IMGUI_TIMELINE_FRAME_SIZE,
     self.atlasOffset = IMGUI_TIMELINE_FRAME_ATLAS_OFFSET,
@@ -1825,21 +1840,21 @@ IMGUI_ITEM(IMGUI_TIMELINE_ADD_ITEM,
 IMGUI_ITEM(IMGUI_TIMELINE_ADD_ITEM_LAYER,
     self.label = "Layer",
     self.tooltip = "Adds a layer item.\nA layer item is a primary graphical item, using a spritesheet.",
-    self.undoAction = "Add Layer",
+    self.snapshotAction = "Add Layer",
     self.isSizeToText = true
 );
 
 IMGUI_ITEM(IMGUI_TIMELINE_ADD_ITEM_NULL,
     self.label = "Null",
     self.tooltip = "Adds a null item.\nA null item is an invisible item, often accessed by the game engine.",
-    self.undoAction = "Add Null",
+    self.snapshotAction = "Add Null",
     self.isSizeToText = true
 );
 
 IMGUI_ITEM(IMGUI_TIMELINE_REMOVE_ITEM,
     self.label = "Remove",
     self.tooltip = "Removes the selected item (layer or null) from the animation.",
-    self.undoAction = "Remove Item",
+    self.snapshotAction = "Remove Item",
     self.focusWindow = IMGUI_TIMELINE.label,
     self.rowCount = IMGUI_TIMELINE_FOOTER_ITEM_CHILD_ITEM_COUNT
 );
@@ -1866,7 +1881,7 @@ IMGUI_ITEM(IMGUI_PAUSE,
 IMGUI_ITEM(IMGUI_ADD_FRAME,
     self.label = "+ Insert Frame",
     self.tooltip = "Inserts a frame in the selected animation item, based on the preview time.",
-    self.undoAction = "Insert Frame",
+    self.snapshotAction = "Insert Frame",
     self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
     self.isSameLine = true
 );
@@ -1874,7 +1889,7 @@ IMGUI_ITEM(IMGUI_ADD_FRAME,
 IMGUI_ITEM(IMGUI_REMOVE_FRAME,
     self.label = "- Delete Frame",
     self.tooltip = "Removes the selected frame from the selected animation item.",
-    self.undoAction = "Delete Frame",
+    self.snapshotAction = "Delete Frame",
     self.focusWindow = IMGUI_TIMELINE.label,
     self.chord = ImGuiKey_Delete,
     self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
@@ -1918,7 +1933,7 @@ IMGUI_ITEM(IMGUI_BAKE_ROUND_ROTATION,
 IMGUI_ITEM(IMGUI_BAKE_CONFIRM,
     self.label = "Bake",
     self.tooltip = "Bake the selected frame with the options selected.",
-    self.undoAction = "Bake Frames",
+    self.snapshotAction = "Bake Frames",
     self.rowCount = IMGUI_OPTION_POPUP_ROW_COUNT,
     self.isSameLine = true
 );
@@ -1926,7 +1941,7 @@ IMGUI_ITEM(IMGUI_BAKE_CONFIRM,
 IMGUI_ITEM(IMGUI_FIT_ANIMATION_LENGTH, 
     self.label = "Fit Animation Length",
     self.tooltip = "Sets the animation's length to the latest frame.",
-    self.undoAction = "Fit Animation Length",
+    self.snapshotAction = "Fit Animation Length",
     self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
     self.isSameLine = true
 );
@@ -1934,7 +1949,7 @@ IMGUI_ITEM(IMGUI_FIT_ANIMATION_LENGTH,
 IMGUI_ITEM(IMGUI_ANIMATION_LENGTH, 
     self.label = "Length",
     self.tooltip = "Sets the animation length.\n(Will not change frames.)",
-    self.undoAction = "Set Animation Length",
+    self.snapshotAction = "Set Animation Length",
     self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
     self.min = ANM2_FRAME_NUM_MIN,
     self.max = ANM2_FRAME_NUM_MAX,
@@ -1945,7 +1960,7 @@ IMGUI_ITEM(IMGUI_ANIMATION_LENGTH,
 IMGUI_ITEM(IMGUI_FPS, 
     self.label = "FPS",
     self.tooltip = "Sets the animation's frames per second (its speed).",
-    self.undoAction = "Set FPS",
+    self.snapshotAction = "Set FPS",
     self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
     self.min = ANM2_FPS_MIN,
     self.max = ANM2_FPS_MAX,
@@ -1956,7 +1971,7 @@ IMGUI_ITEM(IMGUI_FPS,
 IMGUI_ITEM(IMGUI_LOOP,
     self.label = "Loop",
     self.tooltip = "Toggles the animation looping.",
-    self.undoAction = "Set Loop",
+    self.snapshotAction = "Set Loop",
     self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
     self.value = true,
     self.isSameLine = true
@@ -1974,7 +1989,7 @@ IMGUI_ITEM(IMGUI_CONTEXT_MENU, self.label = "## Context Menu");
 IMGUI_ITEM(IMGUI_CUT,
     self.label = "Cut",
     self.tooltip = "Cuts the currently selected contextual element; removing it and putting it to the clipboard.",
-    self.undoAction = "Cut",
+    self.snapshotAction = "Cut",
     self.function = imgui_cut,
     self.chord = ImGuiMod_Ctrl | ImGuiKey_X,
     self.isSizeToText = true
@@ -1983,7 +1998,7 @@ IMGUI_ITEM(IMGUI_CUT,
 IMGUI_ITEM(IMGUI_COPY,
     self.label = "Copy",
     self.tooltip = "Copies the currently selected contextual element to the clipboard.",
-    self.undoAction = "Copy",
+    self.snapshotAction = "Copy",
     self.function = imgui_copy,
     self.chord = ImGuiMod_Ctrl | ImGuiKey_C,
     self.isSizeToText = true
@@ -1992,7 +2007,7 @@ IMGUI_ITEM(IMGUI_COPY,
 IMGUI_ITEM(IMGUI_PASTE,
     self.label = "Paste",
     self.tooltip = "Pastes the currently selection contextual element from the clipboard.",
-    self.undoAction = "Paste",
+    self.snapshotAction = "Paste",
     self.function = imgui_paste,
     self.chord = ImGuiMod_Ctrl | ImGuiKey_V,
     self.isSizeToText = true
@@ -2001,7 +2016,7 @@ IMGUI_ITEM(IMGUI_PASTE,
 IMGUI_ITEM(IMGUI_CHANGE_INPUT_TEXT,
     self.label = "## Input Text",
     self.tooltip = "Rename the selected item.",
-    self.undoAction = "Rename Item",
+    self.snapshotAction = "Rename Item",
     self.flags = ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_EnterReturnsTrue,
     self.max = 255
 );
@@ -2009,7 +2024,7 @@ IMGUI_ITEM(IMGUI_CHANGE_INPUT_TEXT,
 IMGUI_ITEM(IMGUI_CHANGE_INPUT_INT,
     self.label = "## Input Int",
     self.tooltip = "Change the selected item's value.",
-    self.undoAction = "Change Value",
+    self.snapshotAction = "Change Value",
     self.step = 0
 );
 

src/log.cpp

@@ -0,0 +1,56 @@
+#include "log.h"
+
+inline std::ofstream logFile;
+
+std::string log_path_get(void)
+{
+    return preferences_path_get() + LOG_PATH;
+}
+
+void log_write(const std::string& string)
+{
+    std::println("{}", string);
+    
+    if (logFile.is_open())
+    {
+        logFile << string << '\n';
+        logFile.flush();
+    }
+}
+
+void log_init(void)
+{
+    std::string logFilepath = log_path_get();
+    logFile.open(logFilepath, std::ios::out | std::ios::trunc);
+    if (!logFile) std::println("{}", std::format(LOG_INIT_ERROR, logFilepath));
+}
+
+void log_error(const std::string& error)
+{
+    log_write(LOG_ERROR_FORMAT + error);
+}
+
+void log_info(const std::string& info)
+{
+    log_write(LOG_INFO_FORMAT + info);
+}
+
+void log_warning(const std::string& warning)
+{
+    log_write(LOG_WARNING_FORMAT + warning);
+}
+
+void log_imgui(const std::string& imgui)
+{
+    log_write(LOG_IMGUI_FORMAT + imgui);
+}
+
+void log_command(const std::string& command)
+{
+    log_write(LOG_COMMAND_FORMAT + command);
+}
+
+void log_free(void)
+{
+    logFile.close();
+}

src/log.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "COMMON.h"
+
+#define LOG_WARNING_FORMAT "[WARNING] "
+#define LOG_ERROR_FORMAT "[ERROR] "
+#define LOG_INFO_FORMAT "[INFO] "
+#define LOG_IMGUI_FORMAT "[IMGUI] "
+#define LOG_INIT_ERROR "[ERROR] Failed to open log file: {}"
+#define LOG_COMMAND_FORMAT "[COMMAND] "
+#define LOG_PATH "log.txt"
+
+std::string log_path_get(void);
+void log_init(void);
+void log_write(const std::string& file);
+void log_error(const std::string& error);
+void log_info(const std::string& info);
+void log_warning(const std::string& warning);
+void log_imgui(const std::string& imgui);
+void log_command(const std::string& command);
+void log_free(void);

src/main.cpp

@@ -4,7 +4,7 @@ static bool _anm2_rescale(const std::string& file, f32 scale)
 {
 	Anm2 anm2;
 
-	if (!anm2_deserialize(&anm2, nullptr, file)) return false;
+	if (!anm2_deserialize(&anm2, file)) return false;
 	anm2_scale(&anm2, scale);
 	return anm2_serialize(&anm2, file);
 }
@@ -14,6 +14,8 @@ main(s32 argc, char* argv[])
 {
 	State state;
 
+	log_init();
+
 	if (argc > 0 && argv[1])
 	{
 		if (std::string(argv[1]) == ARGUMENT_RESCALE)

src/preview.cpp

@@ -85,7 +85,7 @@ void preview_draw(Preview* self)
     GLuint& shaderGrid = self->resources->shaders[SHADER_GRID];
     mat4 transform = canvas_transform_get(&self->canvas, self->settings->previewPan, self->settings->previewZoom, ORIGIN_CENTER);
  
-    canvas_texture_set(&self->canvas);
+    canvas_framebuffer_resize_check(&self->canvas);
     
     canvas_bind(&self->canvas);
     canvas_viewport_set(&self->canvas);
@@ -108,12 +108,12 @@ void preview_draw(Preview* self)
         anm2_frame_from_time(self->anm2, &root, Anm2Reference{animationID, ANM2_ROOT}, self->time);
 
         if (self->settings->previewIsRootTransform)
-            rootModel = quad_parent_model_get(root.position, vec2(0.0f), root.rotation, PERCENT_TO_UNIT(root.scale));
+            rootModel = canvas_parent_model_get(root.position, {}, PERCENT_TO_UNIT(root.scale), root.rotation);
 
         // Root
         if (self->settings->previewIsTargets && animation->rootAnimation.isVisible && root.isVisible)
         {
-            mat4 model = quad_model_get(PREVIEW_TARGET_SIZE, root.position, PREVIEW_TARGET_SIZE * 0.5f, root.rotation, PERCENT_TO_UNIT(root.scale));
+            mat4 model = canvas_model_get(PREVIEW_TARGET_SIZE, root.position, PREVIEW_TARGET_SIZE * 0.5f, PERCENT_TO_UNIT(root.scale), root.rotation);
             mat4 rootTransform = transform * model;
             f32 vertices[] = ATLAS_UV_VERTICES(ATLAS_TARGET);
             canvas_texture_draw(&self->canvas, shaderTexture, self->resources->atlas.id, rootTransform, vertices, PREVIEW_ROOT_COLOR);
@@ -133,18 +133,18 @@ void preview_draw(Preview* self)
             if (!frame.isVisible)
                 continue;
 
-            mat4 model = quad_model_get(frame.size, frame.position, frame.pivot, frame.rotation, PERCENT_TO_UNIT(frame.scale));
+            mat4 model = canvas_model_get(frame.size, frame.position, frame.pivot, PERCENT_TO_UNIT(frame.scale), frame.rotation);
             mat4 layerTransform = transform * (rootModel * model);
 
-            Texture* texture = map_find(self->resources->textures, self->anm2->layers[id].spritesheetID);
+            Texture& texture = self->anm2->spritesheets[self->anm2->layers[id].spritesheetID].texture;
            
-            if (texture && !texture->isInvalid)
+            if (!texture.isInvalid)
             {
-                vec2 uvMin = frame.crop / vec2(texture->size);
+                vec2 uvMin = frame.crop / vec2(texture.size);
-                vec2 uvMax = (frame.crop + frame.size) / vec2(texture->size);
+                vec2 uvMax = (frame.crop + frame.size) / vec2(texture.size);
                 f32 vertices[] = UV_VERTICES(uvMin, uvMax);
 
-                canvas_texture_draw(&self->canvas, shaderTexture, texture->id, layerTransform, vertices, frame.tintRGBA, frame.offsetRGB);
+                canvas_texture_draw(&self->canvas, shaderTexture, texture.id, layerTransform, vertices, frame.tintRGBA, frame.offsetRGB);
             }
  
             if (self->settings->previewIsBorder)
@@ -153,7 +153,7 @@ void preview_draw(Preview* self)
             if (self->settings->previewIsPivots)
             {
                 f32 vertices[] = ATLAS_UV_VERTICES(ATLAS_PIVOT);
-                mat4 pivotModel = quad_model_get(CANVAS_PIVOT_SIZE, frame.position, CANVAS_PIVOT_SIZE * 0.5f, frame.rotation, PERCENT_TO_UNIT(frame.scale));
+                mat4 pivotModel = canvas_model_get(CANVAS_PIVOT_SIZE, frame.position, CANVAS_PIVOT_SIZE * 0.5f, PERCENT_TO_UNIT(frame.scale), frame.rotation);
                 mat4 pivotTransform = transform * (rootModel * pivotModel);
                 canvas_texture_draw(&self->canvas, shaderTexture, self->resources->atlas.id, pivotTransform, vertices, PREVIEW_PIVOT_COLOR);
             }
@@ -182,7 +182,7 @@ void preview_draw(Preview* self)
                 vec2 size = null.isShowRect ? CANVAS_PIVOT_SIZE : PREVIEW_TARGET_SIZE;
                 AtlasType atlas = null.isShowRect ? ATLAS_SQUARE : ATLAS_TARGET;
           
-                mat4 model = quad_model_get(size, frame.position, size * 0.5f, frame.rotation, PERCENT_TO_UNIT(frame.scale));
+                mat4 model = canvas_model_get(size, frame.position, size * 0.5f, PERCENT_TO_UNIT(frame.scale), frame.rotation);
                 mat4 nullTransform = transform * (rootModel * model);
      
                 f32 vertices[] = ATLAS_UV_VERTICES(atlas);
@@ -191,7 +191,7 @@ void preview_draw(Preview* self)
 
                 if (null.isShowRect)
                 {
-                    mat4 rectModel = quad_model_get(PREVIEW_NULL_RECT_SIZE, frame.position, PREVIEW_NULL_RECT_SIZE * 0.5f, frame.rotation, PERCENT_TO_UNIT(frame.scale));
+                    mat4 rectModel = canvas_model_get(PREVIEW_NULL_RECT_SIZE, frame.position, PREVIEW_NULL_RECT_SIZE * 0.5f, PERCENT_TO_UNIT(frame.scale), frame.rotation);
                     mat4 rectTransform = transform * (rootModel * rectModel);
                     canvas_rect_draw(&self->canvas, shaderLine, rectTransform, color);
                 }
@@ -210,7 +210,7 @@ void preview_draw(Preview* self)
         anm2_frame_from_time(self->anm2, &root, Anm2Reference{animationOverlayID, ANM2_ROOT}, self->time);
 
         if (self->settings->previewIsRootTransform)
-            rootModel = quad_parent_model_get(root.position, vec2(0.0f), root.rotation, PERCENT_TO_UNIT(root.scale));
+            rootModel = canvas_parent_model_get(root.position, {}, PERCENT_TO_UNIT(root.scale));
 
 		for (auto [i, id] : self->anm2->layerMap)
         {
@@ -225,22 +225,21 @@ void preview_draw(Preview* self)
             if (!frame.isVisible)
                 continue;
 
-            Texture* texture = map_find(self->resources->textures, self->anm2->layers[id].spritesheetID);
+            Texture& texture = self->anm2->spritesheets[self->anm2->layers[id].spritesheetID].texture;
             
-            if (!texture || texture->isInvalid)
+            if (texture.isInvalid) continue;
-                continue;
 
-            vec2 uvMin = frame.crop / vec2(texture->size);
+            vec2 uvMin = frame.crop / vec2(texture.size);
-            vec2 uvMax = (frame.crop + frame.size) / vec2(texture->size);
+            vec2 uvMax = (frame.crop + frame.size) / vec2(texture.size);
             f32 vertices[] = UV_VERTICES(uvMin, uvMax);
 
-            mat4 model = quad_model_get(frame.size, frame.position, frame.pivot, frame.rotation, PERCENT_TO_UNIT(frame.scale));
+            mat4 model = canvas_model_get(frame.size, frame.position, frame.pivot, PERCENT_TO_UNIT(frame.scale), frame.rotation);
             mat4 layerTransform = transform * (rootModel * model);
 
             vec4 tint = frame.tintRGBA;
             tint.a *= U8_TO_FLOAT(self->settings->previewOverlayTransparency);
 
-            canvas_texture_draw(&self->canvas, shaderTexture, texture->id, layerTransform, vertices, tint, frame.offsetRGB);
+            canvas_texture_draw(&self->canvas, shaderTexture, texture.id, layerTransform, vertices, tint, frame.offsetRGB);
         }
     }
 

src/resources.cpp

@@ -1,17 +1,5 @@
 #include "resources.h"
 
-void resources_texture_init(Resources* self, const std::string& path, s32 id)
-{
-	Texture texture;
-
-    if (map_find(self->textures, id))
-		texture_free(&self->textures[id]);
-
-	texture_from_path_init(&texture, path);
-
-    self->textures[id] = texture;
-}
-
 void resources_init(Resources* self)
 {
     texture_from_encoded_data_init(&self->atlas, TEXTURE_ATLAS_SIZE, TEXTURE_CHANNELS, (u8*)TEXTURE_ATLAS, TEXTURE_ATLAS_LENGTH);
@@ -22,18 +10,8 @@ void resources_init(Resources* self)
 
 void resources_free(Resources* self)
 {
-    resources_textures_free(self);
-    
     for (auto& shader : self->shaders)
         shader_free(&shader);
 
     texture_free(&self->atlas);
 }
-
-void resources_textures_free(Resources* self)
-{
-    for (auto& [id, texture] : self->textures) 
-        texture_free(&self->textures[id]);
-    
-    log_info(RESOURCES_TEXTURES_FREE_INFO);
-}

src/resources.h

@@ -10,10 +10,7 @@ struct Resources
 {
     GLuint shaders[SHADER_COUNT];
     Texture atlas;
-    std::map<s32, Texture> textures;
 };
 
 void resources_init(Resources* self);
-void resources_texture_init(Resources* self, const std::string& path, s32 id);
 void resources_free(Resources* self);
-void resources_textures_free(Resources* self);

src/settings.cpp

@@ -74,9 +74,7 @@ static void _settings_setting_load(Settings* self, const std::string& line)
 
 std::string settings_path_get(void)
 {
-    char* path = SDL_GetPrefPath("", SETTINGS_FOLDER);
+    std::string filePath = preferences_path_get() + SETTINGS_PATH;
-    std::string filePath = std::string(path) + SETTINGS_PATH;
-    SDL_free(path);
     return filePath;
 }
 

src/shader.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "COMMON.h"
+#include "log.h"
 
 #define SHADER_INFO_LOG_MAX 0xFF
 #define SHADER_INIT_ERROR "Failed to initialize shader {}:\n{}"

src/snapshots.cpp

@@ -1,6 +1,6 @@
 #include "snapshots.h"
 
-static void _snapshot_stack_push(SnapshotStack* stack, const Snapshot* snapshot)
+static void _snapshot_stack_push(SnapshotStack* stack, Snapshot* snapshot)
 {
     if (stack->top >= SNAPSHOT_STACK_MAX)
     {
@@ -11,20 +11,29 @@ static void _snapshot_stack_push(SnapshotStack* stack, const Snapshot* snapshot)
     stack->snapshots[stack->top++] = *snapshot;
 }
 
-static bool _snapshot_stack_pop(SnapshotStack* stack, Snapshot* snapshot)
+static Snapshot* _snapshot_stack_pop(SnapshotStack* stack)
 {
-    if (stack->top == 0) return false;
+    if (stack->top == 0) return nullptr;
-
+    return &stack->snapshots[--stack->top];
-    *snapshot = stack->snapshots[--stack->top];
-    return true;
 }
 
-static void _snapshot_set(Snapshots* self, const Snapshot& snapshot)
+static void _snapshot_set(Snapshots* self, Snapshot* snapshot)
 {
-    *self->anm2 = snapshot.anm2;
+    if (!snapshot) return;
-    *self->reference = snapshot.reference;
+
-    self->preview->time = snapshot.time;
+    *self->anm2 = snapshot->anm2;
-    self->action = snapshot.action;
+    *self->reference = snapshot->reference;
+    self->preview->time = snapshot->time;
+    self->action = snapshot->action;
+
+    anm2_spritesheet_texture_pixels_upload(self->anm2);
+}
+
+Snapshot snapshot_get(Snapshots* self)
+{
+    Snapshot snapshot = {*self->anm2, *self->reference, self->preview->time, self->action};
+    anm2_spritesheet_texture_pixels_download(&snapshot.anm2);
+    return snapshot;
 }
 
 void snapshots_init(Snapshots* self, Anm2* anm2, Anm2Reference* reference, Preview* preview)
@@ -41,18 +50,17 @@ void snapshots_reset(Snapshots* self)
     self->action.clear();
 }
 
-void snapshots_undo_push(Snapshots* self, const Snapshot* snapshot)
+void snapshots_undo_push(Snapshots* self, Snapshot* snapshot)
 {
-    _snapshot_stack_push(&self->undoStack, snapshot);
     self->redoStack.top = 0;
+    _snapshot_stack_push(&self->undoStack, snapshot);
 }
 
 void snapshots_undo(Snapshots* self)
 {
-    Snapshot snapshot;
+    if (Snapshot* snapshot = _snapshot_stack_pop(&self->undoStack))
-    if (_snapshot_stack_pop(&self->undoStack, &snapshot))
     {
-        Snapshot current = {*self->anm2, *self->reference, self->preview->time, self->action};
+        Snapshot current = snapshot_get(self);
         _snapshot_stack_push(&self->redoStack, &current);
         _snapshot_set(self, snapshot);
     }
@@ -60,10 +68,9 @@ void snapshots_undo(Snapshots* self)
 
 void snapshots_redo(Snapshots* self)
 {
-    Snapshot snapshot;
+    if (Snapshot* snapshot = _snapshot_stack_pop(&self->redoStack))
-    if (_snapshot_stack_pop(&self->redoStack, &snapshot))
     {
-        Snapshot current = {*self->anm2, *self->reference, self->preview->time, self->action};
+        Snapshot current = snapshot_get(self);
         _snapshot_stack_push(&self->undoStack, &current);
         _snapshot_set(self, snapshot);
     }

src/snapshots.h

@@ -4,7 +4,7 @@
 #include "preview.h"
 #include "texture.h"
 
-#define SNAPSHOT_STACK_MAX 1000
+#define SNAPSHOT_STACK_MAX 100
 #define SNAPSHOT_ACTION "Action"
 
 struct Snapshot
@@ -33,8 +33,9 @@ struct Snapshots
     SnapshotStack redoStack;
 };
 
-void snapshots_undo_push(Snapshots* self, const Snapshot* snapshot);
+void snapshots_undo_push(Snapshots* self, Snapshot* snapshot);
 void snapshots_init(Snapshots* self, Anm2* anm2, Anm2Reference* reference, Preview* preview);
 void snapshots_undo(Snapshots* self);
 void snapshots_redo(Snapshots* self);
 void snapshots_reset(Snapshots* self);
+Snapshot snapshot_get(Snapshots* self);

src/state.cpp

@@ -24,9 +24,6 @@ static void _draw(State* self)
 
 void init(State* self)
 {
-
-	log_info(STATE_INIT_INFO);
-	
 	settings_init(&self->settings);
 
 	if (!SDL_Init(SDL_INIT_VIDEO))
@@ -63,14 +60,12 @@ void init(State* self)
 		log_info(STATE_MIX_INIT_INFO);
 	*/
 
-	SDL_CreateWindowAndRenderer
+	self->window = SDL_CreateWindow
 	(
 		WINDOW_TITLE, 
 		self->settings.windowSize.x, 
 		self->settings.windowSize.y, 
-		WINDOW_FLAGS, 
+		WINDOW_FLAGS
-		&self->window, 
-		&self->renderer
 	);
 
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
@@ -79,18 +74,24 @@ void init(State* self)
 
 	self->glContext = SDL_GL_CreateContext(self->window);
 	
-	window_vsync_set(self->settings.isVsync);
-	
 	if (!self->glContext)
 	{
 		log_error(std::format(STATE_GL_CONTEXT_INIT_ERROR, SDL_GetError()));
 		quit(self);
 	}
 
-	glewInit();
+	GLenum glewError = glewInit();
+
+	if (glewError != GLEW_OK)
+	{
+		log_error(std::format(STATE_GL_CONTEXT_INIT_ERROR, (const char*)glewGetErrorString(glewError)));
+		quit(self);
+	}
 
 	log_info(std::format(STATE_GL_CONTEXT_INIT_INFO, (const char*)glGetString(GL_VERSION)));
 	
+	window_vsync_set(self->settings.isVsync);
+	
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  
 	glLineWidth(STATE_GL_LINE_WIDTH);
@@ -98,13 +99,21 @@ void init(State* self)
 	glDisable(GL_DEPTH_TEST);
 	glDisable(GL_LINE_SMOOTH);
 	
+	if (!self->argument.empty())
+	{
+		anm2_deserialize(&self->anm2, self->argument);
+		window_title_from_path_set(self->window, self->argument);
+	}
+	else
+		anm2_new(&self->anm2);
+
 	resources_init(&self->resources);
 	dialog_init(&self->dialog, self->window);
 	clipboard_init(&self->clipboard, &self->anm2);
-	snapshots_init(&self->snapshots, &self->anm2, &self->reference, &self->preview);
 	preview_init(&self->preview, &self->anm2, &self->reference, &self->resources, &self->settings);
 	generate_preview_init(&self->generatePreview, &self->anm2, &self->reference, &self->resources, &self->settings);
 	editor_init(&self->editor, &self->anm2, &self->reference, &self->resources, &self->settings);
+	snapshots_init(&self->snapshots, &self->anm2, &self->reference, &self->preview);
 	
 	imgui_init
 	(
@@ -122,14 +131,6 @@ void init(State* self)
 		self->window,
 		&self->glContext
 	);
-
-	if (!self->argument.empty())
-	{
-		anm2_deserialize(&self->anm2, &self->resources, self->argument);
-		window_title_from_path_set(self->window, self->argument);
-	}
-	else
-		anm2_new(&self->anm2);
 }
 
 void loop(State* self)
@@ -191,4 +192,5 @@ void quit(State* self)
 
 	settings_save(&self->settings);
 	log_info(STATE_QUIT_INFO);
+	log_free();
 }

src/state.h

@@ -26,7 +26,6 @@
 struct State
 {
 	SDL_Window* window;
-	SDL_Renderer* renderer;
 	SDL_GLContext glContext;
     Imgui imgui;
 	Dialog dialog;

src/texture.cpp

@@ -17,7 +17,9 @@
 
 static void _texture_gl_set(Texture* self, const u8* data)
 {
+	if (self->id == GL_ID_NONE) 
 		glGenTextures(1, &self->id);
+	
 	glBindTexture(GL_TEXTURE_2D, self->id);
 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self->size.x, self->size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
@@ -40,7 +42,6 @@ std::vector<u8> texture_download(const Texture* self)
 
 bool texture_from_path_init(Texture* self, const std::string& path)
 {
-	*self = Texture{};
 	u8* data = stbi_load(path.c_str(), &self->size.x, &self->size.y, &self->channels, TEXTURE_CHANNELS);
 	
 	if (!data)
@@ -49,11 +50,12 @@ bool texture_from_path_init(Texture* self, const std::string& path)
 		if (!data)
 		{
 			log_error(std::format(TEXTURE_INIT_ERROR, path));
-			self->isInvalid = true;
 			return false;
 		}
 	}
 
+	self->isInvalid = false;
+
 	log_info(std::format(TEXTURE_INIT_INFO, path));
 
 	_texture_gl_set(self, data);
@@ -133,33 +135,3 @@ bool texture_pixel_set(Texture* self, ivec2 position, vec4 color)
 
     return true;
 }
-
-Texture texture_copy(Texture* self)
-{
-	Texture copy = *self;
-	_texture_gl_set(&copy, nullptr);
-
-    GLuint fboSource;
-	GLuint fboDestination;
-    glGenFramebuffers(1, &fboSource);
-    glGenFramebuffers(1, &fboDestination);
-
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, fboSource);
-    glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->id, 0);
-
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fboDestination);
-    glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, copy.id, 0);
-
-    glBlitFramebuffer
-	(
-        0, 0, self->size.x, self->size.y,
-        0, 0, self->size.x, self->size.y,
-        GL_COLOR_BUFFER_BIT, GL_NEAREST
-    );
-
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
-    glDeleteFramebuffers(1, &fboSource);
-    glDeleteFramebuffers(1, &fboDestination);
-
-	return copy;
-}

src/texture.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "COMMON.h"
+#include "log.h"
 
 #define TEXTURE_CHANNELS 4
 #define TEXTURE_INIT_INFO "Initialized texture from file: {}"
@@ -10,10 +10,10 @@
 
 struct Texture
 {
-    GLuint id = 0;
+    GLuint id = GL_ID_NONE;
-    ivec2 size = {0, 0};
+    ivec2 size{};
-    s32 channels = -1;
+    s32 channels = TEXTURE_CHANNELS;
-    bool isInvalid = false;
+    bool isInvalid = true;
 };
 
 bool texture_from_encoded_data_init(Texture* self, ivec2 size, s32 channels, const u8* data, u32 length);