Shader.h

/*     Copyright 2015-2018 Egor Yusov
 *  
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS.
 *
 *  In no event and under no legal theory, whether in tort (including negligence), 
 *  contract, or otherwise, unless required by applicable law (such as deliberate 
 *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
 *  liable for any damages, including any direct, indirect, special, incidental, 
 *  or consequential damages of any character arising as a result of this License or 
 *  out of the use or inability to use the software (including but not limited to damages 
 *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and 
 *  all other commercial damages or losses), even if such Contributor has been advised 
 *  of the possibility of such damages.
 */

#pragma once


#include "DeviceObject.h"
#include "ResourceMapping.h"
#include "FileStream.h"
#include "Sampler.h"

namespace Diligent
{

// {2989B45C-143D-4886-B89C-C3271C2DCC5D}
static constexpr INTERFACE_ID IID_Shader =
{ 0x2989b45c, 0x143d, 0x4886, { 0xb8, 0x9c, 0xc3, 0x27, 0x1c, 0x2d, 0xcc, 0x5d } };

// {0D57DF3F-977D-4C8F-B64C-6675814BC80C}
static constexpr INTERFACE_ID IID_ShaderVariable =
{ 0xd57df3f, 0x977d, 0x4c8f, { 0xb6, 0x4c, 0x66, 0x75, 0x81, 0x4b, 0xc8, 0xc } };

enum SHADER_TYPE : Int32
{
    SHADER_TYPE_UNKNOWN     = 0x000, 
    SHADER_TYPE_VERTEX      = 0x001, 
    SHADER_TYPE_PIXEL       = 0x002, 
    SHADER_TYPE_GEOMETRY    = 0x004, 
    SHADER_TYPE_HULL        = 0x008, 
    SHADER_TYPE_DOMAIN      = 0x010, 
    SHADER_TYPE_COMPUTE     = 0x020  
};

enum SHADER_PROFILE : Int32
{
    SHADER_PROFILE_DEFAULT = 0,
    SHADER_PROFILE_DX_4_0,
    SHADER_PROFILE_DX_5_0,
    SHADER_PROFILE_DX_5_1,
    SHADER_PROFILE_GL_4_2
};

enum SHADER_SOURCE_LANGUAGE : Int32
{
    SHADER_SOURCE_LANGUAGE_DEFAULT = 0,

    SHADER_SOURCE_LANGUAGE_HLSL,

    SHADER_SOURCE_LANGUAGE_GLSL
};

enum BIND_SHADER_RESOURCES_FLAGS : Int32
{
    BIND_SHADER_RESOURCES_RESET_BINDINGS = 0x01,

    BIND_SHADER_RESOURCES_UPDATE_UNRESOLVED = 0x02,

    BIND_SHADER_RESOURCES_ALL_RESOLVED = 0x04
};

enum SHADER_VARIABLE_TYPE : Int32
{
    SHADER_VARIABLE_TYPE_STATIC = 0, 

    SHADER_VARIABLE_TYPE_MUTABLE,

    SHADER_VARIABLE_TYPE_DYNAMIC,

    SHADER_VARIABLE_TYPE_NUM_TYPES
};

struct ShaderVariableDesc
{
    const Char *Name;

    SHADER_VARIABLE_TYPE Type;
    ShaderVariableDesc(const Char *_Name = nullptr, SHADER_VARIABLE_TYPE _Type = SHADER_VARIABLE_TYPE_STATIC) : 
        Name(_Name),
        Type(_Type)
    {}
};


struct StaticSamplerDesc
{
    const Char* TextureName = nullptr;

    SamplerDesc Desc;

    StaticSamplerDesc(){};
    StaticSamplerDesc(const Char* _TexName, const SamplerDesc &_Desc) : 
        TextureName(_TexName),
        Desc(_Desc)
    {}
};

struct ShaderDesc : DeviceObjectAttribs
{
    SHADER_TYPE ShaderType;

    Bool bCacheCompiledShader;
    SHADER_PROFILE TargetProfile;

    SHADER_VARIABLE_TYPE DefaultVariableType;

    const ShaderVariableDesc *VariableDesc;

    Uint32 NumVariables;

    Uint32 NumStaticSamplers;
    
    const StaticSamplerDesc *StaticSamplers;

    ShaderDesc() : 
        ShaderType(SHADER_TYPE_VERTEX),
        bCacheCompiledShader(False),
        TargetProfile(SHADER_PROFILE_DEFAULT),
        DefaultVariableType(SHADER_VARIABLE_TYPE_STATIC),
        VariableDesc(nullptr),
        NumVariables(0),
        NumStaticSamplers(0),
        StaticSamplers(nullptr)
    {}
};

class IShaderSourceInputStreamFactory
{
public:
    virtual void CreateInputStream(const Diligent::Char *Name, IFileStream **ppStream) = 0;
};

struct ShaderMacro
{
    const Char* Name;
    const Char* Definition;
    ShaderMacro(const Char* _Name, const Char* _Def) : Name( _Name ), Definition( _Def ) {}
};

struct ShaderCreationAttribs
{

    const Char* FilePath = nullptr;


    IShaderSourceInputStreamFactory *pShaderSourceStreamFactory = nullptr;

    
    class IHLSL2GLSLConversionStream **ppConversionStream = nullptr;


    const Char* Source = nullptr;

    
    const void *ByteCode = nullptr;


    size_t ByteCodeSize = 0;


    const Char* EntryPoint = "main";


    const ShaderMacro *Macros = nullptr;

    ShaderDesc Desc;

    SHADER_SOURCE_LANGUAGE SourceLanguage = SHADER_SOURCE_LANGUAGE_DEFAULT;
};


class IShaderVariable : public IObject
{
public:

    virtual void Set(IDeviceObject *pObject) = 0;


    virtual void SetArray(IDeviceObject* const* ppObjects, Uint32 FirstElement, Uint32 NumElements) = 0;
};

class IShader : public IDeviceObject
{
public:
    virtual void QueryInterface( const Diligent::INTERFACE_ID &IID, IObject **ppInterface ) = 0;
    
    virtual const ShaderDesc &GetDesc()const = 0;

    virtual void BindResources( IResourceMapping* pResourceMapping, Uint32 Flags ) = 0;

    
    virtual IShaderVariable* GetShaderVariable(const Char* Name) = 0;
};

}