// vtest build: misc-tooling // needs .h files that are produced by `v shader`
/**********************************************************************
* Sokol 3d cube multishader demo
* Copyright (c) 2024 Dario Deledda. All rights reserved.
* Use of this source code is governed by an MIT license
* that can be found in the LICENSE file.
*
* HOW TO COMPILE SHADERS:
* Run `v shader .` in this directory to compile the shaders.
* For more info and help with shader compilation see `docs.md` and `v help shader`.
**********************************************************************/
import gg
import gg.m4
import sokol.sapp
import sokol.gfx
import sokol.sgl
import time

// GLSL Include and functions
#include "@VMODROOT/rt_glsl_march.h" # It should be generated with `v shader .` (see the instructions at the top of this file)
#include "@VMODROOT/rt_glsl_puppy.h" # It should be generated with `v shader .` (see the instructions at the top of this file)

fn C.rt_march_shader_desc(gfx.Backend) &gfx.ShaderDesc
fn C.rt_puppy_shader_desc(gfx.Backend) &gfx.ShaderDesc

const start_ticks = time.ticks()

@[heap]
struct App {
mut:
    gg         &gg.Context = unsafe { nil }
    texture    gfx.Image
    sampler    gfx.Sampler
    init_flag  bool
    mouse_x    int = 502
    mouse_y    int = 394
    mouse_down bool
    // glsl
    cube_pip_glsl gfx.Pipeline
    cube_bind     gfx.Bindings
    pipe          map[string]gfx.Pipeline
    bind          map[string]gfx.Bindings
}

/******************************************************************************
* Texture functions
******************************************************************************/
fn create_texture(w int, h int, buf byteptr) (gfx.Image, gfx.Sampler) {
    sz := w * h * 4
    mut img_desc := gfx.ImageDesc{
        width:  w
        height: h
    }
    img_desc.data.subimage[0][0] = gfx.Range{
        ptr:  buf
        size: usize(sz)
    }
    sg_img := gfx.make_image(&img_desc)
    mut smp_desc := gfx.SamplerDesc{
        min_filter: .linear
        mag_filter: .linear
        wrap_u:     .clamp_to_edge
        wrap_v:     .clamp_to_edge
    }
    sg_smp := gfx.make_sampler(&smp_desc)
    return sg_img, sg_smp
}

/******************************************************************************
* Draw functions
******************************************************************************
Cube vertex buffer with packed vertex formats for color and texture coords.
        Note that a vertex format which must be portable across all
        backends must only use the normalized integer formats
        (BYTE4N, UBYTE4N, SHORT2N, SHORT4N), which can be converted
        to floating point formats in the vertex shader inputs.
        The reason is that D3D11 cannot convert from non-normalized
        formats to floating point inputs (only to integer inputs),
        and WebGL2 / GLES2 does not support integer vertex shader inputs.
*/
struct Vertex_t {
    x     f32
    y     f32
    z     f32
    color u32
    u     f32
    v     f32
}

const vertices = cube_vertices()

fn cube_vertices() []Vertex_t {
    // cube vertex buffer
    d := f32(1.0)
    c := u32(0xFF_FF_FF_FF) // white color RGBA8
    // vfmt off
    // 6 faces, each defined by 4 vertices:
    cube := [
        Vertex_t{-1.0, -1.0, -1.0, c, 0, 0}, Vertex_t{ 1.0, -1.0, -1.0, c, d, 0}, Vertex_t{ 1.0,  1.0, -1.0, c, d, d}, Vertex_t{-1.0,  1.0, -1.0, c, 0, d},
        Vertex_t{-1.0, -1.0,  1.0, c, 0, 0}, Vertex_t{ 1.0, -1.0,  1.0, c, d, 0}, Vertex_t{ 1.0,  1.0,  1.0, c, d, d}, Vertex_t{-1.0,  1.0,  1.0, c, 0, d},
        Vertex_t{-1.0, -1.0, -1.0, c, 0, 0}, Vertex_t{-1.0,  1.0, -1.0, c, d, 0}, Vertex_t{-1.0,  1.0,  1.0, c, d, d}, Vertex_t{-1.0, -1.0,  1.0, c, 0, d},
        Vertex_t{ 1.0, -1.0, -1.0, c, 0, 0}, Vertex_t{ 1.0,  1.0, -1.0, c, d, 0}, Vertex_t{ 1.0,  1.0,  1.0, c, d, d}, Vertex_t{ 1.0, -1.0,  1.0, c, 0, d},
        Vertex_t{-1.0, -1.0, -1.0, c, 0, 0}, Vertex_t{-1.0, -1.0,  1.0, c, d, 0}, Vertex_t{ 1.0, -1.0,  1.0, c, d, d}, Vertex_t{ 1.0, -1.0, -1.0, c, 0, d},
        Vertex_t{-1.0,  1.0, -1.0, c, 0, 0}, Vertex_t{-1.0,  1.0,  1.0, c, d, 0}, Vertex_t{ 1.0,  1.0,  1.0, c, d, d}, Vertex_t{ 1.0,  1.0, -1.0, c, 0, d},
    ]
    // vfmt off
    return cube
}

