Refator pass 1

archive/rpg/overworld/sceneoverworld.c

@@ -0,0 +1,146 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "sceneoverworld.h"
+#include "rpg/entity/entity.h"
+#include "display/spritebatch.h"
+#include "display/framebuffer.h"
+#include "display/scene/scenemanager.h"
+#include "display/mesh/quad.h"
+#include "asset/assetmanager.h"
+#include "assert/assert.h"
+
+#include "display/tileset/tileset_entities.h"
+
+sceneoverworld_t SCENE_OVERWORLD;
+asset_t *testAsset;
+ref_t testAssetRef;
+
+errorret_t sceneOverworldInit(void) {
+  cameraInit(&SCENE_OVERWORLD.camera);
+  glm_vec3_copy((vec3){ 0.0f, 1.0f, 0.0f }, SCENE_OVERWORLD.camera.lookat.up);
+  SCENE_OVERWORLD.camera.perspective.fov = 45;
+  SCENE_OVERWORLD.camera.farClip = 10000.0f;
+
+  scene_t *scene = &SCENE_MANAGER_SCENES[SCENE_TYPE_OVERWORLD];
+  scene->flags |= SCENE_FLAG_ACTIVE | SCENE_FLAG_VISIBLE;
+
+  errorChain(assetManagerLoadAsset(
+    TILESET_ENTITIES.image, &testAsset, &testAssetRef
+  ));
+
+  errorOk();
+}
+
+void sceneOverworldUpdate(void) {
+  if(RPG.map == NULL) return;
+
+  // Move camera to player.
+  const entity_t *start = &RPG.map->entities[0];
+  const entity_t *end = &RPG.map->entities[RPG.map->entityCount];
+  while(start < end) {
+    if(start->type == ENTITY_TYPE_PLAYER) {
+      SCENE_OVERWORLD.camera.lookat.target[0] = start->position[0];
+      SCENE_OVERWORLD.camera.lookat.target[1] = start->position[1];
+      break;
+    }
+    start++;
+  }
+}
+
+void sceneOverworldRender(void) {
+  const float_t camOffset = 12.0f;
+  const float_t fbWidth = frameBufferGetWidth(FRAMEBUFFER_BOUND);
+  const float_t fbHeight = frameBufferGetHeight(FRAMEBUFFER_BOUND);
+  const float_t aspect = fbWidth / fbHeight;
+  const float_t pixelPerfectOffset = tanf(
+    (glm_rad(180) - SCENE_OVERWORLD.camera.perspective.fov) / 2.0f
+  ) * (fbHeight/ 2.0f);
+
+  // glm_vec3_copy((vec3){
+  //   -100.0f, -100.0f, 0.0f
+  // }, SCENE_OVERWORLD.camera.lookat.target);
+  glm_vec3_copy((vec3){
+    SCENE_OVERWORLD.camera.lookat.target[0],
+    SCENE_OVERWORLD.camera.lookat.target[1] + camOffset,
+    SCENE_OVERWORLD.camera.lookat.target[2] + pixelPerfectOffset
+  }, SCENE_OVERWORLD.camera.lookat.position);
+
+  cameraPushMatrix(&SCENE_OVERWORLD.camera);
+
+  if(RPG.map != NULL) sceneOverworldRenderMap(RPG.map);
+
+  spriteBatchFlush();
+  cameraPopMatrix();
+}
+
+void sceneOverworldRenderMap(const map_t *map) {
+  assertNotNull(map, "Map pointer cannot be NULL");
+
+  // Draw base layer
+  sceneOverworldRenderMapLayer(map, &map->base);
+  
+  // Draw entities
+  const entity_t *start = &map->entities[0];
+  const entity_t *end = &map->entities[map->entityCount];
+  while(start < end) {
+    // Render entity here.
+    sceneOverworldRenderEntity(start);
+    start++;
+  }
+  spriteBatchFlush();
+
+  // Draw overlay layer.
+  sceneOverworldRenderMapLayer(map, &map->overlay);
+}
+
+void sceneOverworldRenderEntity(const entity_t *entity) {
+  assertNotNull(entity, "Entity pointer cannot be NULL");
+  assertTrue(entity->type < ENTITY_TYPE_COUNT, "Invalid entity type");
+  assertTrue(entity->type != ENTITY_TYPE_NULL, "Cannot have NULL entity type");
+
+  vec4 uv;
+  tilesetPositionGetUV(&TILESET_ENTITIES, entity->direction, 0, uv);
+
+  // For now, just draw a placeholder quad.
+  spriteBatchPush(
+    &testAsset->paletteImage.texture,
+    entity->position[0], entity->position[1],
+    entity->position[0] + TILESET_ENTITIES.tileWidth,
+    entity->position[1] + TILESET_ENTITIES.tileHeight,
+    COLOR_WHITE,
+    uv[0], uv[1], uv[2], uv[3]
+  );
+}
+
+void sceneOverworldRenderMapLayer(const map_t *map, const maplayer_t *layer) {
+  assertNotNull(layer, "Map layer pointer cannot be NULL");
+
+  for(uint32_t y = 0; y < map->height; y++) {
+    for(uint32_t x = 0; x < map->width; x++) {
+      const tile_t *tile = &layer->tiles[y * map->width + x];
+      if(tile->id == 0) continue;
+
+      spriteBatchPush(
+        NULL,
+        x * TILESET_ENTITIES.tileWidth,
+        y * TILESET_ENTITIES.tileHeight,
+        (x + 1) * TILESET_ENTITIES.tileWidth,
+        (y + 1) * TILESET_ENTITIES.tileHeight,
+        COLOR_RED,
+        0, 0, 1, 1
+      );
+    }
+  }
+
+  spriteBatchFlush();
+}
+
+void sceneOverworldDispose(void) {
+  // Dispose of the overworld scene.
+  if(testAsset) assetUnlock(testAsset, testAssetRef);
+}