sparse_voxel_octree.h

Go to the documentation of this file.

/*
 * Dune D3D library - Tobias Alexander Franke 2013
 * For copyright and license see LICENSE
 * http://www.tobias-franke.eu
 */

#ifndef DUNE_SPARSE_VOXEL_OCTREE
#define DUNE_SPARSE_VOXEL_OCTREE

#include <D3D11.h>

#include "render_target.h"
#include "shader_resource.h"
#include "cbuffer.h"
#include "d3d_tools.h"
#include "composite_mesh.h"
#include "deferred_renderer.h"
#include "light.h"

namespace dune
{
    struct d3d_mesh;
    class gilga_mesh;

    class sparse_voxel_octree : public shader_resource
    {
    public:
        struct param
        {
            float gi_scale;
            float glossiness;
            UINT num_vpls;
            BOOL debug_gi;
        };

    protected:
        ID3D11BlendState*           bs_voxelize_;
        ID3D11SamplerState*         ss_visualize_;

        ID3D11VertexShader*         vs_voxelize_;
        ID3D11GeometryShader*       gs_voxelize_;
        ID3D11PixelShader*          ps_voxelize_;

        ID3D11VertexShader*         vs_inject_;
        ID3D11PixelShader*          ps_inject_;

        INT                         inject_rsm_rho_start_slot_;

        ID3D11Texture3D*            v_normal_;
        ID3D11Texture3D*            v_rho_;

        ID3D11ShaderResourceView*   srv_v_normal_;
        ID3D11ShaderResourceView*   srv_v_rho_;

        ID3D11UnorderedAccessView*  uav_v_normal_;
        ID3D11UnorderedAccessView*  uav_v_rho_;

        ID3D11RasterizerState*      no_culling_;

        UINT                        volume_size_;

        DirectX::XMFLOAT4X4         world_to_svo_;
        DirectX::XMFLOAT3           svo_min_, svo_max_;

        struct cbs_parameters
        {
            DirectX::XMFLOAT4X4 world_to_svo;
            DirectX::XMFLOAT4   bb_min;
            DirectX::XMFLOAT4   bb_max;
        };

        cbuffer<cbs_parameters> cb_parameters_;

        dune::profile_query profiler_;

        typedef cbuffer<param> cb_gi_parameters;
        cb_gi_parameters cb_gi_parameters_;

        UINT last_bound_;

    protected:
        virtual void clear_ps(ID3D11DeviceContext* context);

    public:
        float time_voxelize_;
        float time_inject_;
        float time_mip_;

    public:
        sparse_voxel_octree();
        virtual ~sparse_voxel_octree() {}


        cb_gi_parameters& parameters() { return cb_gi_parameters_; }
        const cb_gi_parameters& parameters() const { return cb_gi_parameters_; }

        virtual void create(ID3D11Device* device, UINT volume_size);
        virtual void destroy();

        void set_shader_voxelize(ID3D11VertexShader* vs, ID3D11GeometryShader* gs, ID3D11PixelShader* ps);

        void set_shader_inject(ID3D11VertexShader* vs, ID3D11PixelShader* ps, UINT rsm_start_slot);

        void voxelize(ID3D11DeviceContext* context, gilga_mesh& mesh, bool clear = true);

        virtual void inject(ID3D11DeviceContext* context, directional_light& light);

        void filter(ID3D11DeviceContext* context);


        void set_model_matrix(ID3D11DeviceContext* context, const DirectX::XMFLOAT4X4& model, const DirectX::XMFLOAT3& svo_min, const DirectX::XMFLOAT3& svo_max, UINT svo_parameters_slot);
        const DirectX::XMFLOAT4X4& world_to_svo() const { return world_to_svo_; }

        virtual void to_ps(ID3D11DeviceContext* context, UINT volume_start_slot);
    };

    class delta_sparse_voxel_octree : public sparse_voxel_octree
    {
    protected:
        ID3D11Texture3D*            v_delta_;
        ID3D11ShaderResourceView*   srv_v_delta_;
        ID3D11UnorderedAccessView*  uav_v_delta_;

        INT                         inject_rsm_mu_start_slot_;

    protected:
        virtual void clear_ps(ID3D11DeviceContext* context);

    public:
        delta_sparse_voxel_octree();
        virtual ~delta_sparse_voxel_octree() {}

        virtual void create(ID3D11Device* device, UINT volume_size);
        virtual void destroy();

        void set_shader_inject(ID3D11VertexShader* vs, ID3D11PixelShader* ps, UINT mu_start_slot, UINT rho_start_slot);

        virtual void inject(ID3D11DeviceContext* context, differential_directional_light& light);
        virtual void to_ps(ID3D11DeviceContext* context, UINT volume_start_slot);
    };
}

#endif