fn (mut app App) init_glsl_shader(shader_name string, shader_desc &gfx.ShaderDesc, indices []u16) {
    mut vert_buffer_desc := gfx.BufferDesc{}
    unsafe { vmemset(&vert_buffer_desc, 0, sizeof(vert_buffer_desc)) }
    vert_buffer_desc.label = c'cube-vertices'
    vert_buffer_desc.size = usize(vertices.len) * sizeof(Vertex_t)
    vert_buffer_desc.data = gfx.Range{
        ptr: vertices.data
        size: vert_buffer_desc.size
    }
    vert_buffer_desc.type = .vertexbuffer
    vbuf := gfx.make_buffer(&vert_buffer_desc)

    mut index_buffer_desc := gfx.BufferDesc{}
    unsafe { vmemset(&index_buffer_desc, 0, sizeof(index_buffer_desc)) }
    index_buffer_desc.label = c'cube-indices'
    index_buffer_desc.size = usize(indices.len) * sizeof(u16)
    index_buffer_desc.data = gfx.Range{
        ptr: indices.data
        size: index_buffer_desc.size
    }
    index_buffer_desc.type = .indexbuffer
    ibuf := gfx.make_buffer(&index_buffer_desc)

    // create shader
    shader := gfx.make_shader(shader_desc)

    mut pipdesc := gfx.PipelineDesc{}
    unsafe { vmemset(&pipdesc, 0, sizeof(pipdesc)) }
    pipdesc.label = c'glsl_shader pipeline'
    pipdesc.layout.buffers[0].stride = int(sizeof(Vertex_t))

    // the constants [C.ATTR_vs_m_pos, C.ATTR_vs_m_color0, C.ATTR_vs_m_texcoord0] are generated by sokol-shdc
    pipdesc.layout.attrs[C.ATTR_vs_m_pos].format = .float3 // x,y,z as f32
    pipdesc.layout.attrs[C.ATTR_vs_m_color0].format = .ubyte4n // color as u32
    pipdesc.layout.attrs[C.ATTR_vs_m_texcoord0].format = .float2 // u,v as f32
    // pipdesc.layout.attrs[C.ATTR_vs_m_texcoord0].format  = .short2n  // u,v as u16
    pipdesc.shader = shader
    pipdesc.index_type = .uint16
    pipdesc.depth = gfx.DepthState{
        write_enabled: true
        compare: .less_equal
    }
    pipdesc.cull_mode = .back

    mut bind := gfx.Bindings{}
    unsafe { vmemset(&bind, 0, sizeof(bind)) }
    bind.vertex_buffers[0] = vbuf
    bind.index_buffer = ibuf
    bind.fs.images[C.SLOT_tex] = app.texture
    bind.fs.samplers[C.SLOT_smp] = app.sampler
    app.bind[shader_name] = bind
    app.pipe[shader_name] = gfx.make_pipeline(&pipdesc)
    println('${@FN} for shader `${shader_name}` done.')
}

fn calc_tr_matrices(w f32, h f32, rx f32, ry f32, in_scale f32) m4.Mat4 {
    proj := m4.perspective(60, w / h, 0.01, 10.0)
    view := m4.look_at(m4.vec4(0.0, 0, 6, 0), m4.vec4(0, 0, 0, 0), m4.vec4(0, 1, 0, 0))
    view_proj := view * proj

    rxm := m4.rotate(m4.rad(rx), m4.vec4(1, 0, 0, 0))
    rym := m4.rotate(m4.rad(ry), m4.vec4(0, 1, 0, 0))

    model := rym * rxm
    scale_m := m4.scale(m4.vec4(in_scale, in_scale, in_scale, 1))

    res := (scale_m * model) * view_proj
    return res
}

fn (app &App) draw_glsl_shader(shader_name string) {
    ws := gg.window_size_real_pixels()
    ratio := f32(ws.width) / ws.height
    dw := f32(ws.width / 2)
    dh := f32(ws.height / 2)

    rot := [f32(app.mouse_y), f32(app.mouse_x)]
    tr_matrix := calc_tr_matrices(dw, dh, rot[0], rot[1], 2.3)

    // apply the pipeline and bindings
    gfx.apply_pipeline(app.pipe[shader_name])
    gfx.apply_bindings(app.bind[shader_name])

    // Uniforms
    // *** vertex shadeer uniforms ***
    // passing the view matrix as uniform
    // res is a 4x4 matrix of f32 thus: 4*16 byte of size
    vs_uniforms_range := gfx.Range{
        ptr: &tr_matrix
        size: usize(4 * 16)
    }
    gfx.apply_uniforms(.vs, C.SLOT_vs_params_m, &vs_uniforms_range)

    // *** fragment shader uniforms ***
    time_ticks := f32(time.ticks() - start_ticks) / 1000
    mut tmp_fs_params := [
        f32(ws.width),
        ws.height * ratio, // x,y resolution to pass to FS
        0,
        0, // dont send mouse position
        // app.mouse_x,               // mouse x
        // ws.height - app.mouse_y*2, // mouse y scaled
        time_ticks, // time as f32
        f32(app.gg.frame), // frame count
        0,
        0, // padding bytes , see "fs_params" struct paddings in rt_glsl.h
    ]!
    fs_uniforms_range := gfx.Range{
        ptr: unsafe { &tmp_fs_params }
        size: usize(sizeof(tmp_fs_params))
    }
    gfx.apply_uniforms(.fs, C.SLOT_fs_params_p, &fs_uniforms_range)

    // 3 vertices for triangle * 2 triangles per face * 6 faces = 36 vertices to draw
    gfx.draw(0, (3 * 2) * 3, 1)
}

