shariq
/
Symmetry
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rewrote array to make it easier to use

Browse Source
dev
Shariq Shah 10 years ago
parent 4a8c3133bb
commit e6a04a1577
11 changed files with 293 additions and 222 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 173
      src/array.c
  2. 69
      src/array.h
  3. 27
      src/entity.c
  4. 3
      src/game.c
  5. 99
      src/geometry.c
  6. 54
      src/input.c
  7. 8
      src/input.h
  8. 26
      src/shader.c
  9. 30
      src/string_utils.c
  10. 3
      src/transform.c
  11. 17
      src/transform.h

173
src/array.c
Unescape View File

@ -1,28 +1,44 @@
#include <stdlib.h> #include <stdlib.h>
#include <stddef.h>
#include <string.h> #include <string.h>
#include "array.h" #include "array.h"
struct Array
{
int capacity; // current capacity i.e memory allocated
int length; // current length of array
size_t object_size; // size per element
char data[]; // actual data
};
#define ARRAY_MIN_CAPACITY 2 #define ARRAY_MIN_CAPACITY 2
static bool array_reallocate(struct Array* array); static struct Array* array_get_ptr(void* array_data);
static struct Array* array_reallocate(struct Array* array);
static void* array_top(struct Array* array);
static void* array_get(struct Array* array, unsigned int index);
struct Array* array_new_(size_t object_size, int capacity) static struct Array* array_get_ptr(void* array_data)
{ {
struct Array* newArray = malloc(sizeof(struct Array)); return (struct Array*)((char*)array_data - offsetof(struct Array, data));
}
newArray->object_size = object_size; void* array_new_(size_t object_size, int capacity)
newArray->length = 0; {
newArray->capacity = capacity == 0 ? ARRAY_MIN_CAPACITY : capacity; capacity = capacity == 0 ? ARRAY_MIN_CAPACITY : capacity;
newArray->data = malloc(newArray->object_size * newArray->capacity); struct Array* new_array = malloc(sizeof(*new_array) + (object_size * capacity));
new_array->object_size = object_size;
new_array->length = 0;
new_array->capacity = capacity;
return newArray; return new_array->data;
} }
void array_free(struct Array* array) void array_free(void* array)
{ {
free(array->data); struct Array* array_ptr = array_get_ptr(array);
free(array); free(array_ptr);
} }
void* array_get(struct Array* array, unsigned int index) void* array_get(struct Array* array, unsigned int index)
@ -35,85 +51,105 @@ void* array_top(struct Array* array)
return array->data + (array->object_size * (array->length - 1)); return array->data + (array->object_size * (array->length - 1));
} }
void* array_add(struct Array* array) void* array_grow_(void** array)
{ {
struct Array* array_ptr = array_get_ptr(*array);
/* if capacity is full, double size */ /* if capacity is full, double size */
if(++array->length > array->capacity) if(++array_ptr->length > array_ptr->capacity)
{ {
array->capacity = array->capacity << 1; /* LShift by 1 means (number * number) */ array_ptr->capacity = array_ptr->capacity << 1; /* LShift by 1 means (number * number) */
char* new_data = realloc(array->data, array->object_size * array->capacity); char* new_data = realloc(array_ptr, sizeof(*array_ptr) + (array_ptr->object_size * array_ptr->capacity));
if(new_data) if(new_data)
{ {
array->data = new_data; array_ptr = (struct Array*)new_data;
*array = array_ptr->data; /* update the original pointer to the new address */
} }
else else
{ {
array->length--; array_ptr->length--;
array->capacity = array->capacity >> 1; array_ptr->capacity = array_ptr->capacity >> 1;
/* TODO: Error handling here! */ /* TODO: Error handling here! */
} }
} }
/* Return new pointer to data */
/* return new location added */ return array_top(array_ptr);
return array->data + (array->object_size * (array->length - 1));
} }
void array_reset(struct Array* array, unsigned int length) int array_reset_(void** array, int length)
{ {
if(array->data) free(array->data); struct Array* array_ptr = array_get_ptr(*array);
array->length = length; size_t object_size = array_ptr->object_size;
array->capacity = length < ARRAY_MIN_CAPACITY ? ARRAY_MIN_CAPACITY : length; int new_capacity = length < ARRAY_MIN_CAPACITY ? ARRAY_MIN_CAPACITY : length;
array->data = malloc(array->object_size * array->capacity); int new_length = new_capacity;
array_ptr = calloc(1, sizeof(*array_ptr) + (new_capacity * object_size));
if(array_ptr)
{
array_ptr->length = new_length;
array_ptr->capacity = new_capacity;
array_ptr->object_size = object_size;
*array = array_ptr->data;
}
return array_ptr ? 1 : 0;
} }
bool array_pop(struct Array* array) int array_pop_(void** array)
{ {
bool success = false; struct Array* array_ptr = array_get_ptr(*array);
if(array->length > 0) int success = 1;
if(array_ptr->length > 0)
{ {
array->length--; array_ptr->length--;
success = array_reallocate(array); if(!(array_ptr = array_reallocate(array_ptr)))
success = 0;
else
*array = array_ptr->data;
} }
return success; return success;
} }
bool array_reallocate(struct Array* array) struct Array* array_reallocate(struct Array* array)
{ {
bool success = true;
/* If capacity is too big i.e. 4 times larger than length, halve it */ /* If capacity is too big i.e. 4 times larger than length, halve it */
if((array->length << 2) < array->capacity && array->capacity > ARRAY_MIN_CAPACITY) if((array->length << 2) < array->capacity && array->capacity > ARRAY_MIN_CAPACITY)
{ {
array->capacity = array->capacity >> 1; array->capacity = array->capacity >> 1;
char* new_data = realloc(array->data, array->object_size * array->capacity); array = realloc(array, sizeof(*array) + (array->object_size * array->capacity));
if(new_data) /* TODO: Maybe error handling here? */
array->data = new_data;
else
success = false;
} }
return success; return array;
} }
bool array_remove_at(struct Array* array, unsigned int index) int array_remove_at_(void** array, int index)
{ {
bool success = false; struct Array* array_ptr = array_get_ptr(*array);
if(array->length > 0) int success = 1;
if(array_ptr->length > 0 && index <= array_ptr->length && index >= 0)
{ {
unsigned int next_index = index + 1; int next_index = index + 1;
if(next_index < array->length) if(next_index < array_ptr->length)
{ {
char* current_location = array->data + (array->object_size * index); char* current_location = array_ptr->data + (array_ptr->object_size * index);
char* location_after_obj = current_location + array->object_size; char* location_after_obj = current_location + array_ptr->object_size;
memmove(current_location, memmove(current_location,
location_after_obj, location_after_obj,
array->object_size * (array->length - next_index)); array_ptr->object_size * (array_ptr->length - next_index));
array->length--; array_ptr->length--;
success = array_reallocate(array); if(!(array_ptr = array_reallocate(array_ptr)))
success = 0;
else
*array = array_ptr->data;
} }
else else
{ {
success = array_pop(array); if(!array_pop(*array))
success = 0;
} }
} }
else
{
success = 0;
}
return success; return success;
} }
@ -127,7 +163,40 @@ void* array_end(struct Array* array)
return array->data + (array->object_size * array->length); return array->data + (array->object_size * array->length);
} }
void array_sort(struct Array* array, int (*compar)(const void*, const void*)) int array_len(void* array)
{ {
qsort(array->data, array->length, array->object_size, compar); struct Array* array_ptr = array_get_ptr(array);
return array_ptr->length;
}
int array_capacity(void* array)
{
struct Array* array_ptr = array_get_ptr(array);
return array_ptr->capacity;
}
void array_match_len_cap_(void** array)
{
struct Array* array_ptr = array_get_ptr(*array);
array_ptr->length = array_ptr->capacity;
}
void array_inc_cap_by_(void** array, int cap)
{
struct Array* array_ptr = array_get_ptr(*array);
if(cap > 0)
{
array_ptr->capacity += cap;
char* new_data = realloc(array_ptr, sizeof(*array_ptr) + (array_ptr->object_size * array_ptr->capacity));
if(new_data)
{
array_ptr = (struct Array*)new_data;
*array = array_ptr->data; /* update the original pointer to the new address */
}
else
{
array_ptr->capacity = array_ptr->capacity -= cap;
/* TODO: Error handling here! */
}
}
} }

