epickh
/
Techneck
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added block creation utilities

This commit is contained in:
Eric-Paul Ickhorn 2023-10-12 08:18:43 +02:00
parent 6c57999c8f
commit f12bcee579
13 changed files with 452 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
build.bash
View File

@ -4,9 +4,9 @@ mkdir -p dependencies/build/
gcc -g -o dependencies/build/glad.o \ gcc -g -o dependencies/build/glad.o \
-c dependencies/sources/glad/glad.c \ -c dependencies/sources/glad/glad.c \
-I dependencies/include/ -I dependencies/include/ -Wall
gcc -g -o techneck.elf \ gcc -g -o techneck.elf \
code/source-c/*.c dependencies/build/glad.o \ code/source-c/*.c dependencies/build/glad.o \
-I dependencies/include -lGL -lSDL2 -lm -I dependencies/include -lGL -lSDL2 -lm -Wall

86
code/source-c/assets.c
View File

@ -6,6 +6,9 @@
#define STB_IMAGE_IMPLEMENTATION #define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h> #include <stb_image.h>
// TODO: This can be done better.
uint32_t tc_image_id_counter = 1;
tc_asset_storage_s tc_init_asset_storage(char *asset_folder_path) tc_asset_storage_s tc_init_asset_storage(char *asset_folder_path)
{ {
tc_asset_storage_s assets; tc_asset_storage_s assets;
@ -35,17 +38,26 @@ void tc_upload_image(tc_image_s *image)
GL_UNSIGNED_BYTE, GL_UNSIGNED_BYTE,
image->pixels image->pixels
); );
image->is_uploaded = true;
} }
tc_image_s * tc_load_image_from_disk(char *path) tc_image_s * tc_load_image_from_disk(char *path)
{ {
tc_image_s *image = malloc(sizeof(tc_image_s)); tc_image_s *image = malloc(sizeof(tc_image_s));
image->attributes_capacity = 8; image->attributes_capacity = 8;
image->attributes = calloc(sizeof(tc_asset_attribute_s), image->attributes_capacity); image->attributes =
calloc(sizeof(tc_asset_attribute_s), image->attributes_capacity);
image->num_attributes = 0; image->num_attributes = 0;
image->pixels = stbi_load(path, &image->width, &image->height, NULL, 4); image->pixels = stbi_load(path, &image->width, &image->height, NULL, 4);
image->len_name = 0; image->len_name = 0;
image->name = NULL; image->name = NULL;
image->x = 0;
image->y = 0;
image->is_subimage = false;
image->superimage = NULL;
image->image_id = tc_image_id_counter;
++tc_image_id_counter;
if(tc_game_state_g.asset_storage.num_images >= tc_game_state_g.asset_storage.images_capacity) if(tc_game_state_g.asset_storage.num_images >= tc_game_state_g.asset_storage.images_capacity)
{ {
@ -57,7 +69,79 @@ tc_image_s * tc_load_image_from_disk(char *path)
} }
tc_game_state_g.asset_storage.images[tc_game_state_g.asset_storage.num_images] = image; tc_game_state_g.asset_storage.images[tc_game_state_g.asset_storage.num_images] = image;
++tc_game_state_g.asset_storage.num_images;
return image; return image;
} }
tc_image_s * tc_create_subimage(tc_image_s *superimage,
uint32_t x, uint32_t y,
uint32_t width, uint32_t height
) {
if(!superimage->is_uploaded)
{
puts("Superimages must have been uploaded before creating a subimage!");
return NULL;
}
tc_image_s *image = malloc(sizeof(tc_image_s));
image->attributes_capacity = 8;
image->attributes =
calloc(sizeof(tc_asset_attribute_s), image->attributes_capacity);
image->num_attributes = 0;
image->pixels = NULL;
image->len_name = 0;
image->name = NULL;
image->x = x;
image->y = y;
image->is_subimage = true;
image->width = width;
image->height = height;
image->superimage = superimage;
image->image_id = tc_image_id_counter;
++tc_image_id_counter;
if(tc_game_state_g.asset_storage.num_images >= tc_game_state_g.asset_storage.images_capacity)
{
tc_game_state_g.asset_storage.images_capacity *= 2;
tc_game_state_g.asset_storage.images =
realloc(tc_game_state_g.asset_storage.images,
sizeof(tc_image_s *) * tc_game_state_g.asset_storage.images_capacity
);
}
tc_game_state_g.asset_storage.images[tc_game_state_g.asset_storage.num_images] = image;
++tc_game_state_g.asset_storage.num_images;
return tc_game_state_g.asset_storage.images[tc_game_state_g.asset_storage.num_images-1];
}
tc_image_s * tc_resolve_id_to_image(uint32_t id)
{
uint32_t image_index = 0;
while(image_index < tc_game_state_g.asset_storage.num_images)
{
if(tc_game_state_g.asset_storage.images[image_index]->image_id == id)
return tc_game_state_g.asset_storage.images[image_index];
++image_index;
}
return NULL;
}
tc_image_s * tc_resolve_name_to_image(char *name)
{
uint32_t image_index = 0;
while(image_index < tc_game_state_g.asset_storage.num_images)
{
if(tc_game_state_g.asset_storage.images[image_index]->name == NULL)
{
++image_index;
continue;
}
if(!strcmp(tc_game_state_g.asset_storage.images[image_index]->name, name))
return tc_game_state_g.asset_storage.images[image_index];
++image_index;
}
return NULL;
}

25
code/source-c/assets.h
View File

@ -6,6 +6,8 @@
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
typedef struct tc_image tc_image_s;
typedef struct tc_asset_attribute typedef struct tc_asset_attribute
{ {
char *issuer; char *issuer;
@ -21,9 +23,15 @@ typedef struct tc_asset_attribute
} tc_asset_attribute_s; } tc_asset_attribute_s;
typedef struct tc_image struct tc_image
{ {
bool is_subimage;
bool is_uploaded;
tc_image_s *superimage;
uint32_t gl_identifier; uint32_t gl_identifier;
uint32_t image_id;
uint32_t len_name; uint32_t len_name;
char *name; char *name;
@ -32,18 +40,20 @@ typedef struct tc_image
uint32_t num_attributes; uint32_t num_attributes;
tc_asset_attribute_s *attributes; tc_asset_attribute_s *attributes;
uint32_t x; // Only used if this is a subimage
uint32_t y; // Only used if this is a subimage
uint32_t width; uint32_t width;
uint32_t height; uint32_t height;
void *pixels; void *pixels;
} tc_image_s; };
typedef struct tc_asset_storage typedef struct tc_asset_storage
{ {
uint32_t images_capacity; uint32_t images_capacity;
uint32_t num_images; uint32_t num_images;
tc_image_s **images; tc_image_s **images;
// todo: meshes // todo: meshes
} tc_asset_storage_s; } tc_asset_storage_s;
@ -52,5 +62,12 @@ tc_asset_storage_s tc_init_asset_storage (char *asset_folder_
tc_image_s * tc_load_image_from_disk (char *path); tc_image_s * tc_load_image_from_disk (char *path);
void tc_upload_image (tc_image_s *image); void tc_upload_image (tc_image_s *image);
tc_image_s * tc_resolve_id_to_image (uint32_t id);
tc_image_s * tc_resolve_name_to_image (char *name);
tc_image_s * tc_create_subimage(tc_image_s *superimage,
uint32_t x, uint32_t y,
uint32_t width, uint32_t height);
#endif #endif

138
code/source-c/blocks.c
View File

@ -3,18 +3,34 @@
#include <stdlib.h> #include <stdlib.h>
tc_block_entry_s tc_new_block_entry(char *name)
tc_block_entry_s * tc_new_block_entry(char *name)
{ {
tc_block_entry_s entry; tc_block_entry_s *entry = malloc(sizeof(tc_block_entry_s));
entry.name = name; entry->name = name;
entry.attributes_capacity = 16; entry->attributes_capacity = 16;
entry.num_attributes = 0; entry->num_attributes = 0;
entry.attributes = calloc(sizeof(tc_block_attribute_s), entry.attributes_capacity); entry->attributes = calloc(
sizeof(tc_block_attribute_s), entry->attributes_capacity
);
if(tc_game_state_g.block_registry.num_blocks >= tc_game_state_g.block_registry.blocks_capacity)
{
tc_game_state_g.block_registry.blocks =
realloc(tc_game_state_g.block_registry.blocks,
sizeof(tc_block_entry_s)
*
tc_game_state_g.block_registry.blocks_capacity
);
}
tc_game_state_g.block_registry.blocks[tc_game_state_g.block_registry.num_blocks] = entry;
++tc_game_state_g.block_registry.num_blocks;
return entry; return entry;
} }
void tc_add_attribute_to_block(tc_block_entry_s *entry, tc_block_attribute_s attribute) void tc_add_attribute_to_block_entry(tc_block_entry_s *entry, tc_block_attribute_s attribute)
{ {
if(entry->num_attributes >= entry->attributes_capacity) if(entry->num_attributes >= entry->attributes_capacity)
{ {
@ -24,6 +40,21 @@ void tc_add_attribute_to_block(tc_block_entry_s *entry, tc_block_attribute_s att
} }
entry->attributes[entry->num_attributes] = attribute; entry->attributes[entry->num_attributes] = attribute;
++entry->num_attributes;
}
tc_block_attribute_s * tc_block_resolve_name_to_attribute(tc_block_entry_s *block, char *name)
{
uint32_t attribute_index = 0;
while(attribute_index < block->num_attributes)
{
if(!strcmp(block->attributes[attribute_index].name, name))
return &block->attributes[attribute_index];
++attribute_index;
}
return NULL;
} }
tc_block_entry_s * tc_get_block(char *name) tc_block_entry_s * tc_get_block(char *name)
@ -31,20 +62,109 @@ tc_block_entry_s * tc_get_block(char *name)
uint32_t index = 0; uint32_t index = 0;
while(index < tc_game_state_g.block_registry.num_blocks) while(index < tc_game_state_g.block_registry.num_blocks)
{ {
if(!strcmp(tc_game_state_g.block_registry.blocks[index].name, name)) if(!strcmp(tc_game_state_g.block_registry.blocks[index]->name, name))
return &tc_game_state_g.block_registry.blocks[index]; return tc_game_state_g.block_registry.blocks[index];
++index; ++index;
} }
return NULL; return NULL;
} }
tc_block_entry_s * tc_resolve_id_to_block_entry(uint32_t id)
{
uint32_t index = 0;
while(index < tc_game_state_g.block_registry.num_blocks)
{
if(tc_game_state_g.block_registry.blocks[index]->identifier == id)
{
return tc_game_state_g.block_registry.blocks[index];
}
++index;
}
return NULL;
}
tc_block_registry_s tc_init_blocks() tc_block_registry_s tc_init_blocks()
{ {
tc_block_registry_s registry; tc_block_registry_s registry;
registry.blocks_capacity = 256; registry.blocks_capacity = 256;
registry.num_blocks = 0;
registry.blocks = calloc(sizeof(tc_block_entry_s), registry.blocks_capacity); registry.blocks = calloc(sizeof(tc_block_entry_s), registry.blocks_capacity);
return registry; return registry;
} }
tc_block_entry_s * tc_new_cube_block(tc_cube_info_s info)
{
tc_block_entry_s *entry = tc_new_block_entry(info.name);
entry->identifier = info.identifier;
tc_block_attribute_s block_type_attrib;
block_type_attrib.name = "block_type";
block_type_attrib.value.string = "basic_cube";
tc_add_attribute_to_block_entry(entry, block_type_attrib);
tc_block_attribute_s top_attrib;
top_attrib.name = "top_texture";
top_attrib.value.pointer = tc_resolve_id_to_image(info.texture_top);
tc_add_attribute_to_block_entry(entry, top_attrib);
tc_block_attribute_s bottom_attrib;
bottom_attrib.name = "bottom_texture";
bottom_attrib.value.pointer = tc_resolve_id_to_image(info.texture_bottom);
tc_add_attribute_to_block_entry(entry, bottom_attrib);
tc_block_attribute_s east_attrib;
east_attrib.name = "east_texture";
east_attrib.value.pointer = tc_resolve_id_to_image(info.texture_east);
tc_add_attribute_to_block_entry(entry, east_attrib);
tc_block_attribute_s west_attrib;
west_attrib.name = "west_texture";
west_attrib.value.pointer = tc_resolve_id_to_image(info.texture_west);
tc_add_attribute_to_block_entry(entry, west_attrib);
tc_block_attribute_s back_attrib;
back_attrib.name = "back_texture";
back_attrib.value.pointer = tc_resolve_id_to_image(info.texture_back);
tc_add_attribute_to_block_entry(entry, back_attrib);
tc_block_attribute_s front_attrib;
front_attrib.name = "front_texture";
front_attrib.value.pointer = tc_resolve_id_to_image(info.texture_front);
tc_add_attribute_to_block_entry(entry, front_attrib);
return entry;
}
tc_cube_info_s tc_gen_unitexture_cube_info
(char *name, uint32_t identifier, uint32_t texture)
{
tc_cube_info_s cube_info;
cube_info.name = name;
cube_info.identifier = identifier;
cube_info.texture_top = texture;
cube_info.texture_bottom = texture;
cube_info.texture_east = texture;
cube_info.texture_west = texture;
cube_info.texture_back = texture;
cube_info.texture_front = texture;
return cube_info;
}
void tc_create_blocks()
{
tc_image_s *dirt_texture = tc_resolve_name_to_image("dirt");
tc_image_s *grass_texture = tc_resolve_name_to_image("grass");
tc_image_s *stone_texture = tc_resolve_name_to_image("stone");
tc_cube_info_s dirt = tc_gen_unitexture_cube_info("Dirt", 1, dirt_texture->image_id);
tc_cube_info_s grass = tc_gen_unitexture_cube_info("Grass", 2, grass_texture->image_id);
tc_cube_info_s stone = tc_gen_unitexture_cube_info("Stone", 3, stone_texture->image_id);
tc_new_cube_block(dirt);
tc_new_cube_block(grass);
tc_new_cube_block(stone);
}

44
code/source-c/blocks.h
View File

@ -9,11 +9,13 @@
typedef struct tc_block_attribute typedef struct tc_block_attribute
{ {
uint32_t len_name;
uint32_t len_content;
char *name; char *name;
void *content;
union {
void *pointer;
char *string;
int64_t integer;
} value;
} tc_block_attribute_s; } tc_block_attribute_s;
@ -32,16 +34,44 @@ typedef struct tc_block_registry
{ {
uint32_t blocks_capacity; uint32_t blocks_capacity;
uint32_t num_blocks; uint32_t num_blocks;
tc_block_entry_s *blocks; tc_block_entry_s **blocks;
} tc_block_registry_s; } tc_block_registry_s;
tc_block_entry_s tc_new_block_entry (char *name);
void tc_add_attribute_to_block
tc_block_entry_s * tc_new_block_entry (char *name);
void tc_add_attribute_to_block_entry
(tc_block_entry_s *entry, tc_block_attribute_s attribute); (tc_block_entry_s *entry, tc_block_attribute_s attribute);
tc_block_attribute_s * tc_block_resolve_name_to_attribute (tc_block_entry_s *block, char *name);
tc_block_entry_s * tc_get_block (char *name); tc_block_entry_s * tc_get_block (char *name);
tc_block_entry_s * tc_resolve_id_to_block_entry (uint32_t id);
tc_block_registry_s tc_init_blocks (); tc_block_registry_s tc_init_blocks ();
typedef struct tc_cube_info
{
char *name;
uint32_t identifier;
uint32_t texture_top;
uint32_t texture_bottom;
uint32_t texture_east;
uint32_t texture_west;
uint32_t texture_back;
uint32_t texture_front;
} tc_cube_info_s;
tc_cube_info_s tc_gen_unitexture_cube_info
(char *name, uint32_t identifier, uint32_t texture);
tc_block_entry_s * tc_new_cube_block (tc_cube_info_s info);
void tc_create_blocks ();
#endif #endif

3
code/source-c/default_terrain_generator.c
View File

@ -28,4 +28,5 @@ bool tc_generate_default_terrain_chunk(tc_worldgen_s *gen, tc_chunk_s *chunk)
} }
return true; return true;
} }

36
code/source-c/initialization.c
View File

@ -3,7 +3,8 @@
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
const char *tc_window_title_g = "Techneck"; const char *tc_window_title_g = "Techneck";
techneck_s tc_game_state_g;
void tc_init_renderer(techneck_s *techneck) void tc_init_renderer(techneck_s *techneck)
{ {
@ -29,24 +30,41 @@ void tc_init_renderer(techneck_s *techneck)
techneck->renderer.draw_shader = tc_make_shader_program("vertex_shader.glsl", "fragment_shader.glsl"); techneck->renderer.draw_shader = tc_make_shader_program("vertex_shader.glsl", "fragment_shader.glsl");
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
} }
void tc_load_textures() void tc_load_textures()
{ {
tc_game_state_g.block_texture_atlas = tc_load_image_from_disk("assets/block_atlas.png"); tc_game_state_g.block_texture_atlas = tc_load_image_from_disk("assets/block_atlas.png");
tc_game_state_g.block_texture_atlas->name = "Atlas";
tc_upload_image(tc_game_state_g.block_texture_atlas); tc_upload_image(tc_game_state_g.block_texture_atlas);
tc_image_s *dirt =
tc_create_subimage(tc_game_state_g.block_texture_atlas, 0, 0, 8, 8);
dirt->name = "dirt";
printf("POiNTA: %p!\n", dirt);
printf("Resolving from array: %p\n", tc_game_state_g.asset_storage.images);
tc_image_s *grass =
tc_create_subimage(tc_game_state_g.block_texture_atlas, 8, 0, 8, 8);
grass->name = "grass";
tc_image_s *stone =
tc_create_subimage(tc_game_state_g.block_texture_atlas, 16, 0, 8, 8);
stone->name = "stone";
} }
techneck_s tc_init() void tc_init()
{ {
techneck_s techneck; tc_init_renderer(&tc_game_state_g);
tc_init_renderer(&techneck); tc_game_state_g.asset_storage = tc_init_asset_storage("assets/");
techneck.main_world = tc_init_worlds(); tc_load_textures();
techneck.asset_storage = tc_init_asset_storage("assets/"); tc_game_state_g.block_registry = tc_init_blocks();
techneck.block_registry = tc_init_blocks(); tc_create_blocks();
tc_game_state_g.main_world = tc_init_worlds();
return techneck; puts("Finished initializing!");
} }
void tc_cleanup() void tc_cleanup()

72
code/source-c/main.c
View File

@ -1,7 +1,5 @@
#include "state.h" #include "state.h"
techneck_s tc_game_state_g;
#include <glad/glad.h> #include <glad/glad.h>
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include <linmath.h> #include <linmath.h>
@ -13,57 +11,57 @@ float triangle_vertices[108] =
{ {
// Front // Front
-0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f,
-0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f,
0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f,
0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f,
0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f,
-0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f,
// Back // Back
-0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f,
0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f,
0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f,
0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
// Left // Left
-0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f,
-0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f,
-0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f,
-0.5f, -0.5f, 0.5f, -0.5f, 0.5f, -0.5f,
// Right // Right
0.5f, 0.5f, -0.5f, 0.5f, -0.5f, 0.5f,
0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f,
0.5f, -0.5f, 0.5f, 0.5f, 0.5f, -0.5f,
0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f,
0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f,
// Top // Top
-0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f,
-0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f,
0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f,
0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f,
-0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f,
// Bottom // Bottom
-0.5f, -0.5f, 0.5f,
-0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f,
-0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f,
0.5f, -0.5f, -0.5f,
0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f,
-0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f,
0.5f, -0.5f, -0.5f 0.5f, -0.5f, -0.5f
}; };
tc_vec3_s tc_camera_position = { 0.0f, 0.0f, 0.0f }; tc_vec3_s tc_camera_position = { 0.0f, 0.0f, 0.0f };
@ -300,12 +298,12 @@ bool update()
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
tc_game_state_g = tc_init(); tc_init();
tc_new_chunk(&tc_game_state_g.main_world, 1.0f, 1.0f, 1.0f); tc_new_chunk(&tc_game_state_g.main_world, 1.0f, 1.0f, 1.0f);
tc_load_textures();
block = tc_new_block_at_3f(0.0, 0.0, 0.0); block = tc_new_block_at_3f(0.0, 0.0, 0.0);
// tc_new_cube_block();
int64_t frame_index = 1; int64_t frame_index = 1;
while(frame_index > 0) while(frame_index > 0)

123
code/source-c/meshize.c
View File

@ -1,4 +1,5 @@
#include "world.h" #include "world.h"
#include "assets.h"
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -15,27 +16,27 @@ float tc_block_vertices[108] =
-0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f,
// Back // Back
0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, 0.5f,
-0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, 0.5f,
0.5f, -0.5f, 0.5f,
0.5f, 0.5f, 0.5f,
0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f,
0.5f, -0.5f, 0.5f,
0.5f, 0.5f, 0.5f,
// Left // Left
-0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f,
-0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f,
-0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, -0.5f,
-0.5f, 0.5f, 0.5f,
-0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, 0.5f,
-0.5f, 0.5f, -0.5f,
// Right // Right
0.5f, 0.5f, -0.5f,
0.5f, -0.5f, -0.5f,
0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f,
0.5f, -0.5f, -0.5f,
0.5f, 0.5f, -0.5f,
0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f,
0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
@ -46,13 +47,13 @@ float tc_block_vertices[108] =
-0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f,
0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f,
0.5f, 0.5f, 0.5f,
-0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f,
0.5f, 0.5f, 0.5f,
0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f,
// Bottom // Bottom
-0.5f, -0.5f, -0.5f,
-0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f,
-0.5f, -0.5f, -0.5f,
0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f,
0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f,
@ -60,7 +61,7 @@ float tc_block_vertices[108] =
0.5f, -0.5f, -0.5f 0.5f, -0.5f, -0.5f
}; };
float test_uvs[72] = float tc_generic_cube_uvs[72] =
{ {
// Front // Front
0.0f, 0.0f, 0.0f, 0.0f,
@ -72,13 +73,13 @@ float test_uvs[72] =
0.0f, 1.0f, 0.0f, 1.0f,
// Back // Back
1.0f, 1.0f,
1.0f, 0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f, 1.0f,
0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 1.0f, 0.0f,
1.0f, 1.0f,
// Left // Left
1.0f, 0.0f, 1.0f, 0.0f,
@ -107,7 +108,7 @@ float test_uvs[72] =
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 1.0f, 0.0f,
// Back // Bottom
1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f, 1.0f,
@ -145,6 +146,74 @@ uint32_t tc_count_chunk_vertices(tc_chunk_s *chunk)
return num_vertices; return num_vertices;
} }
void tc_modify_basic_cube_face_uvs_to_fit(tc_image_s *image, float *face_uvs)
{
float lower_x = ((float) image->x) / ((float) image->width);
float lower_y = ((float) image->y) / ((float) image->height);
float higher_x;
float higher_y;
if(image->superimage != NULL)
{
higher_x = (((float) (image->x + image->width)) / ((float) image->superimage->width));
higher_y = (((float) (image->y + image->height)) / ((float) image->superimage->height));
}
else
{
higher_x = 1.0f;
higher_y = 1.0f;
}
uint32_t num_floats = 2 * 6;
uint32_t index = 0;
while(index < num_floats)
{
if(face_uvs[index] == 1.0f)
{
face_uvs[index] = higher_x;
}
else
{
face_uvs[index] = lower_x;
}
++index;
if(face_uvs[index] == 1.0f)
{
face_uvs[index] = higher_y;
}
else
{
face_uvs[index] = lower_y;
}
++index;
}
}
void tc_generate_basic_cube_uvs(tc_block_entry_s *entry, float *block_uvs)
{
uint32_t num_floats = 2 * 36;
memcpy(block_uvs, tc_generic_cube_uvs, sizeof(float) * num_floats);
tc_block_attribute_s *front = tc_block_resolve_name_to_attribute(entry, "front_texture");
tc_block_attribute_s *back = tc_block_resolve_name_to_attribute(entry, "back_texture");
tc_block_attribute_s *west = tc_block_resolve_name_to_attribute(entry, "west_texture");
tc_block_attribute_s *east = tc_block_resolve_name_to_attribute(entry, "east_texture");
tc_block_attribute_s *top = tc_block_resolve_name_to_attribute(entry, "top_texture");
tc_block_attribute_s *bottom = tc_block_resolve_name_to_attribute(entry, "bottom_texture");
uint32_t num_floats_per_face = 2 * 6;
tc_modify_basic_cube_face_uvs_to_fit(front->value.pointer, &block_uvs[0]);
tc_modify_basic_cube_face_uvs_to_fit(back->value.pointer, &block_uvs[num_floats_per_face]);
tc_modify_basic_cube_face_uvs_to_fit(west->value.pointer, &block_uvs[num_floats_per_face*2]);
tc_modify_basic_cube_face_uvs_to_fit(east->value.pointer, &block_uvs[num_floats_per_face*3]);
tc_modify_basic_cube_face_uvs_to_fit(top->value.pointer, &block_uvs[num_floats_per_face*4]);
tc_modify_basic_cube_face_uvs_to_fit(bottom->value.pointer, &block_uvs[num_floats_per_face*5]);
}
void tc_meshize_chunk(tc_chunk_s *chunk) void tc_meshize_chunk(tc_chunk_s *chunk)
{ {
chunk->num_vertices = tc_count_chunk_vertices(chunk); chunk->num_vertices = tc_count_chunk_vertices(chunk);
@ -155,8 +224,6 @@ void tc_meshize_chunk(tc_chunk_s *chunk)
float block_positions[36*3]; float block_positions[36*3];
float block_uvs[36*2]; float block_uvs[36*2];
memcpy(block_uvs, test_uvs, sizeof(float) * 36 * 2);
uint32_t x_in_chunk = 0; uint32_t x_in_chunk = 0;
uint32_t y_in_chunk = 0; uint32_t y_in_chunk = 0;
uint32_t z_in_chunk = 0; uint32_t z_in_chunk = 0;
@ -168,7 +235,26 @@ void tc_meshize_chunk(tc_chunk_s *chunk)
z_in_chunk = 0; z_in_chunk = 0;
while(z_in_chunk < 32) while(z_in_chunk < 32)
{ {
if(chunk->blocks[x_in_chunk][y_in_chunk][z_in_chunk] > 0) tc_block_entry_s *entry =
tc_resolve_id_to_block_entry(
chunk->blocks[x_in_chunk][y_in_chunk][z_in_chunk]
);
if(entry == NULL)
{
++z_in_chunk;
continue;
}
tc_block_attribute_s *block =
tc_block_resolve_name_to_attribute(entry, "block_type");
if(block == NULL)
{
++z_in_chunk;
continue;
}
if(!strcmp(block->value.string, "basic_cube"))
{ {
memcpy( memcpy(
block_positions, block_positions,
@ -191,6 +277,9 @@ void tc_meshize_chunk(tc_chunk_s *chunk)
++vertex_of_block; ++vertex_of_block;
} }
memcpy(block_uvs, tc_generic_cube_uvs, sizeof(float) * 36 * 2);
tc_generate_basic_cube_uvs(entry, block_uvs);
memcpy( memcpy(
&chunk->vertex_positions[vertex_index*3], &chunk->vertex_positions[vertex_index*3],
block_positions, block_positions,

6
code/source-c/state.h
View File

@ -43,8 +43,10 @@ typedef struct
extern techneck_s tc_game_state_g; extern techneck_s tc_game_state_g;
techneck_s tc_init (); void tc_init ();
void tc_cleanup (); void tc_cleanup ();
void tc_load_textures ();
#endif #endif

2
code/source-c/world.c
View File

@ -100,7 +100,9 @@ tc_chunk_s * tc_new_chunk(tc_world_s *world, float x, float y, float z)
chunk->position.y = y; chunk->position.y = y;
chunk->position.z = z; chunk->position.z = z;
world->worldgen->fn_generate_chunk(world->worldgen, chunk); world->worldgen->fn_generate_chunk(world->worldgen, chunk);
puts("Meshizing"); fflush(stdout);
tc_meshize_chunk(chunk); tc_meshize_chunk(chunk);
puts("Meshized"); fflush(stdout);
glGenVertexArrays(1, &chunk->vao); glGenVertexArrays(1, &chunk->vao);
glBindVertexArray(chunk->vao); glBindVertexArray(chunk->vao);

2
code/source-c/world.h
View File

@ -56,7 +56,7 @@ struct tc_world
tc_world_s tc_init_worlds (); tc_world_s tc_init_worlds ();
void tc_draw_world (tc_world_s *world); void tc_draw_world (tc_world_s *world);
tc_chunk_s * tc_new_chunk (tc_world_s *world, float x, float y, float z); tc_chunk_s * tc_new_chunk (tc_world_s *world, float x, float y, float z); // must be integers
void tc_set_block_in_chunk( void tc_set_block_in_chunk(
tc_chunk_s *chunk, tc_chunk_s *chunk,

1
vertex_shader.glsl
View File

@ -12,6 +12,7 @@ uniform mat4 model_matrix;
void main() { void main() {
gl_Position = projection_matrix * view_matrix * model_matrix * vec4(pos, 1.0); gl_Position = projection_matrix * view_matrix * model_matrix * vec4(pos, 1.0);
uv_coords = uv; uv_coords = uv;
} }