MeshResources.h

Go to the documentation of this file.

#pragma once

#include "swCommonLib/Common/ObjectDeleter.h"
#include "swCommonLib/System/Path.h"

#include "swGraphicAPI/Resources/ResourceObject.h"
#include "swGraphicAPI/Resources/IShader.h"
#include "swGraphicAPI/Resources/IBuffer.h"
#include "swGraphicAPI/Resources/IRenderTarget.h"
#include "swGraphicAPI/Resources/IShaderInputLayout.h"
#include "swGraphicAPI/Rendering/GraphicAPIConstants.h"
#include "swGraphicAPI/Resources/ResourcePtr.h"
#include "swGraphicAPI/Resources/BufferInitData.h"

#include <DirectXMath.h>


//definicje
#define WRONG_ID                        0

class AssetsManager;
struct ModelPart;
class BufferObject;
class TextureObject;
class VertexShader;
class PixelShader;
struct MeshPartObject;
struct MaterialObject;

/*
// W buforze wierzchołków znajdują się elementy typu VERT_INDEX.
// Definicja typu VERT_INDEX znajduje się w pliku macros_switches.h i wygląda tak:

#if defined(INDEX_BUFFER_UINT16)
typedef UINT16 VERT_INDEX;
#elif defined(INDEX_BUFFER_UINT32)
typedef UINT32 VERT_INDEX;
#else
typedef UINT32 VERT_INDEX;
#endif

*/


static const std::wstring RENDER_TARGET_COLOR_BUFFER_NAME = L"::color";
static const std::wstring RENDER_TARGET_DEPTH_BUFFER_NAME = L"::depth";
static const std::wstring RENDER_TARGET_STENCIL_BUFFER_NAME = L"::stencil";


typedef uint16 Index16;
typedef uint32 Index32;
typedef uint8 Index8;


enum TextureUse
{
    TEX_DIFFUSE         
    , TEX_SPECULAR      
    , TEX_EMISSIVE      
    , TEX_BUMP_MAP      
    , TEX_DISPLACEMENT_MAP      
    , TEX_OTHER1        
    , TEX_OTHER2        
    , TEX_LIGHTMAP      
};




//----------------------------------------------------------------------------------------------//
//                              TextureObject                                                   //
//----------------------------------------------------------------------------------------------//

enum class MipMapFilter : short
{
    Box = 0,        
    Tent,           
    Bell,           
    bSpline,        
    Mitchell,       
    Lanczos3,       
    Blackman,       
    Lanczos4,       
    Lanczos6,       
    Lanczos12,      
    Kaiser,         
    Gaussian,       
    Catmullrom,     
    QuadraticInterpolation,     
    QuadraticAproximation,      
    QuadraticMix,               

    Unknown                     
};


struct TextureInfo
{
    uint16              TextureWidth;               
    uint16              TextureHeight;              
    uint16              ArraySize;                  
    bool                CPURead : 1;                
    bool                CPUWrite : 1;               
    bool                AllowShareResource : 1;     
    bool                IsCubeMap : 1;              
    bool                GenerateMipMaps : 1;        
    TextureType         TextureType;                
    ResourceUsage       Usage;                      
    ResourceFormat      Format;                     
    MipMapFilter        MipMapFilter;               
    uint16              MipMapLevels;               
    uint16              CutOffMipMaps;              

    uint32              MemorySize;                 
    filesystem::Path    FilePath;                   
    
    TextureInfo()
    {
        ArraySize = 1;
        CPURead = false;
        CPUWrite = false;
        AllowShareResource = false;
        IsCubeMap = false;
        GenerateMipMaps = false;
        Usage = ResourceUsage::RESOURCE_USAGE_DEFAULT;
        MipMapFilter = MipMapFilter::Unknown;
        MipMapLevels = 1;
        CutOffMipMaps = 0;
        TextureType = TextureType::TEXTURE_TYPE_TEXTURE2D;
        MemorySize = 0;
    }

private:
    RTTR_REGISTRATION_FRIEND;
    
    int     GetWidth        ()      { return TextureWidth; }
    int     GetHeight       ()      { return TextureHeight; }
    int     GetArraySize    ()      { return ArraySize; }
    bool    IsCPUReadable   ()      { return CPURead; }
    bool    IsCPUWriteable  ()      { return CPUWrite; }
    bool    IsSharedResource()      { return AllowShareResource; }
    bool    IsCubeMapTex    ()      { return IsCubeMap; }
    bool    GenMipMaps      ()      { return GenerateMipMaps; }
    int     GetMipLevels    ()      { return MipMapLevels; }

