c:\Users\nitan\Documents\RayTest\src\main.zig

const std = @import("std");
const rl = @import("raylib");
const gl = @import("rlgl");
const math = @import("raylib-math");

const vector = @import("vector.zig");

const Vector3 = vector.Vector3D;

const allocator = std.heap.c_allocator;

const MAX_INSTANCES: usize = 10000;

pub fn main() !void {
    const screen_width = 800;
    const screen_height = 600;

    rl.initWindow(screen_width, screen_height, "Raylib");
    rl.disableCursor();

    var camera = rl.Camera3D{
        .position = Vector3.new(10.0, 0.0, 10.0).rlVector3(),
        .target = Vector3.zero.rlVector3(), 
        .up = Vector3.up.rlVector3(), 
        .fovy = 45.0,
        .projection = rl.CameraProjection.camera_perspective,
    };

    const cube = rl.genMeshCube(1.0, 1.0, 1.0);
    const cubePos = Vector3.new(0.0, 0.0, 0.0);

    var transforms = try allocator.alloc(rl.Matrix, MAX_INSTANCES);

    for (0..MAX_INSTANCES) |i| {
        transforms[i] = math.matrixTranslate(cubePos.x(), cubePos.y(), cubePos.z());
    }

    defer allocator.free(transforms);

    const shader = rl.loadShader("assets/shaders/lighting_instancing.vs", "assets/shaders/lighting.fs");

    const shader_loc_matrix_mvp: usize = @intFromEnum(rl.ShaderLocationIndex.shader_loc_matrix_mvp);
    const shader_loc_vector_view: usize = @intFromEnum(rl.ShaderLocationIndex.shader_loc_vector_view);
    const shader_loc_matrix_model: usize = @intFromEnum(rl.ShaderLocationIndex.shader_loc_matrix_model);

    shader.locs[shader_loc_matrix_mvp] = rl.getShaderLocation(shader, "mvp");
    shader.locs[shader_loc_vector_view] = rl.getShaderLocation(shader, "viewPos");
    shader.locs[shader_loc_matrix_model] = rl.getShaderLocation(shader, "instanceTransform");

    const ambientLoc = rl.getShaderLocation(shader, "ambient");
    const ambientValue: [4]f32 = .{ 0.2, 0.2, 0.2, 1.0 };
    const uniform_type: i32 = @intFromEnum(rl.ShaderUniformDataType.shader_uniform_vec4);
    rl.setShaderValue(shader, ambientLoc, &ambientValue, uniform_type);

    var matInstances = rl.loadMaterialDefault();
    matInstances.shader = shader;
    const material_map_difuse: usize = @intFromEnum(rl.MATERIAL_MAP_DIFFUSE);
    matInstances.maps[material_map_difuse].color = rl.Color.red;

    rl.setTargetFPS(60);

    while (!rl.windowShouldClose()) {
        camera.update(rl.CameraMode.camera_free);

        rl.beginDrawing();
        rl.clearBackground(rl.Color.ray_white);

        camera.begin();

        cube.drawInstanced(matInstances, transforms);

        camera.end();

        rl.endDrawing();
        rl.drawFPS(10, 10);
    }
}