OGLResourceCache.h

//
//  OGLResourceCache.h
//  avara3d
//
//  Created by Morgan Davis on 12/31/25.
//  Copyright © 2026 Morgan K Davis. All rights reserved.
//
 
#ifndef AVARA3D_RENDER_BACKEND_OPENGL_OGLRESOURCECACHE_H
#define AVARA3D_RENDER_BACKEND_OPENGL_OGLRESOURCECACHE_H
 
#include <array>
#include <cstdint>
#include <unordered_map>
#include <vector>
 
#include "a3d/render/PipelineDesc.h"
#include "a3d/render/backend/opengl/GLTypes.h"
 
namespace a3d {
 
    class Material;
    class MeshElement;
    class OGLMemoryTracker;
    class Texture;
 
    // [Internal Types]
 
    struct OGLPipeline {
        PipelineDesc desc    = {};
        gl::uint_t   program = 0;
    };
 
    struct OGLMeshElement {
        gl::uint_t   vao             = 0;
        gl::uint_t   vbo             = 0;
        gl::uint_t   ebo             = 0;
        gl::enum_t   indexType       = gl::value::unsigned_int;
        uint32_t     indexCount      = 0;
        uint32_t     vertexCount     = 0;
        VertexLayout vertexLayoutKey = VertexLayout::None;
    };
 
    static constexpr size_t NUM_MATERIAL_PROPERTY_SLOTS = 4;
 
    struct OGLMaterial {
        std::array<gl::uint_t, NUM_MATERIAL_PROPERTY_SLOTS> tex              = {};
        float                                               specularExponent = 75.0f;
        float                                               uvScale          = 1.0f;
    };
 
    struct OGLTexture {
        gl::uint_t id = 0;
    };
 
    class OGLResourceCache {
 
    public:
        // [Internal Lifecycle Functions]
 
        explicit OGLResourceCache(OGLMemoryTracker& memoryTracker);
 
        OGLResourceCache(const OGLResourceCache&)            = delete;
        OGLResourceCache& operator=(const OGLResourceCache&) = delete;
 
        OGLResourceCache(OGLResourceCache&&)            = delete;
        OGLResourceCache& operator=(OGLResourceCache&&) = delete;
 
        ~OGLResourceCache();
 
        // [Internal Member Functions]
 
        PipelineId            ensurePipeline(const PipelineDesc& desc, gl::uint_t program);
        const OGLPipeline&    pipeline(PipelineId pipelineId) const;
        const OGLMeshElement& ensureMeshElement(MeshElement& element);
        const OGLMaterial&    ensureMaterial(Material& material);
        const OGLTexture&     ensureTexture(Texture& texture);
 
    private:
        // [Private Member Variables]
 
        OGLMemoryTracker&                                              _memoryTracker;
        std::unordered_map<PipelineDesc, PipelineId, PipelineDescHash> _pipelineMap;
        std::vector<OGLPipeline>                                       _pipelineList;
        std::unordered_map<MeshElement*, OGLMeshElement>               _meshElementMap;
        std::unordered_map<Material*, OGLMaterial>                     _materialMap;
        std::unordered_map<Texture*, OGLTexture>                       _textureMap;
    };
 
}
 
#endif // AVARA3D_RENDER_BACKEND_OPENGL_OGLRESOURCECACHE_H