renderer.h

//##################################################################################################
//
// Copyright (c) 2024 Beijing Qiongqi Tech Co.,Ltd. All rights reserved. 
 
// This source code is confidential and proprietary to Beijing Qiongqi Tech Co.,Ltd(The Holder). 
// Any unauthorized use, copying, modification, or distribution of the code is strictly prohibited. 
// Any user shall obtain authorizaition from the Holder before modifying the source code. And the user shall not
// sublicense, sell, distribute, or transfer the source code, whether in original or modified form, to any third party
// without the prior written consent of the Holder.
 
// This copyright notice and permission grant shall be included in all copies or substantial portions of the source code.
 
// Author  Cumulia Illustrator
// Date    2025-08-05
// Version V2.1.0
//##################################################################################################
 
#pragma once
 
#include <memory>
 
#include "assetmanager.h"
#include "scenemanager.h"
#include "rendercontext.h"
 
#include "../variant/types.h"
#include "../primitive/types.h"
#include "../scene/types.h"
 
namespace cil
{
    class Renderer
    {
        friend class Stats;
 
    protected:
        std::shared_ptr<RenderContext> renderContext;
 
    private:
        std::shared_ptr<AssetManager> assetManager;
        std::shared_ptr<SceneManager> sceneManager;
 
    public:
        Renderer();
        virtual ~Renderer();
 
        void makeCurrent();
 
        virtual void render(const ScenePtr& scene);
 
        Image2DPtr read(const ImageBufferPtr& buffer);
 
        void add(const ScenePtr& scene);
        void add(const PassPtr& pass);
        void add(const NodePtr& node);
        void add(const MeshPtr& mesh);
        void add(const TargetPtr& target);
        void add(const PrimitivePtr& primitive);
        void add(const MaterialPtr& material);
        void add(const GeometryPtr& geometry);
        void add(const ProgramPtr& program);
        void add(const TexturePtr& texture);
        void add(const VerticesPtr& vertices);
        void add(const ElementIndicesPtr& indices);
        void add(const SourcePtr& source);
        void add(const ImagePtr& image);
        void add(const SamplerPtr& sampler);
        void add(const ArrayBufferPtr& buffer);
 
        void remove(const ScenePtr& scene);
        void remove(const PassPtr& pass);
        void remove(const NodePtr& node);
        void remove(const MeshPtr& mesh);
        void remove(const TargetPtr& target);
        void remove(const PrimitivePtr& primitive);
        void remove(const MaterialPtr& material);
        void remove(const GeometryPtr& geometry);
        void remove(const ProgramPtr& program);
        void remove(const TexturePtr& texture);
        void remove(const VerticesPtr& vertices);
        void remove(const ElementIndicesPtr& indices);
        void remove(const SourcePtr& source);
        void remove(const ImagePtr& image);
        void remove(const SamplerPtr& sampler);
        void remove(const ArrayBufferPtr& buffer);
 
        void update(const ScenePtr& scene);
        void update(const PassPtr& pass);
        void update(const NodePtr& node);
        void update(const MeshPtr& mesh);
        void update(const TargetPtr& target);
        void update(const PrimitivePtr& primitive);
        void update(const MaterialPtr& material);
        void update(const GeometryPtr& geometry);
        void update(const ProgramPtr& program);
        void update(const TexturePtr& texture);
        void update(const VerticesPtr& vertices);
        void update(const ElementIndicesPtr& indices);
        void update(const SourcePtr& source);
        void update(const ImagePtr& image);
        void update(const SamplerPtr& sampler);
        void update(const ArrayBufferPtr& buffer);
 
        void clear();
 
        void free(bool unused = false);
    };
}