Add project files.

examples/viewer.cpp

@@ -0,0 +1,117 @@
+// Minimal raylib viewer: shows how little code it takes to use a Hammer++ map in another app.
+//   hmap_viewer [file.hmap]        WASD + mouse (hold right button) to fly, Shift = fast
+//
+// Everything map-related is: loadCompiled() -> iterate batches -> trace()/pointContents().
+// Baked vertex lighting is already in Vertex::color, which raylib's default shader multiplies in.
+#include <hmap/hmap.h>
+
+#include <cmath>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+#include "raylib.h"
+#include "raymath.h"  // MatrixIdentity
+
+struct GpuBatch {
+    Mesh mesh;
+    int material;
+};
+
+static Mesh toRaylib(const hmap::Batch& b) {
+    Mesh m = {};
+    size_t n = b.indices.size();  // expand to a non-indexed triangle list (no 16-bit index limit)
+    m.vertexCount = (int)n;
+    m.triangleCount = (int)(n / 3);
+    m.vertices = (float*)MemAlloc((unsigned)(n * 3 * sizeof(float)));
+    m.texcoords = (float*)MemAlloc((unsigned)(n * 2 * sizeof(float)));
+    m.normals = (float*)MemAlloc((unsigned)(n * 3 * sizeof(float)));
+    m.colors = (unsigned char*)MemAlloc((unsigned)(n * 4));
+    for (size_t i = 0; i < n; ++i) {
+        const hmap::Vertex& v = b.vertices[b.indices[i]];
+        m.vertices[i * 3 + 0] = v.pos.x; m.vertices[i * 3 + 1] = v.pos.y; m.vertices[i * 3 + 2] = v.pos.z;
+        m.normals[i * 3 + 0] = v.normal.x; m.normals[i * 3 + 1] = v.normal.y; m.normals[i * 3 + 2] = v.normal.z;
+        m.texcoords[i * 2 + 0] = v.uv.x; m.texcoords[i * 2 + 1] = v.uv.y;
+        m.colors[i * 4 + 0] = (unsigned char)(v.color & 0xff);
+        m.colors[i * 4 + 1] = (unsigned char)((v.color >> 8) & 0xff);
+        m.colors[i * 4 + 2] = (unsigned char)((v.color >> 16) & 0xff);
+        m.colors[i * 4 + 3] = (unsigned char)((v.color >> 24) & 0xff);
+    }
+    UploadMesh(&m, false);
+    return m;
+}
+
+int main(int argc, char** argv) {
+    const char* path = argc > 1 ? argv[1] : "demo_runtime.hmap";
+    hmap::CompiledMap map;
+    hmap::Status st = hmap::loadCompiled(path, map);  // works for source, compiled and mixed files
+    if (!st) {
+        std::fprintf(stderr, "cannot load %s: %s\n", path, st.message.c_str());
+        return 1;
+    }
+
+    InitWindow(1280, 720, "hmap viewer");
+    SetTargetFPS(120);
+
+    std::vector<GpuBatch> gpu;
+    for (const hmap::Batch& b : map.batches)
+        if (!b.indices.empty()) gpu.push_back({toRaylib(b), b.material});
+    Material mat = LoadMaterialDefault();
+
+    hmap::Vec3 pos(0, 100, 300);
+    float yaw = 0, pitch = 0;
+    for (const hmap::Entity& e : map.entities)
+        if (e.classname == "info_player_start") { pos = e.origin + hmap::Vec3(0, 40, 0); yaw = e.angles.y; }
+
+    while (!WindowShouldClose()) {
+        float dt = GetFrameTime();
+        if (IsMouseButtonDown(MOUSE_BUTTON_RIGHT)) {
+            Vector2 d = GetMouseDelta();
+            yaw -= d.x * 0.15f;
+            pitch = std::fmax(-89.0f, std::fmin(89.0f, pitch - d.y * 0.15f));
+        }
+        float cy = std::cos(yaw * hmap::kDeg2Rad), sy = std::sin(yaw * hmap::kDeg2Rad);
+        float cp = std::cos(pitch * hmap::kDeg2Rad), sp = std::sin(pitch * hmap::kDeg2Rad);
+        hmap::Vec3 fwd(-sy * cp, sp, -cy * cp), right(cy, 0, -sy);
+        float speed = (IsKeyDown(KEY_LEFT_SHIFT) ? 900.0f : 300.0f) * dt;
+        hmap::Vec3 move;
+        if (IsKeyDown(KEY_W)) move += fwd;
+        if (IsKeyDown(KEY_S)) move -= fwd;
+        if (IsKeyDown(KEY_D)) move += right;
+        if (IsKeyDown(KEY_A)) move -= right;
+        hmap::Vec3 next = pos + hmap::normalize(move) * speed;
+        // collide against the BSP: stop at walls
+        if (!map.trace(pos, next + hmap::normalize(move) * 12.0f).hit) pos = next;
+
+        hmap::TraceResult aim = map.trace(pos, pos + fwd * 4000.0f);  // "what am I looking at?"
+
+        Camera3D cam = {};
+        cam.position = {pos.x, pos.y, pos.z};
+        cam.target = {pos.x + fwd.x, pos.y + fwd.y, pos.z + fwd.z};
+        cam.up = {0, 1, 0};
+        cam.fovy = 70;
+        cam.projection = CAMERA_PERSPECTIVE;
+
+        BeginDrawing();
+        ClearBackground({24, 26, 32, 255});
+        BeginMode3D(cam);
+        for (const GpuBatch& g : gpu) {
+            const hmap::Material& hm = map.materials[(size_t)g.material];
+            mat.maps[MATERIAL_MAP_DIFFUSE].color = {(unsigned char)(hm.color.x * 255), (unsigned char)(hm.color.y * 255),
+                                                    (unsigned char)(hm.color.z * 255), 255};
+            DrawMesh(g.mesh, mat, MatrixIdentity());
+        }
+        for (const hmap::Entity& e : map.entities)
+            DrawCubeWires({e.origin.x, e.origin.y, e.origin.z}, 12, 12, 12, e.classname.rfind("light", 0) == 0 ? YELLOW : SKYBLUE);
+        if (aim.hit) DrawSphere({aim.point.x, aim.point.y, aim.point.z}, 3, RED);
+        EndMode3D();
+        DrawText(TextFormat("%s  |  %d batches  %u tris  |  aim: %s  |  %d fps", path, (int)gpu.size(), map.stats.triangles,
+                            aim.hit ? TextFormat("%.0f units", aim.fraction * 4000.0f) : "nothing", GetFPS()),
+                 10, 10, 18, RAYWHITE);
+        EndDrawing();
+    }
+    for (GpuBatch& g : gpu) UnloadMesh(g.mesh);
+    MemFree(mat.maps);
+    CloseWindow();
+    return 0;
+}