    std::string     GetPath ()      { return FilePath.String(); }
};

class TextureObject : public ResourceObject
{
    RTTR_ENABLE( ResourceObject );
    friend ObjectDeleter<TextureObject>;
private:
protected:
    virtual ~TextureObject() = default;
public:
    TextureObject() : ResourceObject( 0 ) {}

    virtual const filesystem::Path&     GetFilePath     () const = 0;       

    virtual MemoryChunk                 CopyData        () const = 0;       
    virtual const TextureInfo&          GetDescriptor   () const = 0;       

    virtual std::string                 GetResourceName () const override { return GetFilePath().String(); }

    inline bool operator==( TextureObject& object );
    inline bool operator==( const std::wstring& file_name );
};

//----------------------------------------------------------------------------------------------//
//                              RenderTargetObject                                              //
//----------------------------------------------------------------------------------------------//

struct RenderTargetDescriptor
{
    uint16              TextureWidth;               
    uint16              TextureHeight;              
    uint16              ArraySize;                  
    bool                CPURead : 1;                
    bool                CPUWrite : 1;               
    bool                AllowShareResource : 1;     
    bool                IsCubeMap : 1;              
    uint8               NumSamples;                 
    uint16              SamplesQuality;             
    TextureType         TextureType;                
    ResourceFormat      ColorBuffFormat;            
    DepthStencilFormat  DepthStencilFormat;         
    ResourceUsage       Usage;                      

    RenderTargetDescriptor()
    {
        ArraySize = 1;
        CPURead = 0;
        CPUWrite = 0;
        AllowShareResource = 0;
        IsCubeMap = 0;
        Usage = ResourceUsage::RESOURCE_USAGE_DEFAULT;
    }

    TextureInfo     CreateTextureInfo() const
    {
        TextureInfo texInfo;
        texInfo.TextureWidth = TextureWidth;
        texInfo.TextureHeight = TextureHeight;
        texInfo.ArraySize = ArraySize;
        texInfo.CPURead = CPURead;
        texInfo.CPUWrite = CPUWrite;
        texInfo.AllowShareResource = AllowShareResource;
        texInfo.IsCubeMap = IsCubeMap;
        texInfo.TextureType = TextureType;
        texInfo.Usage = Usage;

        return texInfo;
    }
};

class RenderTargetObject : public IRenderTarget
{
    RTTR_ENABLE( IRenderTarget );
    RTTR_REGISTRATION_FRIEND;
private:
protected:
    ResourcePtr< TextureObject >    m_colorBuffer;          
    ResourcePtr< TextureObject >    m_depthBuffer;          
    ResourcePtr< TextureObject >    m_stencilBuffer;        
public:
    RenderTargetObject( TextureObject* colorBuffer, TextureObject* depthBuffer, TextureObject* stencilBuffer );
    virtual ~RenderTargetObject();

    inline TextureObject*       GetColorBuffer()            { return m_colorBuffer.Ptr(); }     
    inline TextureObject*       GetDepthBuffer()            { return m_depthBuffer.Ptr(); }     
    inline TextureObject*       GetStencilBuffer()          { return m_stencilBuffer.Ptr(); }       

    virtual std::string         GetResourceName () const override;  
};

//----------------------------------------------------------------------------------------------//
//                              ShaderInputLayout                                               //
//----------------------------------------------------------------------------------------------//

class ShaderInputLayout : public IShaderInputLayout
{
    RTTR_ENABLE( IShaderInputLayout );
    friend ObjectDeleter< ShaderInputLayout >;
private:
protected:
    virtual ~ShaderInputLayout() = default;
public:
    ShaderInputLayout() = default;

    virtual std::string         GetResourceName () const override { return ""; }
};

class InputLayoutDescriptor
{
private:
    std::wstring                m_inputLayoutName;
protected:
public:
    InputLayoutDescriptor( const std::wstring& layoutName ) : m_inputLayoutName( layoutName ){}
    virtual ~InputLayoutDescriptor() = default;

    virtual void        AddRow      ( const char* semanticName, ResourceFormat format, unsigned int inputSlot, unsigned int byteOffset, bool perInstance, unsigned int instanceDataStep ) = 0;

    std::wstring&       GetName     () { return m_inputLayoutName; }
};