69
src/array.h
Unescape View File

@ -2,47 +2,34 @@
#define ARRAY_H #define ARRAY_H
#include <stddef.h> #include <stddef.h>
#include <stdbool.h>
struct Array
{
char* data; // actual data
unsigned int capacity; // current capacity i.e memory allocated
unsigned int length; // current length of array
size_t object_size; // size per element
};
struct Array* array_new_(size_t object_size, int capacity);
#define array_new(type) array_new_(sizeof(type), 0); // Use this for array creation
#define array_new_cap(type, capacity) array_new_(sizeof(type), capacity); // Use this for array with specific capacity
void array_free(struct Array* array);
// All the macros with _val return by value while the function returns pointer
void* array_get(struct Array* array, unsigned int index);
#define array_get_val(array, type, index) (*((type*) array_get(array, index)))
#define array_get_last_val(array, type) array_get_val(array, type, array->length - 1)
#define array_get_raw(array, type) (type*) array->data
void* array_top(struct Array* array);
#define array_top_val(array, type) (*((type*) array_top(array)))
void* array_add(struct Array* array);
#define array_add_val(array, type) (*((type*) array_add(array)))
#define array_push(array, value, type) \
type* new_val = array_add(array); \
*new_val = value;
void array_reset(struct Array* array, unsigned int length); // Resize to length objects whose data is unspecified
#define array_clear(array) array_reset(array, 0)
bool array_pop(struct Array* array); // Remove object with highest index
bool array_remove_at(struct Array* array, unsigned int index);
void* array_begin(struct Array* array);
void* array_end(struct Array* array);
void array_sort(struct Array* array, int (*compar)(const void*, const void*)); // Sort array by providing a comparator function
/* Private use */
void* array_new_(size_t object_size, int capacity);
void* array_grow_(void** array);
int array_reset_(void** array, int length); // Resize to length objects whose data is unspecified
int array_pop_(void** array); // Remove object with highest index
int array_remove_at_(void** array, int index);
void array_match_len_cap_(void** array);
void array_inc_cap_by_(void** array, int cap);
/* Public Api */
#define array_new(type) (type*) array_new_(sizeof(type), 0); // Use this for array creation
#define array_new_cap(type, capacity) (type*) array_new_(sizeof(type), capacity); // Use this for array with specific capacity
#define array_clear(array) array_reset(array, 0)
#define array_grow(array, type) (type*) array_grow_((void**)&array)
#define array_push(array, value, type) {type* new_val = array_grow(array, type); \
*new_val = value;}
#define array_get_last(array, type) (type*) (&array[array_len(array)])
#define array_set_last(array, val, type) {type* last = array_get_last(array, type); \
*last = val}
#define array_pop(array) array_pop_((void**)&array)
#define array_remove_at(array, index) array_remove_at_((void**)&array, index);
#define array_reset(array, length) array_reset_((void**)&array, length);
#define array_match_len_cap(array) array_match_len_cap_((void**)&array);
#define array_inc_cap_by(array, cap) array_inc_cap_by_((void**)&array, cap);
int array_len(void* array);
int array_capacity(void* array);
void array_free(void* array);
/* TODO function to increase capacity of array by certain number similar to reserve in stl vector? */
#endif #endif

