Tweaking camera params and asset generation

diff --git a/src/render_raylib.c b/src/render_raylib.c
index 6448bfa9a682363277eafcbd074ac2214bf96fb3..835ed067d940fbfc6438128e4e468e12b9b36418 100644 (file)
--- a/src/render_raylib.c
+++ b/src/render_raylib.c
@@ -1,4 +1,5 @@
 #include <raylib.h>
+#define RAYMATH_IMPLEMENTATION
 #include <raymath.h>
 
 #include "structs.h"
@@ -66,6 +67,15 @@ void process_inputs()
                        player_rotation.x = rotate_speed;
                }
 
+               if (IsKeyDown(KEY_T))
+               {
+                       cam.target.y += DEG2RAD * 20.0;
+               }
+               else if (IsKeyDown(KEY_G))
+               {
+                       cam.target.y -= DEG2RAD * 20.0;
+               }
+
                if (IsKeyDown(KEY_SPACE) || IsKeyDown(KEY_LEFT_SHIFT) || IsKeyDown(KEY_RIGHT_SHIFT))
                {
                        //player_velocity.x *= 2.0f;
@@ -131,15 +141,15 @@ void initialize_renderer()
        floor_model.materials[0].maps[MATERIAL_MAP_ROUGHNESS].texture = floor_albedo;
        floor_model.materials[0].shader = shader;
 
-       cam = (Camera3D){0};
-       cam.position    = barrow_position;
+       cam                                             = (Camera3D){0};
+       cam.position            = barrow_position;
        cam.position.y -= 0.5f;
-       cam.position.x = 0;//barrow_scale.x/2;
-       cam.position.z = -barrow_scale.z/2;
-       cam.target              = (Vector3){0.0f, cam.position.y - 12.0f, 0.0f};
-       cam.up                          = (Vector3){0.0f, 1.0f, 0.0f};
-       cam.fovy                        = 90.0f;
-       cam.projection= CAMERA_PERSPECTIVE;
+       cam.position.x  = barrow_scale.x/2.0f;
+       cam.position.z  = (-barrow_scale.z/2.0f) - 4.0f;
+       cam.target                      = (Vector3){barrow_scale.x/2.0f, cam.position.y - 10.0f, cam.position.z/2.0f};
+       cam.up                                  = (Vector3){0.0f, 1.0f, 0.0f};
+       cam.fovy                                = 90.0f;
+       cam.projection  = CAMERA_PERSPECTIVE;
 
        DisableCursor();
 }
@@ -168,6 +178,7 @@ void start_render_loop()
 
                        BeginMode3D(cam);
                        BeginShaderMode(shader);
+                               DrawGrid(barrow_scale.x, 1.0f);
                                DrawModelEx(barrow_model, barrow_position, barrow_rotation_axis, barrow_rotation, barrow_scale, DARKGRAY);
                                DrawModelEx(floor_model, floor_position, floor_rotation_axis, floor_rotation, floor_scale, DARKGRAY);
                        EndShaderMode();
@@ -175,6 +186,7 @@ void start_render_loop()
 
                        DrawTexturePro(barrow_texture, minimap_src, minimap_dest, (Vector2){0.0f, 0.0f}, 0.0f, RAYWHITE);
                        DrawFPS(fscreen_dims.x - 80, 10);
+                       DrawText(TextFormat("cam x %f\ncam y %f\ncam z %f", cam.position.x, cam.position.y, cam.position.z), 0, 128, 16, GREEN);
                EndDrawing();
 
                /* Decay forward velocity and rotation */

diff --git a/src/shaders/lighting.fs b/src/shaders/lighting.fs
index b8437bbb7e43d59fd29884a6f3bf342fca75828f..03eb20be5dbd816a0168559a747911bf7c647915 100644 (file)
--- a/src/shaders/lighting.fs
+++ b/src/shaders/lighting.fs
@@ -1,4 +1,5 @@
 #version 330
+asdfasdf
 
 // Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
@@ -11,6 +12,7 @@ uniform vec4 colDiffuse;
 uniform vec3 cam_position;
 uniform vec2 screen_dims;
 