enum class ShaderType : uint8
{
    VertexShader                = 0x01,
    PixelShader                 = 0x02,
    GeometryShader              = 0x04,
    TesselationControlShader    = 0x08,
    TesselationEvaluationShader = 0x10,
    ComputeShader               = 0x20
};

//----------------------------------------------------------------------------------------------//
//                              VertexShader                                                    //
//----------------------------------------------------------------------------------------------//

class VertexShader : public IShader
{
    RTTR_ENABLE( IShader );
    friend ObjectDeleter< VertexShader >;
private:
protected:
    ~VertexShader() = default;
public:
    VertexShader() = default;

    virtual std::string         GetResourceName () const override { return ""; }
};

//----------------------------------------------------------------------------------------------//
//                              PixelShader                                                     //
//----------------------------------------------------------------------------------------------//

class PixelShader : public IShader
{
    RTTR_ENABLE( IShader );
    friend ObjectDeleter< PixelShader >;
private:
protected:
    ~PixelShader() = default;
public:
    PixelShader() = default;

    virtual std::string         GetResourceName () const override { return ""; }
};

//----------------------------------------------------------------------------------------------//
//                              GeometryShader                                                  //
//----------------------------------------------------------------------------------------------//

class GeometryShader : public IShader
{
    RTTR_ENABLE( IShader );
    friend ObjectDeleter<GeometryShader>;
private:
protected:
    ~GeometryShader() = default;
public:
    GeometryShader() = default;

    virtual std::string         GetResourceName () const override { return ""; }
};

//----------------------------------------------------------------------------------------------//
//                              ControlShader                                                   //
//----------------------------------------------------------------------------------------------//

class ControlShader : public IShader
{
    RTTR_ENABLE( IShader );
    friend ObjectDeleter< ControlShader >;
private:
protected:
    ~ControlShader() = default;
public:
    ControlShader() = default;

    virtual std::string         GetResourceName () const override { return ""; }
};

//----------------------------------------------------------------------------------------------//
//                              EvaluationShader                                                //
//----------------------------------------------------------------------------------------------//

class EvaluationShader : public IShader
{
    RTTR_ENABLE( IShader );
    friend ObjectDeleter< EvaluationShader >;
private:
protected:
    ~EvaluationShader() = default;
public:
    EvaluationShader() = default;

    virtual std::string         GetResourceName () const override { return ""; }
};

//----------------------------------------------------------------------------------------------//
//                              ComputeShader                                                   //
//----------------------------------------------------------------------------------------------//

class ComputeShader : public IShader
{
    RTTR_ENABLE( IShader );
    friend ObjectDeleter<ComputeShader>;
private:
protected:
    ~ComputeShader() = default;
public:
    ComputeShader() = default;

    virtual std::string         GetResourceName () const override { return ""; }
};

//----------------------------------------------------------------------------------------------//
//                              BufferObject                                                    //
//----------------------------------------------------------------------------------------------//

class BufferObject : public IBuffer
{
    RTTR_ENABLE( IBuffer )
    friend ObjectDeleter<BufferObject>;
protected:
    unsigned int        m_elementSize;          
    unsigned int        m_elementCount;         

    ~BufferObject() = default;
public:
    BufferObject( unsigned int elementSize, unsigned int elementCount );

    inline unsigned int GetStride()             { return m_elementSize; }       
    inline unsigned int GetElementSize()        { return m_elementSize; }       
    inline unsigned int GetElementCount()       { return m_elementCount; }      

    virtual std::string GetResourceName () const override { return GetDescriptor().GetName(); }
};

//----------------------------------------------------------------------------------------------//
//                              MaterialObject                                                  //
//----------------------------------------------------------------------------------------------//


struct MaterialObject : public ResourceObject
{
    RTTR_ENABLE( ResourceObject );
public:
    friend ObjectDeleter<MaterialObject>;

    DirectX::XMFLOAT4       Diffuse;        //Składowa przezroczystości odnosi się do całego materiału
    DirectX::XMFLOAT4       Ambient;
    DirectX::XMFLOAT4       Specular;
    DirectX::XMFLOAT4       Emissive;
    float                   Power;

    MaterialObject( unsigned int id = WRONG_ID ) : ResourceObject( id ){}
    MaterialObject( const MaterialObject* material );

    void SetNullMaterial();

    virtual std::string GetResourceName () const override { return ""; }
};