frames are now tiles in sprite(/sheet) terminology

src/sprite.c

@@ -11,9 +11,7 @@ struct Sprite {
     Spritesheet* spritesheet;
 
     // The current frame of animation.
-    size_t current_frame;
-    // Time at the start of the current frame of animation.
-    float current_frame_time;
+    size_t tile_index;
 
     // The local transformation of this sprite.
     Vector origin;
@@ -26,9 +24,7 @@ Sprite* sprite_from_spritesheet(Spritesheet* sheet, size_t initial_frame) {
 
     self->spritesheet = sheet;
     self->origin = (Vector){0.5f, 0.5f};
-    self->current_frame = initial_frame;
-    // TODO: replace with a getter for the current game time.
-    self->current_frame_time = 0;
+    self->tile_index = initial_frame;
 
     return self;
 }
@@ -41,7 +37,7 @@ void sprite_draw(Sprite* self, Transform transform) {
     // #warning "sprite drawing disabled"
     // return;
     SDL_Texture* texture = spritesheet_get_texture(self->spritesheet);
-    SDL_Rect source = spritesheet_get_frame_rect(self->spritesheet, self->current_frame);
+    SDL_Rect source = spritesheet_get_tile_rect(self->spritesheet, self->tile_index);
 
     Vector left_top = transform_point(&transform, vinvf(self->origin));
 
@@ -65,12 +61,12 @@ void sprite_set_origin(Sprite* self, Vector origin) {
     self->origin = origin;
 }
 
-size_t sprite_get_frame(const Sprite* self) {
-    return self->current_frame;
+size_t sprite_get_tile(const Sprite* self) {
+    return self->tile_index;
 }
 
-void sprite_set_frame(Sprite* self, size_t size) {
-    self->current_frame = size;
+void sprite_set_tile(Sprite* self, size_t frame) {
+    self->tile_index = frame;
 }
 
 Spritesheet* sprite_get_spritesheet(const Sprite* self) {
@@ -79,4 +75,4 @@ Spritesheet* sprite_get_spritesheet(const Sprite* self) {
 
 void sprite_set_spritesheet(Sprite* self, Spritesheet* spritesheet) {
     self->spritesheet = spritesheet;
-}
+}

src/sprite.h

@@ -18,8 +18,8 @@ extern void sprite_draw(Sprite* self, Transform transform);
 extern Vector sprite_get_origin(Sprite* self);
 extern void sprite_set_origin(Sprite* self, Vector origin);
 
-extern size_t sprite_get_frame(const Sprite* self);
-extern void sprite_set_frame(Sprite* self, size_t size);
+extern size_t sprite_get_tile(const Sprite* self);
+extern void sprite_set_tile(Sprite* self, size_t tile);
 
 extern Spritesheet* sprite_get_spritesheet(const Sprite* self);
 extern void sprite_set_spritesheet(Sprite* self, Spritesheet* spritesheet);

src/spritesheet.c

@@ -12,16 +12,12 @@ struct Spritesheet {
     SDL_Texture* texture;
     // The resolution of the texture.
     IVector resolution;
-    // The number of frames in the sheet.
-    size_t frame_count;
-    // The number of frames contained in the width of the texture.
-    size_t frame_shear;
-    // Rules for how to play the sheet's animation.
-    AnimationType animation_type;
-    // The resolution of a single frame of the sheet.
-    IVector frame_size;
-    // The time to wait before switching frames.
-    float frame_interval;
+    // The number of tiles in the sheet.
+    size_t tile_count;
+    // The number of tiles contained in the width of the texture.
+    size_t tile_shear;
+    // The resolution of a single tile of the sheet.
+    IVector tile_size;
 };
 
 void _internal_spritesheet_destroy(Spritesheet* self) {
@@ -29,13 +25,13 @@ void _internal_spritesheet_destroy(Spritesheet* self) {
     free(self);
 }
 
-Spritesheet* spritesheet_load(const char* texture_name, IVector frame_resolution) {
+Spritesheet* spritesheet_load(const char* texture_name, IVector tile_size) {
     SDL_Texture* texture = IMG_LoadTexture(g_renderer, texture_name);
     ASSERT_RETURN(texture != NULL, NULL, "Failed to load texture from file %s.", texture_name);
-    return spritesheet_from_texture(texture, frame_resolution);
+    return spritesheet_from_texture(texture, tile_size);
 }
 
-Spritesheet* spritesheet_from_texture(SDL_Texture* texture, IVector frame_resolution) {
+Spritesheet* spritesheet_from_texture(SDL_Texture* texture, IVector tile_size) {
     Spritesheet* self = malloc(sizeof(Spritesheet));
 
     ASSERT_RETURN(self != NULL, NULL, "Failed to allocate spritesheet.");
@@ -46,11 +42,9 @@ Spritesheet* spritesheet_from_texture(SDL_Texture* texture, IVector frame_resolu
     self->texture = texture;
     SDL_QueryTexture(self->texture, NULL, NULL, &self->resolution.x, &self->resolution.y);
 
-    self->animation_type = ANIMTYPE_ONCE;
-    self->frame_size = frame_resolution;
-    self->frame_shear = self->resolution.x / self->frame_size.x;
-    self->frame_count = self->resolution.x / self->frame_size.x + self->resolution.y / self->frame_size.y;
-    self->frame_interval = 0.016f;
+    self->tile_size = tile_size;
+    self->tile_shear = self->resolution.x / self->tile_size.x;
+    self->tile_count = self->resolution.x / self->tile_size.x + self->resolution.y / self->tile_size.y;
 
     return self;
 }
@@ -63,13 +57,13 @@ SDL_Texture* spritesheet_get_texture(const Spritesheet* self) {
     return self->texture;
 }
 
-SDL_Rect spritesheet_get_frame_rect(const Spritesheet* self, size_t index) {
-    IVector tile_coord = {index % self->frame_shear, index / self->frame_shear};
-    tile_coord = vmuli(tile_coord, self->frame_size);
+SDL_Rect spritesheet_get_tile_rect(const Spritesheet* self, size_t index) {
+    IVector tile_coord = {index % self->tile_shear, index / self->tile_shear};
+    tile_coord = vmuli(tile_coord, self->tile_size);
 
     return (SDL_Rect) {
         tile_coord.x, tile_coord.y,
-        self->frame_size.x, self->frame_size.y
+        self->tile_size.x, self->tile_size.y
     };
 }
 

src/spritesheet.h

@@ -5,20 +5,14 @@
 #include "vmath.h"
 #include <SDL2/SDL_render.h>
 
-typedef enum AnimationType AnimationType;
-enum AnimationType {
-    ANIMTYPE_ONCE,
-    ANIMTYPE_LOOP,
-};
-
 typedef struct Spritesheet Spritesheet;
 
-extern Spritesheet* spritesheet_load(const char* texture_name, IVector frame_resolution);
-extern Spritesheet* spritesheet_from_texture(SDL_Texture* texture, IVector frame_resolution);
+extern Spritesheet* spritesheet_load(const char* texture_name, IVector tile_size);
+extern Spritesheet* spritesheet_from_texture(SDL_Texture* texture, IVector tile_size);
 extern void spritesheet_destroy(Spritesheet* self);
 
 extern SDL_Texture* spritesheet_get_texture(const Spritesheet* self);
-extern SDL_Rect spritesheet_get_frame_rect(const Spritesheet* self, size_t index);
+extern SDL_Rect spritesheet_get_tile_rect(const Spritesheet* self, size_t index);
 extern IVector spritesheet_get_resolution(const Spritesheet* self);
 
 extern asset_id spritesheet_get_asset_id(Spritesheet* self);