27
src/entity.c
Unescape View File

@ -7,8 +7,8 @@
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
static struct Array* entity_list; static struct Entity* entity_list;
static struct Array* empty_indices; static int* empty_indices;
void entity_initialize(void) void entity_initialize(void)
@ -19,7 +19,7 @@ void entity_initialize(void)
void entity_cleanup(void) void entity_cleanup(void)
{ {
for(int i = 0; i < (int)entity_list->length; i++) for(int i = 0; i < array_len(entity_list); i++)
entity_remove(i); entity_remove(i);
array_free(entity_list); array_free(entity_list);
@ -28,7 +28,7 @@ void entity_cleanup(void)
void entity_remove(int index) void entity_remove(int index)
{ {
struct Entity* entity = array_get(entity_list, index); struct Entity* entity = &entity_list[index];
for(int i = 0; i < MAX_COMPONENTS; i++) for(int i = 0; i < MAX_COMPONENTS; i++)
{ {
@ -54,16 +54,17 @@ struct Entity* entity_create(const char* name, const char* tag)
{ {
struct Entity* new_entity = NULL; struct Entity* new_entity = NULL;
int index = -1; int index = -1;
if(empty_indices->length > 0) int empty_len = array_len(empty_indices);
if(empty_len > 0)
{ {
index = array_get_last_val(empty_indices, int); index = empty_indices[empty_len - 1];
array_pop(empty_indices); array_pop(empty_indices);
new_entity = array_get(entity_list, index); new_entity = &entity_list[index];
} }
else else
{ {
new_entity = array_add(entity_list); new_entity = array_grow(entity_list, struct Entity);
index = entity_list->length - 1; index = array_len(entity_list) - 1;
} }
if(new_entity->name) free(new_entity->name); if(new_entity->name) free(new_entity->name);
@ -82,8 +83,8 @@ struct Entity* entity_create(const char* name, const char* tag)
struct Entity* entity_get(int index) struct Entity* entity_get(int index)
{ {
struct Entity* entity = NULL; struct Entity* entity = NULL;
if(index >= 0 && index < (int)entity_list->length) if(index >= 0 && index < array_len(entity_list))
entity = array_get(entity_list, index); entity = &entity_list[index];
else else
log_error("entity:get", "Invalid index '%d'", index); log_error("entity:get", "Invalid index '%d'", index);
return entity; return entity;
@ -93,9 +94,9 @@ struct Entity* entity_find(const char* name)
{ {
/* Bruteforce search all entities and return the first match */ /* Bruteforce search all entities and return the first match */
struct Entity* entity = NULL; struct Entity* entity = NULL;
for(int i = 0; i < (int)entity_list->length; i++) for(int i = 0; i < array_len(entity_list); i++)
{ {
struct Entity* curr_ent = array_get(entity_list, i); struct Entity* curr_ent = &entity_list[i];
if(strcmp(curr_ent->name, name) == 0) if(strcmp(curr_ent->name, name) == 0)
{ {
entity = curr_ent; entity = curr_ent;

3
src/game.c
Unescape View File

@ -1,4 +1,6 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include "GLFW/glfw3.h" #include "GLFW/glfw3.h"
#include "game.h" #include "game.h"
@ -9,6 +11,7 @@
#include "file_io.h" #include "file_io.h"
#include "shader.h" #include "shader.h"
#include "entity.h" #include "entity.h"
#include "array.h"
void run(void); void run(void);
void update(void); void update(void);

99
src/geometry.c
Unescape View File

@ -17,28 +17,28 @@
struct Geometry struct Geometry
{ {
char* filename; char* filename;
bool draw_indexed; bool draw_indexed;
uint vao; uint vao;
uint vertex_vbo; uint vertex_vbo;
uint uv_vbo; uint uv_vbo;
uint normal_vbo; uint normal_vbo;
uint color_vbo; uint color_vbo;
uint index_vbo; uint index_vbo;
uint ref_count; uint ref_count;
struct Array* vertices; vec3* vertices;
struct Array* vertex_colors; vec3* vertex_colors;
struct Array* normals; vec3* normals;
struct Array* uvs; vec2* uvs;
struct Array* indices; uint* indices;
/* BoundingBox boundingBox; */ /* BoundingBox boundingBox; */
/* BoundingSphere boundingSphere; */ /* BoundingSphere boundingSphere; */
}; };
/* Data */ /* Data */
static struct Array* geometry_list; static struct Geometry* geometry_list;
static struct Array* empty_indices; static int* empty_indices;
/* Function definitions */ /* Function definitions */
bool load_from_file(struct Geometry* geometry, const char* filename); bool load_from_file(struct Geometry* geometry, const char* filename);
@ -53,9 +53,9 @@ void geom_initialize(void)
int geom_find(const char* filename) int geom_find(const char* filename)
{ {
int index = -1; int index = -1;
for(int i = 0; i < (int)geometry_list->length; i++) for(int i = 0; i < array_len(geometry_list); i++)
{ {
struct Geometry* geometry = array_get(geometry_list, i); struct Geometry* geometry = &geometry_list[i];
if(strcmp(geometry->filename, filename) == 0) if(strcmp(geometry->filename, filename) == 0)
{ {
index = i; index = i;
@ -74,20 +74,20 @@ int geom_create(const char* name)
/* add new geometry object or overwrite existing one */ /* add new geometry object or overwrite existing one */
struct Geometry* new_geo = NULL; struct Geometry* new_geo = NULL;
int index = -1; int index = -1;
if(empty_indices->length != 0) int empty_len = array_len(empty_indices);
if(empty_len > 0)
{ {
index = array_get_last_val(empty_indices, int); index = empty_indices[empty_len - 1];
array_pop(empty_indices); array_pop(empty_indices);
new_geo = array_get(geometry_list, index); new_geo = &geometry_list[index];
} }
else else
{ {
new_geo = array_add(geometry_list); new_geo = array_grow(geometry_list, struct Geometry);
index = geometry_list->length - 1; index = array_len(geometry_list) - 1;
} }
assert(new_geo); assert(new_geo);
if(load_from_file(new_geo, name)) if(load_from_file(new_geo, name))
{ {
create_vao(new_geo); create_vao(new_geo);
@ -102,17 +102,16 @@ int geom_create(const char* name)
} }
else else
{ {
struct Geometry* raw_geom_array = array_get_raw(geometry_list, struct Geometry); geometry_list[index].ref_count++;
raw_geom_array[index].ref_count++;
} }
return index; return index;
} }
void geom_remove(int index) void geom_remove(int index)
{ {
if(index >= 0 && index < (int)geometry_list->length) if(index >= 0 && index < array_len(geometry_list))
{ {
struct Geometry* geometry = array_get(geometry_list, index); struct Geometry* geometry = &geometry_list[index];
array_free(geometry->indices); array_free(geometry->indices);
array_free(geometry->vertices); array_free(geometry->vertices);
array_free(geometry->uvs); array_free(geometry->uvs);
@ -125,7 +124,7 @@ void geom_remove(int index)
void geom_cleanup(void) void geom_cleanup(void)
{ {
for(uint i = 0; i < geometry_list->length; i++) for(int i = 0; i < array_len(geometry_list); i++)
geom_remove(i); geom_remove(i);
array_free(geometry_list); array_free(geometry_list);
@ -161,16 +160,16 @@ bool load_from_file(struct Geometry* geometry, const char* filename)
uint32 uvs_count = header[3]; uint32 uvs_count = header[3];
// Indices // Indices
geometry->indices = array_new_cap(uint, indices_count); geometry->indices = array_new_cap(uint, indices_count);
fread(geometry->indices->data, INDEX_SIZE, indices_count, file); fread(geometry->indices, INDEX_SIZE, indices_count, file);
// Vertices // Vertices
geometry->vertices = array_new_cap(uint, vertices_count); geometry->vertices = array_new_cap(vec3, vertices_count);
fread(geometry->vertices->data, VEC3_SIZE, vertices_count, file); fread(geometry->vertices, VEC3_SIZE, vertices_count, file);
// Normals // Normals
geometry->normals = array_new_cap(uint, normals_count); geometry->normals = array_new_cap(vec3, normals_count);
fread(&geometry->normals->data, VEC3_SIZE, normals_count, file); fread(geometry->normals, VEC3_SIZE, normals_count, file);
// Uvs // Uvs
geometry->uvs = array_new_cap(uint, uvs_count); geometry->uvs = array_new_cap(vec2, uvs_count);
fread(&geometry->uvs->data, VEC2_SIZE, uvs_count, file); fread(geometry->uvs, VEC2_SIZE, uvs_count, file);
} }
fclose(file); fclose(file);
geometry->filename = str_new(filename); geometry->filename = str_new(filename);
@ -195,59 +194,59 @@ void create_vao(struct Geometry* geometry)
glGenBuffers(1, &geometry->vertex_vbo); glGenBuffers(1, &geometry->vertex_vbo);
glBindBuffer(GL_ARRAY_BUFFER, geometry->vertex_vbo); glBindBuffer(GL_ARRAY_BUFFER, geometry->vertex_vbo);
glBufferData(GL_ARRAY_BUFFER, glBufferData(GL_ARRAY_BUFFER,
geometry->vertices->length * sizeof(vec3), array_len(geometry->vertices) * sizeof(vec3),
geometry->vertices->data, geometry->vertices,
GL_STATIC_DRAW); GL_STATIC_DRAW);
renderer_check_glerror("Geometry::create_vbo::vertex"); renderer_check_glerror("Geometry::create_vbo::vertex");
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
if(geometry->normals->length > 0) if(array_len(geometry->normals) > 0)
{ {
glGenBuffers(1, &geometry->normal_vbo); glGenBuffers(1, &geometry->normal_vbo);
glBindBuffer(GL_ARRAY_BUFFER, geometry->normal_vbo); glBindBuffer(GL_ARRAY_BUFFER, geometry->normal_vbo);
glBufferData(GL_ARRAY_BUFFER, glBufferData(GL_ARRAY_BUFFER,
geometry->normals->length * sizeof(vec3), array_len(geometry->normals) * sizeof(vec3),
geometry->normals->data, geometry->normals,
GL_STATIC_DRAW); GL_STATIC_DRAW);
renderer_check_glerror("Geometry::create_vbo::normal"); renderer_check_glerror("Geometry::create_vbo::normal");
glEnableVertexAttribArray(1); glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_TRUE, 0, 0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_TRUE, 0, 0);
} }
if(geometry->uvs->length > 0) if(array_len(geometry->uvs) > 0)
{ {
glGenBuffers(1, &geometry->uv_vbo); glGenBuffers(1, &geometry->uv_vbo);
glBindBuffer(GL_ARRAY_BUFFER, geometry->uv_vbo); glBindBuffer(GL_ARRAY_BUFFER, geometry->uv_vbo);
glBufferData(GL_ARRAY_BUFFER, glBufferData(GL_ARRAY_BUFFER,
geometry->uvs->length * sizeof(vec2), array_len(geometry->uvs) * sizeof(vec2),
geometry->uvs->data, geometry->uvs,
GL_STATIC_DRAW); GL_STATIC_DRAW);
renderer_check_glerror("Geometry::create_vbo::uv"); renderer_check_glerror("Geometry::create_vbo::uv");
glEnableVertexAttribArray(2); glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 0); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 0);
} }
if(geometry->vertex_colors->length > 0) if(array_len(geometry->vertex_colors) > 0)
{ {
glGenBuffers(1, &geometry->color_vbo); glGenBuffers(1, &geometry->color_vbo);
glBindBuffer(GL_ARRAY_BUFFER, geometry->color_vbo); glBindBuffer(GL_ARRAY_BUFFER, geometry->color_vbo);
glBufferData(GL_ARRAY_BUFFER, glBufferData(GL_ARRAY_BUFFER,
geometry->vertex_colors->length * sizeof(vec3), array_len(geometry->vertex_colors) * sizeof(vec3),
geometry->vertex_colors->data, geometry->vertex_colors,
GL_STATIC_DRAW); GL_STATIC_DRAW);
renderer_check_glerror("Geometry::create_vbo::color"); renderer_check_glerror("Geometry::create_vbo::color");
glEnableVertexAttribArray(3); glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, 0); glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, 0);
} }
if(geometry->indices->length > 0) if(array_len(geometry->indices) > 0)
{ {
glGenBuffers(1, &geometry->index_vbo); glGenBuffers(1, &geometry->index_vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, geometry->index_vbo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, geometry->index_vbo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, glBufferData(GL_ELEMENT_ARRAY_BUFFER,
geometry->indices->length * sizeof(GLuint), array_len(geometry->indices) * sizeof(GLuint),
geometry->indices->data, geometry->indices,
GL_STATIC_DRAW); GL_STATIC_DRAW);
geometry->draw_indexed = true; geometry->draw_indexed = true;
} }

54
src/input.c
Unescape View File

@ -11,12 +11,19 @@
#define KS_INACTIVE -1; /* state for input map is set to KS_INACTIVE(KeyState_Inactive) when #define KS_INACTIVE -1; /* state for input map is set to KS_INACTIVE(KeyState_Inactive) when
the key is neither pressed nor released */ the key is neither pressed nor released */
struct Input_Map
{
const char* name;
int* keys;
int state;
};
static void input_on_key(GLFWwindow* window, int key, int scancode, int action, int mods); static void input_on_key(GLFWwindow* window, int key, int scancode, int action, int mods);
static void input_on_mousebutton(GLFWwindow* window, int button, int action, int mods); static void input_on_mousebutton(GLFWwindow* window, int button, int action, int mods);
static void input_on_cursor_move(GLFWwindow* window, double xpos, double ypos); static void input_on_cursor_move(GLFWwindow* window, double xpos, double ypos);
static int map_find(const char* name); static int map_find(const char* name);
static struct Array* input_map_list; static struct Input_Map* input_map_list;
void input_init(GLFWwindow* window) void input_init(GLFWwindow* window)
{ {
@ -29,9 +36,9 @@ void input_init(GLFWwindow* window)
void input_cleanup(void) void input_cleanup(void)
{ {
for(unsigned int i = 0; i < input_map_list->length; i++) for(int i = 0; i < array_len(input_map_list); i++)
{ {
struct Input_Map* map = array_get(input_map_list, i); struct Input_Map* map = &input_map_list[i];
array_free(map->keys); array_free(map->keys);
} }
array_free(input_map_list); array_free(input_map_list);
@ -51,13 +58,12 @@ void input_cursor_pos_get(double* xpos, double* ypos)
static void input_on_key(GLFWwindow* window, int key, int scancode, int action, int mods) static void input_on_key(GLFWwindow* window, int key, int scancode, int action, int mods)
{ {
for(unsigned int i = 0; i < input_map_list->length; i++) for(int i = 0; i < array_len(input_map_list); i++)
{ {
struct Input_Map* map = array_get(input_map_list, i); struct Input_Map* map = &input_map_list[i];
for(unsigned int j = 0; j < map->keys->length; j++) for(int j = 0; j < array_len(map->keys); j++)
{ {
int map_key = array_get_val(map->keys, int, j); if(map->keys[i] == key)
if(map_key == key)
{ {
map->state = action; map->state = action;
break; break;
@ -88,9 +94,9 @@ void input_cursor_mode_set(enum Cursor_Mode mode)
bool input_map_state_get(const char* map_name, int state) bool input_map_state_get(const char* map_name, int state)
{ {
int current_state = KS_INACTIVE; int current_state = KS_INACTIVE;
for(unsigned int i = 0; i < input_map_list->length; i++) for(int i = 0; i < array_len(input_map_list); i++)
{ {
struct Input_Map* map = array_get(input_map_list, i); struct Input_Map* map = &input_map_list[i];
if(strcmp(map->name, map_name) == 0) if(strcmp(map->name, map_name) == 0)
{ {
current_state = map->state; current_state = map->state;
@ -118,22 +124,21 @@ void input_map_create(const char* name, int* keys, size_t num_keys)
{ {
assert(name && keys && num_keys > 0); assert(name && keys && num_keys > 0);
struct Input_Map* new_map = array_add(input_map_list); struct Input_Map* new_map = array_grow(input_map_list, struct Input_Map);
new_map->name = name; new_map->name = name;
new_map->keys = array_new(int); new_map->keys = array_new(int);
new_map->state = KS_INACTIVE; new_map->state = KS_INACTIVE;
for(size_t i = 0; i < num_keys; i++) for(size_t i = 0; i < num_keys; i++)
{ {
int* key = array_add(new_map->keys); array_push(new_map->keys, keys[i], int);
*key = keys[i];
} }
} }
void input_update(void) void input_update(void)
{ {
for(unsigned int i = 0; i < input_map_list->length; i++) for(int i = 0; i < array_len(input_map_list); i++)
{ {
struct Input_Map* map = array_get(input_map_list, i); struct Input_Map* map = &input_map_list[i];
if(map->state == GLFW_RELEASE) if(map->state == GLFW_RELEASE)
map->state = KS_INACTIVE; map->state = KS_INACTIVE;
} }
@ -146,7 +151,7 @@ bool input_map_remove(const char* name)
int index = map_find(name); int index = map_find(name);
if(index > -1) if(index > -1)
{ {
array_remove_at(input_map_list, (unsigned int)index); array_remove_at(input_map_list, (int)index);
success = true; success = true;
} }
if(!success) log_error("input:map_remove", "Map %s not found", name); if(!success) log_error("input:map_remove", "Map %s not found", name);
@ -161,17 +166,14 @@ bool input_map_keys_set(const char* name, int* keys, int num_keys)
int index = map_find(name); int index = map_find(name);
if(index > -1) if(index > -1)
{ {
struct Input_Map* map = array_get(input_map_list, (unsigned int)index); struct Input_Map* map = &input_map_list[index];
array_reset(map->keys, num_keys); array_reset(map->keys, num_keys);
for(int i = 0; i < num_keys; i++) for(int i = 0; i < num_keys; i++)
{ map->keys[i] = keys[i];
int* key = array_get(map->keys, (unsigned int)i);
*key = keys[i];
}
success = true; success = true;
} }
if(!success) log_error("input:map_keys_set", "Map %s not found", name); if(!success)
log_error("input:map_keys_set", "Map %s not found", name);
return success; return success;
} }
@ -182,7 +184,7 @@ bool input_map_name_set(const char* name, const char* new_name)
int index = map_find(name); int index = map_find(name);
if(index > -1) if(index > -1)
{ {
struct Input_Map* map = array_get(input_map_list, (unsigned int)index); struct Input_Map* map = &input_map_list[index];
map->name = new_name; map->name = new_name;
success = true; success = true;
} }
@ -193,9 +195,9 @@ bool input_map_name_set(const char* name, const char* new_name)
static int map_find(const char* name) static int map_find(const char* name)
{ {
int index = -1; int index = -1;
for(unsigned int i = 0; i < input_map_list->length; i++) for(int i = 0; i < array_len(input_map_list); i++)
{ {
struct Input_Map* map = array_get(input_map_list, i); struct Input_Map* map = &input_map_list[i];
if(strcmp(name, map->name) == 0) if(strcmp(name, map->name) == 0)
{ {
index = i; index = i;

8
src/input.h
Unescape View File

@ -5,7 +5,6 @@
#include <stdlib.h> #include <stdlib.h>
typedef struct GLFWwindow GLFWwindow; typedef struct GLFWwindow GLFWwindow;
struct Array;
enum Cursor_Mode enum Cursor_Mode
{ {
@ -15,13 +14,6 @@ enum Cursor_Mode
}; };
struct Input_Map
{
struct Array* keys;
const char* name;
int state;
};
void input_init(GLFWwindow* window); void input_init(GLFWwindow* window);
void input_cleanup(void); void input_cleanup(void);
bool input_mousebutton_state_get(int button, int state_type); bool input_mousebutton_state_get(int button, int state_type);

26
src/shader.c
Unescape View File

@ -28,8 +28,8 @@ const int NORMAL_LOC = 1;
const int UV_LOC = 2; const int UV_LOC = 2;
const int COLOR_LOC = 3; const int COLOR_LOC = 3;
static struct Array* shader_list; static struct Shader_Object* shader_list;
static struct Array* empty_indices; static int* empty_indices;
void debug_print_shader(const char* shaderText) void debug_print_shader(const char* shaderText)
{ {
@ -201,16 +201,17 @@ int shader_create(const char* vert_shader_name, const char* frag_shader_name)
/* add new object or overwrite existing one */ /* add new object or overwrite existing one */
Shader_Object* new_object = NULL; Shader_Object* new_object = NULL;
int index = -1; int index = -1;
if(empty_indices->length != 0) int empty_len = array_len(empty_indices);
if(empty_len != 0)
{ {
index = array_get_last_val(empty_indices, int); index = empty_indices[empty_len - 1];
array_pop(empty_indices); array_pop(empty_indices);
new_object = array_get(shader_list, index); new_object = &shader_list[index];
} }
else else
{ {
new_object = array_add(shader_list); new_object = array_grow(shader_list, struct Shader_Object);
index = shader_list->length - 1; index = array_len(shader_list) - 1;
} }
assert(new_object); assert(new_object);
new_object->vertex_shader = vert_shader; new_object->vertex_shader = vert_shader;
@ -226,8 +227,7 @@ int shader_create(const char* vert_shader_name, const char* frag_shader_name)
void shader_bind(const int shader_index) void shader_bind(const int shader_index)
{ {
Shader_Object* shader_object = array_get(shader_list, shader_index); glUseProgram(shader_list[shader_index].program);
glUseProgram(shader_object->program);
} }
void shader_unbind(void) void shader_unbind(void)
@ -237,9 +237,7 @@ void shader_unbind(void)
int get_uniform_location(const int shader_index, const char* name) int get_uniform_location(const int shader_index, const char* name)
{ {
Shader_Object shader_object = array_get_val(shader_list, Shader_Object, shader_index); GLint handle = glGetUniformLocation(shader_list[shader_index].program, name);
GLint handle = glGetUniformLocation(shader_object.program, name);
if(handle == -1) if(handle == -1)
log_error("shader:get_uniform_location", "Invalid uniform %s", name); log_error("shader:get_uniform_location", "Invalid uniform %s", name);
@ -290,7 +288,7 @@ void setUniformMat4(const int shader_index, const char* name, const mat4 value)
void shader_remove(const int shader_index) void shader_remove(const int shader_index)
{ {
Shader_Object* shader_object = array_get(shader_list, shader_index); Shader_Object* shader_object = &shader_list[shader_index];
glDeleteProgram(shader_object->program); glDeleteProgram(shader_object->program);
glDeleteShader(shader_object->vertex_shader); glDeleteShader(shader_object->vertex_shader);
glDeleteShader(shader_object->fragment_shader); glDeleteShader(shader_object->fragment_shader);
@ -300,7 +298,7 @@ void shader_remove(const int shader_index)
void shader_cleanup(void) void shader_cleanup(void)
{ {
for(int i = 0; i < (int)shader_list->length; i++) for(int i = 0; i < array_len(shader_list); i++)
shader_remove(i); shader_remove(i);
array_free(shader_list); array_free(shader_list);

30
src/string_utils.c
Unescape View File

@ -28,42 +28,42 @@ char* str_concat(char* string, const char* str_to_concat)
char* str_replace(char* string, const char* pattern, const char* replacement) char* str_replace(char* string, const char* pattern, const char* replacement)
{ {
struct Array* indices = array_new(unsigned int); int* indices = array_new(int);
size_t string_len = strlen(string); size_t string_len = strlen(string);
/* Calculate size of new string and allocate new memory */ /* Calculate size of new string and allocate new memory */
size_t pattern_len = strlen(pattern); size_t pattern_len = strlen(pattern);
size_t replacement_len = strlen(replacement); size_t replacement_len = strlen(replacement);
bool done = false; int done = 0;
char* remaining_string = string; char* remaining_string = string;
while(!done) while(!done)
{ {
char* location = strstr(remaining_string, pattern); char* location = strstr(remaining_string, pattern);
if(location) if(location)
{ {
unsigned int index = location - string; int index = location - string;
unsigned int* new_index = array_add(indices); array_push(indices, index, int);
*new_index = index;
remaining_string = location + pattern_len; /* Find the next occurance in the remaining string */ remaining_string = location + pattern_len; /* Find the next occurance in the remaining string */
} }
else else
{ {
done = true; done = 1;
} }
} }
if(indices->length > 0) int num_indices = array_len(indices);
if(num_indices > 0)
{ {
size_t string_len_without_pattern = string_len - (pattern_len * indices->length); size_t string_len_without_pattern = string_len - (pattern_len * num_indices);
size_t new_string_len = string_len_without_pattern + (replacement_len * indices->length); size_t new_string_len = string_len_without_pattern + (replacement_len * num_indices);
char* new_string = malloc(new_string_len); char* new_string = malloc(new_string_len);
if(new_string) if(new_string)
{ {
done = false; done = 0;
unsigned int count = 0; int count = 0;
unsigned int index = array_get_val(indices, unsigned int, count); int index = indices[count];
unsigned int prev_index = 0; unsigned int prev_index = 0;
while(!done) while(!done)
{ {
@ -76,15 +76,15 @@ char* str_replace(char* string, const char* pattern, const char* replacement)
count++; count++;
prev_index = index + pattern_len; prev_index = index + pattern_len;
if(count == indices->length) if(count == array_len(indices))
{ {
done = true; done = 1;
source_beg = string + prev_index; source_beg = string + prev_index;
strcat(new_string, source_beg); strcat(new_string, source_beg);
} }
else else
{ {
index = array_get_val(indices, unsigned int, count); index = indices[count];
} }
} }
free(string); free(string);

3
src/transform.c
Unescape View File

@ -0,0 +1,3 @@
#include "transform.h"

17
src/transform.h
Unescape View File

@ -0,0 +1,17 @@
#ifndef _transform_H
#define _transform_H
#include "linmath.h"
struct Transform
{
vec3 position;
vec3 scale;
quat rotation;
};
void transform_initialize(void);
void transform_cleanup(void);
int transform_create(int node);
#endif
Write Preview
Loading…
Cancel
Save