+adasd
 // Output fragment color
 out vec4 finalColor;
 

diff --git a/src/utils.c b/src/utils.c
index 78618d7cd53304b651237aeab11b25e73a428a4d..61989a37a0a6f1d11d5094b3a366f4bddc2a5cbb 100644 (file)
--- a/src/utils.c
+++ b/src/utils.c
@@ -95,9 +95,10 @@ int initialize(int worker_count, RD_Opts active_opt)
        srand(time(NULL));
 
        /* Set up as a circle */
-       float radius = grid_size.x/2.1f;
+       float barrow_radius = grid_size.x/2.1f;
        int center_x = grid_size.x/2;
        int center_y = grid_size.y/2;
+       float central_chamber_radius = barrow_radius/6;
 
        for (int x = 0; x < grid_size.x; x++)
        {
@@ -106,15 +107,16 @@ int initialize(int worker_count, RD_Opts active_opt)
                        grid[x][y].a = 1.0f;
                        grid[x][y].b = 0.0f;
 
-                       if ((sqrtf(((x-center_x)*(x-center_x))+((y-center_y)*(y-center_y))) < radius))
+                       if ((sqrtf(((x-center_x)*(x-center_x))+((y-center_y)*(y-center_y))) < barrow_radius))
                        {
                                grid[x][y].c = 0.0f;
                        }
-                       else {
+                       /* Outside the barrow walls */
+                       else
+                       {
                                grid[x][y].c = 1.0f;
                        }
-
-                       if ((sqrtf(((x-center_x)*(x-center_x))+((y-center_y)*(y-center_y))) < radius/6))
+                       if ((sqrtf(((x-center_x)*(x-center_x))+((y-center_y)*(y-center_y))) < central_chamber_radius))
                        {
                                grid[x][y].c = 1.0f;
                        }
@@ -137,7 +139,6 @@ int initialize(int worker_count, RD_Opts active_opt)
                int seed_x = ((cosf(angle) * (grid_size.x/4.0f)) + (grid_size.x/2.0f));
                int seed_y = ((sinf(angle) * (grid_size.y/4.0f)) + (grid_size.y/2.0f));
 
-
                grid[seed_x][seed_y].b = 1.0f;
                grid[seed_x][seed_y].c = 0.0f;
 
@@ -168,30 +169,21 @@ int generate_rd(int worker_count, RD_Opts active_opt, FVec2 **grid_buffer, IVec2
        printf("Opts: {\nIterations: %d\nTime delta: %f\nDiffA: %f\nDiffB: %f\nFeed: %f\nKill: %f\n\n}\n", active_opt.max_iterations, active_opt.delta_t, active_opt.diff_a, active_opt.diff_b, active_opt.feed, active_opt.kill);
 
        /* png for the heightmap */
-       unsigned char mesh_buffer[pgrid_size.x][pgrid_size.y];
-       unsigned char large_mesh_buffer[pgrid_size.x*img_export_scale.x][pgrid_size.y*img_export_scale.y];
+       unsigned char barrow_mesh_buffer[pgrid_size.x][pgrid_size.y];
+       unsigned char floor_mesh_buffer[pgrid_size.x][pgrid_size.y];
+       unsigned char large_barrow_mesh_buffer[pgrid_size.x*img_export_scale.x][pgrid_size.y*img_export_scale.y];
+       unsigned char large_floor_mesh_buffer[pgrid_size.x*img_export_scale.x][pgrid_size.y*img_export_scale.y];
        /* png for albedo buffer */
        uint32_t albedo_buffer[pgrid_size.x][pgrid_size.y];
        uint32_t large_albedo_buffer[pgrid_size.x*img_export_scale.x][pgrid_size.y*img_export_scale.y];
 
-       int entrance_radius = 16.0f;
-       int seed_x = grid_size.x/2;
-       int seed_y = entrance_radius;
-       for (int x = seed_x-entrance_radius; x < seed_x+entrance_radius; x++)
-       {
-               for (int y = seed_y-entrance_radius; y < seed_y+entrance_radius; y++)
-               {
-                       if ((sqrtf(((x-seed_x)*(x-seed_x))+((y-seed_y)*(y-seed_y))) < entrance_radius))
-                               grid_buffer[x][y].a = 0.0f;
-               }
-       }
-
        for (int x = 0; x < pgrid_size.x; x++)
        {
                for (int y = 0; y < pgrid_size.y; y++)
                {
                        float a = round(-0.05f + grid_buffer[x][y].a);
-                       mesh_buffer[x][y] = (uint8_t)(255.0f * a);
+                       barrow_mesh_buffer[x][y] = (uint8_t)(255.0f * a);
+                       floor_mesh_buffer[x][y] = 0.0f;
 
                        /* Generate different materials
                        */
@@ -217,19 +209,23 @@ int generate_rd(int worker_count, RD_Opts active_opt, FVec2 **grid_buffer, IVec2
        sprintf(floor_albedo_name, "./floor_albedo.png");
 
        stbir_resize_uint8_linear(
-                       (unsigned char*)mesh_buffer, pgrid_size.x, pgrid_size.y, sizeof(uint8_t) * pgrid_size.x,
-                       (unsigned char*)large_mesh_buffer, pgrid_size.x*img_export_scale.x, pgrid_size.y*img_export_scale.y, sizeof(uint8_t) * pgrid_size.x * img_export_scale.x,
+                       (unsigned char*)barrow_mesh_buffer, pgrid_size.x, pgrid_size.y, sizeof(uint8_t) * pgrid_size.x,
+                       (unsigned char*)large_barrow_mesh_buffer, pgrid_size.x*img_export_scale.x, pgrid_size.y*img_export_scale.y, sizeof(uint8_t) * pgrid_size.x * img_export_scale.x,
+                       STBIR_1CHANNEL);
+       stbir_resize_uint8_linear(
+                       (unsigned char*)floor_mesh_buffer, pgrid_size.x, pgrid_size.y, sizeof(uint8_t) * pgrid_size.x,
+                       (unsigned char*)large_floor_mesh_buffer, pgrid_size.x*img_export_scale.x, pgrid_size.y*img_export_scale.y, sizeof(uint8_t) * pgrid_size.x * img_export_scale.x,
                        STBIR_1CHANNEL);
        stbir_resize_uint8_linear(
                        (unsigned char*)albedo_buffer, pgrid_size.x, pgrid_size.y, sizeof(uint32_t) * pgrid_size.x,
                        (unsigned char*)large_albedo_buffer, pgrid_size.x*img_export_scale.x, pgrid_size.y*img_export_scale.y, sizeof(uint32_t) * pgrid_size.x * img_export_scale.x,
                        STBIR_RGBA);
 
-       stbi_write_png(mesh_name, pgrid_size.x*img_export_scale.x, pgrid_size.y*img_export_scale.y, 1, large_mesh_buffer, pgrid_size.x * sizeof(uint8_t)*img_export_scale.x);
+       stbi_write_png(mesh_name, pgrid_size.x*img_export_scale.x, pgrid_size.y*img_export_scale.y, 1, large_barrow_mesh_buffer, pgrid_size.x * sizeof(uint8_t)*img_export_scale.x);
        stbi_write_png(albedo_name, pgrid_size.x*img_export_scale.x, pgrid_size.y*img_export_scale.y, 4, large_albedo_buffer, pgrid_size.x * sizeof(uint32_t)*img_export_scale.x);
 
        stbi_flip_vertically_on_write(1);
-       stbi_write_png(floor_mesh_name, pgrid_size.x*img_export_scale.x, pgrid_size.y*img_export_scale.y, 1, large_mesh_buffer, pgrid_size.x * sizeof(uint8_t)*img_export_scale.x);
+       stbi_write_png(floor_mesh_name, pgrid_size.x*img_export_scale.x, pgrid_size.y*img_export_scale.y, 1, large_floor_mesh_buffer, pgrid_size.x * sizeof(uint8_t)*img_export_scale.x);
        stbi_write_png(floor_albedo_name, pgrid_size.x*img_export_scale.x, pgrid_size.y*img_export_scale.y, 4, large_albedo_buffer, pgrid_size.x * sizeof(uint32_t)*img_export_scale.x);
 
        cleanup();