models.h

Go to the documentation of this file.

#pragma once
 
#include <bgfx/bgfx.h>
#include <bx/math.h>
#include <vector>
 
#include "components/rendering/bgfx/shaders/shaders.h"
#include "components/content/tags/classes/render_model.h"
 
#ifndef BLAM
#define BLAM
#endif
 
struct PosColorVertex
{
    float x;
    float y;
    float z;
    uint32_t abgr;
};
 
struct BlamRenderModel
{
    render_model model;
 
    float rotation_x = 0.0f;
    float rotation_y = 0.0f;
 
    std::vector<PosColorVertex> verticies;
    std::vector<uint16_t> triangles;
 
    const bgfx::Memory* verticies_data;
    const bgfx::Memory* triangles_data;
 
    bgfx::VertexBufferHandle vertex_buffer = { 0 };
    bgfx::IndexBufferHandle index_buffer = { 0 };
    bgfx::VertexLayout vertex_layout;
 
    bool draw_ready = false;
    bool drawing = false;
 
    BlamRenderModel()
    {
        verticies = {
        {-1.0f,  1.0f,  1.0f, 0xff000000 },
        { 1.0f,  1.0f,  1.0f, 0xff0000ff },
        {-1.0f, -1.0f,  1.0f, 0xff00ff00 },
        { 1.0f, -1.0f,  1.0f, 0xff00ffff },
        {-1.0f,  1.0f, -1.0f, 0xffff0000 },
        { 1.0f,  1.0f, -1.0f, 0xffff00ff },
        {-1.0f, -1.0f, -1.0f, 0xffffff00 },
        { 1.0f, -1.0f, -1.0f, 0xffffffff },
        };
 
        triangles = {
        0, 1, 2,
        1, 3, 2,
        4, 6, 5,
        5, 6, 7,
        0, 2, 4,
        4, 2, 6,
        1, 5, 3,
        5, 7, 3,
        0, 4, 1,
        4, 5, 1,
        2, 3, 6,
        6, 3, 7,
        };
 
        Rebuild();
    }
 
    ~BlamRenderModel()
    {
        draw_ready = false;
 
        while (drawing)
        {
            // Wait for drawing to stop
        }
 
        if (vertex_buffer.idx != 0)
        {
            bgfx::destroy(vertex_buffer);
        }
 
        if (index_buffer.idx != 0)
        {
            bgfx::destroy(index_buffer);
        }
    }
 
    void Rebuild()
    {
        draw_ready = false;
 
        while (drawing)
        {
            // Wait for drawing to stop
        }
 
        if (vertex_buffer.idx != 0)
        {
            bgfx::destroy(vertex_buffer);
        }
 
        if (index_buffer.idx != 0)
        {
            bgfx::destroy(index_buffer);
        }
 
        vertex_layout.begin()
            .add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float)
            .add(bgfx::Attrib::Color0, 4, bgfx::AttribType::Uint8, true)
            .end();
 
        uint32_t verticies_size = verticies.size() * sizeof(PosColorVertex);
        uint32_t triangles_size = triangles.size() * sizeof(uint16_t);
 
        verticies_data = bgfx::copy(verticies.data(), verticies_size);
        triangles_data = bgfx::copy(triangles.data(), triangles_size);
 
        vertex_buffer = bgfx::createVertexBuffer(verticies_data, vertex_layout);
        index_buffer = bgfx::createIndexBuffer(triangles_data);
 
        draw_ready = true;
    }
 
    void Draw()
    {
        if (draw_ready)
        {
            drawing = true;
 
            float mtx[16];
            bx::mtxRotateXY(mtx, rotation_x, rotation_y);
            bgfx::setTransform(mtx);
 
            bgfx::setVertexBuffer(0, vertex_buffer);
            bgfx::setIndexBuffer(index_buffer);
 
            bgfx::ProgramHandle program = BlamRendering::BGFX::Shaders::GetShaderProgram("test_program")->GetProgramHandle();
            bgfx::submit(0, program);
 
            drawing = false;
        }
    }
};
 
namespace BlamRendering::Models
{
    BLAM BlamRenderModel* GetTestModel();
}