Isometric Renderer initial commit.

1 files changed, 213 insertions, 0 deletions

diff --git a/gfx-iso/demo/isogfx-demo.c b/gfx-iso/demo/isogfx-demo.c
new file mode 100644
index 0000000..d6c1ab0
--- /dev/null
+++ b/gfx-iso/demo/isogfx-demo.c
@@ -0,0 +1,213 @@
+#include <isogfx/isogfx.h>
+
+#include <gfx/gfx.h>
+#include <gfx/gfx_app.h>
+#include <gfx/render_backend.h>
+#include <gfx/renderer.h>
+#include <gfx/scene.h>
+#include <gfx/util/geometry.h>
+#include <gfx/util/shader.h>
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static const int SCREEN_WIDTH  = 1408;
+static const int SCREEN_HEIGHT = 960;
+static const int TILE_WIDTH    = 64;
+static const int TILE_HEIGHT   = TILE_WIDTH / 2;
+static const int WORLD_WIDTH   = 20;
+static const int WORLD_HEIGHT  = 20;
+
+static const Pixel BLACK = (Pixel){.r = 0x38, .g = 0x3b, .b = 0x46};
+static const Pixel WHITE = (Pixel){.r = 0xA5, .g = 0xb3, .b = 0xc0};
+static const Pixel RED   = (Pixel){.r = 0xdc, .g = 0x76, .b = 0x84};
+
+typedef struct State {
+  Gfx*     gfx;
+  IsoGfx*  iso;
+  Tile     red;
+  int      xpick;
+  int      ypick;
+  Texture* screen_texture;
+  Scene*   scene;
+} State;
+
+static void make_checkerboard(IsoGfx* iso, Tile black, Tile white) {
+  assert(iso);
+  for (int y = 0; y < isogfx_world_height(iso); ++y) {
+    for (int x = 0; x < isogfx_world_width(iso); ++x) {
+      const int  odd_col = x & 1;
+      const int  odd_row = y & 1;
+      const Tile value   = (odd_row ^ odd_col) == 0 ? black : white;
+      isogfx_set_tile(iso, x, y, value);
+    }
+  }
+}
+
+static bool init(const GfxAppDesc* desc, void** app_state) {
+  State* state = calloc(1, sizeof(State));
+  if (!state) {
+    return false;
+  }
+
+  if (!(state->iso = isogfx_new(&(IsoGfxDesc){
+            .screen_width  = SCREEN_WIDTH,
+            .screen_height = SCREEN_HEIGHT,
+            .tile_width    = TILE_WIDTH,
+            .tile_height   = TILE_HEIGHT,
+            .world_width   = WORLD_WIDTH,
+            .world_height  = WORLD_HEIGHT}))) {
+    goto cleanup;
+  }
+  if (!(state->gfx = gfx_init())) {
+    goto cleanup;
+  }
+  RenderBackend* render_backend = gfx_get_render_backend(state->gfx);
+
+  if (!(state->screen_texture = gfx_make_texture(
+            render_backend, &(TextureDesc){
+                                .width     = SCREEN_WIDTH,
+                                .height    = SCREEN_HEIGHT,
+                                .dimension = Texture2D,
+                                .format    = TextureRGB8,
+                                .filtering = NearestFiltering,
+                                .wrap      = ClampToEdge,
+                                .mipmaps   = false}))) {
+    goto cleanup;
+  }
+
+  ShaderProgram* shader = gfx_make_view_texture_shader(render_backend);
+  if (!shader) {
+    goto cleanup;
+  }
+
+  Geometry* geometry = gfx_make_quad_11(render_backend);
+  if (!geometry) {
+    goto cleanup;
+  }
+
+  MaterialDesc material_desc = (MaterialDesc){.num_uniforms = 1};
+  material_desc.uniforms[0]  = (ShaderUniform){
+       .type          = UniformTexture,
+       .value.texture = state->screen_texture,
+       .name          = sstring_make("Texture")};
+  Material* material = gfx_make_material(&material_desc);
+  if (!material) {
+    return false;
+  }
+
+  const MeshDesc mesh_desc =
+      (MeshDesc){.geometry = geometry, .material = material, .shader = shader};
+  Mesh* mesh = gfx_make_mesh(&mesh_desc);
+  if (!mesh) {
+    goto cleanup;
+  }
+
+  SceneObject* object = gfx_make_object();
+  if (!object) {
+    goto cleanup;
+  }
+  gfx_add_object_mesh(object, mesh);
+
+  state->scene    = gfx_make_scene();
+  SceneNode* node = gfx_make_object_node(object);
+  SceneNode* root = gfx_get_scene_root(state->scene);
+  gfx_set_node_parent(node, root);
+
+  const Tile black = isogfx_make_tile(
+      state->iso, &(TileDesc){.type = TileFromColour, .colour = BLACK});
+  const Tile white = isogfx_make_tile(
+      state->iso, &(TileDesc){.type = TileFromColour, .colour = WHITE});
+  state->red = isogfx_make_tile(
+      state->iso, &(TileDesc){.type = TileFromColour, .colour = RED});
+  make_checkerboard(state->iso, black, white);
+  isogfx_render(state->iso);
+
+  *app_state = state;
+  return true;
+
+cleanup:
+  if (state->gfx) {
+    gfx_destroy(&state->gfx);
+  }
+  free(state);
+  return false;
+}
+
+static void shutdown(void* app_state) {
+  assert(app_state);
+  State* state = (State*)(app_state);
+  isogfx_del(&state->iso);
+  gfx_destroy(&state->gfx);
+  free(app_state);
+}
+
+static void update(void* app_state, double t, double dt) {
+  assert(app_state);
+  State* state = (State*)(app_state);
+
+  double mouse_x, mouse_y;
+  gfx_app_get_mouse_position(&mouse_x, &mouse_y);
+
+  isogfx_pick_tile(state->iso, mouse_x, mouse_y, &state->xpick, &state->ypick);
+
+  printf("Picked tile: (%d, %d)\n", state->xpick, state->ypick);
+}
+
+static void render(void* app_state) {
+  assert(app_state);
+  State* state = (State*)(app_state);
+
+  isogfx_render(state->iso);
+  if ((state->xpick != -1) && (state->ypick != -1)) {
+    isogfx_draw_tile(state->iso, state->xpick, state->ypick, state->red);
+  }
+
+  const Pixel* screen = isogfx_get_screen_buffer(state->iso);
+  assert(screen);
+  gfx_update_texture(
+      state->screen_texture, &(TextureDataDesc){.pixels = screen});
+
+  RenderBackend* render_backend = gfx_get_render_backend(state->gfx);
+  Renderer*      renderer       = gfx_get_renderer(state->gfx);
+
+  gfx_start_frame(render_backend);
+  gfx_render_scene(
+      renderer, &(RenderSceneParams){
+                    .mode = RenderDefault, .scene = state->scene, .camera = 0});
+  gfx_end_frame(render_backend);
+}
+
+static void resize(void* app_state, int width, int height) {
+  assert(app_state);
+  State* state = (State*)(app_state);
+
+  RenderBackend* render_backend = gfx_get_render_backend(state->gfx);
+  gfx_set_viewport(render_backend, width, height);
+}
+
+int main(int argc, const char** argv) {
+  const int initial_width  = SCREEN_WIDTH;
+  const int initial_height = SCREEN_HEIGHT;
+  const int max_fps        = 60;
+
+  gfx_app_run(
+      &(GfxAppDesc){
+          .argc              = argc,
+          .argv              = argv,
+          .width             = initial_width,
+          .height            = initial_height,
+          .max_fps           = max_fps,
+          .update_delta_time = max_fps > 0 ? 1.0 / (double)max_fps : 0.0,
+          .title             = "Isometric Renderer"},
+      &(GfxAppCallbacks){
+          .init     = init,
+          .update   = update,
+          .render   = render,
+          .resize   = resize,
+          .shutdown = shutdown});
+
+  return 0;
+}