fn (mut app App) frame() {
    mut pass_action := gfx.PassAction{}
    pass_action.colors[0] = gfx.ColorAttachmentAction{
        load_action: .clear
        clear_value: gfx.Color{b: 0.9}
    }
    gfx.begin_pass(sapp.create_default_pass(pass_action))
    if !app.init_flag {
        return
    }
    ws := gg.window_size_real_pixels()
    gfx.apply_viewport(0, 0, ws.width, ws.height, true)
    app.draw_glsl_shader('march')
    app.draw_glsl_shader('puppy')
    gfx.end_pass()
    gfx.commit()
}

fn (mut app App) on_init() {
    // set max vertices, but note, that for a large number of the same type of object it is better use the instances!!
    gfx.setup(sapp.create_desc())
    sgl.setup(sgl.Desc{max_vertices: 50 * 65536})

    // create chessboard texture 256*256 RGBA
    w := 256
    h := 256
    sz := w * h * 4
    tmp_txt := unsafe { malloc(sz) }
    defer {
        unsafe { free(tmp_txt) }
    }
    mut i := 0
    for i < sz {
        unsafe {
            y := (i >> 0x8) >> 5 // 8 cell
            x := (i & 0xFF) >> 5 // 8 cell
            // upper left corner
            if x == 0 && y == 0 {
                tmp_txt[i + 0] = 0xFF
                tmp_txt[i + 1] = 0
                tmp_txt[i + 2] = 0
                tmp_txt[i + 3] = 0xFF
            }
            // low right corner
            else if x == 7 && y == 7 {
                tmp_txt[i + 0] = 0
                tmp_txt[i + 1] = 0xFF
                tmp_txt[i + 2] = 0
                tmp_txt[i + 3] = 0xFF
            } else {
                col := if ((x + y) & 1) == 1 { u8(0xFF) } else { 128 }
                tmp_txt[i + 0] = col // red
                tmp_txt[i + 1] = col // green
                tmp_txt[i + 2] = col // blue
                tmp_txt[i + 3] = 0xFF // alpha
            }
            i += 4
        }
    }
    app.texture, app.sampler = create_texture(w, h, tmp_txt)

    // vfmt off
    app.init_glsl_shader('march', voidptr(C.rt_march_shader_desc(C.sg_query_backend())), [
        u16(0), 1,  2,    0,   2,  3,
            6,  5,  4,    7,   6,  4,
            8,  9, 10,    8,  10, 11,
    ])
    app.init_glsl_shader('puppy', voidptr(C.rt_puppy_shader_desc(C.sg_query_backend())), [
        u16(14), 13, 12,  15, 14, 12,
            16,  17, 18,  16, 18, 19,
            22,  21, 20,  23, 22, 20,
    ])
    // vfmt on
    app.init_flag = true
}

/******************************************************************************
* events handling
******************************************************************************/
fn (mut app App) on_event(ev &gg.Event, x voidptr) {
    if ev.typ == .mouse_down {
        app.mouse_down = true
    }
    if ev.typ == .mouse_up {
        app.mouse_down = false
    }
    if app.mouse_down == true && ev.typ == .mouse_move {
        app.mouse_x = int(ev.mouse_x)
        app.mouse_y = int(ev.mouse_y)
    }
    if ev.typ == .touches_began || ev.typ == .touches_moved {
        if ev.num_touches > 0 {
            touch_point := ev.touches[0]
            app.mouse_x = int(touch_point.pos_x)
            app.mouse_y = int(touch_point.pos_y)
        }
    }
    // eprintln('> app.mouse_x: ${app.mouse_x} | app.mouse_y: ${app.mouse_y}')
}

fn main() {
    mut app := &App{}
    app.gg = gg.new_context(
        width:        800
        height:       800
        window_title: '3D Dual shader Cube - click and rotate with the mouse'
        user_data:    app
        frame_fn:     app.frame
        init_fn:      app.on_init
        event_fn:     app.on_event
    )
    app.gg.run()
}