IRenderer.h

/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.

#pragma once

#include "Cry_Geo.h"
#include "Cry_Camera.h"
#include <CryEngineAPI.h>
#include <IFlares.h> // <> required for Interfuscator
#include <AzCore/Casting/numeric_cast.h>

#include "IResourceCompilerHelper.h" //  for IResourceCompilerHelper::ERcCallResult

// forward declarations
struct SRenderingPassInfo;
struct IFoliage;
struct SRTStack;

// Callback used for DXTCompress
typedef void (* MIPDXTcallback)(const void* buffer, size_t count, void* userData);

typedef void (* GpuCallbackFunc)(DWORD context);

// Callback for shadercache miss
typedef void (* ShaderCacheMissCallback)(const char* acShaderRequest);

struct ICaptureFrameListener
{
    virtual ~ICaptureFrameListener (){}
    virtual bool OnNeedFrameData(unsigned char*& pConvertedTextureBuf) = 0;
    virtual void OnFrameCaptured(void) = 0;
    virtual int OnGetFrameWidth(void) = 0;
    virtual int OnGetFrameHeight(void) = 0;
    virtual int OnCaptureFrameBegin(int* pTexHandle) = 0;

    enum ECaptureFrameFlags
    {
        eCFF_NoCaptureThisFrame = (0 << 1),
        eCFF_CaptureThisFrame = (1 << 1),
    };
};


// Forward declarations.
//////////////////////////////////////////////////////////////////////
typedef void* WIN_HWND;
typedef void* WIN_HINSTANCE;
typedef void* WIN_HDC;
typedef void* WIN_HGLRC;

class CREMesh;
class CMesh;
//class   CImage;
struct  CStatObj;
class CVegetation;
struct  ShadowMapFrustum;
struct  IStatObj;
class CObjManager;
struct  SPrimitiveGroup;
struct  ICharacterInstance;
class CRendElementBase;
class CRenderObject;
class CTexMan;
//class   ColorF;
class CShadowVolEdge;
class CCamera;
class CDLight;
struct SDeferredLightVolume;
struct  ILog;
struct  IConsole;
struct  ICVar;
struct  ITimer;
struct  ISystem;
class IGPUParticleEngine;
class ICrySizer;
struct IRenderAuxGeom;
struct SREPointSpriteCreateParams;
struct SPointSpriteVertex;
struct RenderLMData;
struct SShaderParam;
struct SSkyLightRenderParams;
struct SParticleRenderInfo;
struct SParticleAddJobCompare;
struct IColorGradingController;
class IStereoRenderer;
struct IFFont;
struct IFFont_RenderProxy;
struct STextDrawContext;
struct IRenderMesh;
class IOpticsManager;
struct ShadowFrustumMGPUCache;
struct IAsyncTextureCompileListener;
struct IClipVolume;
struct SClipVolumeBlendInfo;
class IImageFile;
class CRenderView;
struct SDynTexture2;
class CTexture;

//////////////////////////////////////////////////////////////////////
typedef unsigned char bvec4[4];
typedef float vec4_t[4];
typedef unsigned char byte;
typedef float vec2_t[2];

//DOC-IGNORE-BEGIN
#include "Cry_Color.h"
#include "Tarray.h"

#include <IFont.h>
//DOC-IGNORE-END

#define MAX_NUM_VIEWPORTS 7

// Query types for CryInd editor (used in EF_Query() function).
enum ERenderQueryTypes
{
    EFQ_DeleteMemoryArrayPtr = 1,
    EFQ_DeleteMemoryPtr,
    EFQ_GetShaderCombinations,
    EFQ_SetShaderCombinations,
    EFQ_CloseShaderCombinations,

    EFQ_MainThreadList,
    EFQ_RenderThreadList,
    EFQ_RenderMultithreaded,

    EFQ_RecurseLevel,
    EFQ_IncrementFrameID,
    EFQ_DeviceLost,
    EFQ_LightSource,

    EFQ_Alloc_APITextures,
    EFQ_Alloc_APIMesh,

    // Memory allocated by meshes in system memory.
    EFQ_Alloc_Mesh_SysMem,
    EFQ_Mesh_Count,

    EFQ_HDRModeEnabled,
    EFQ_ParticlesTessellation,
    EFQ_WaterTessellation,
    EFQ_MeshTessellation,
    EFQ_GetShadowPoolFrustumsNum,
    EFQ_GetShadowPoolAllocThisFrameNum,
    EFQ_GetShadowMaskChannelsNum,
    EFQ_GetTiledShadingSkippedLightsNum,

    // Description:
    //      Query will return all textures in the renderer,
    //      pass pointer to an SRendererQueryGetAllTexturesParam instance
    EFQ_GetAllTextures,

    // Description:
    //      Release resources allocated by GetAllTextures query
    //      pass pointer to an SRendererQueryGetAllTexturesParam instance, populated by EFQ_GetAllTextures
    EFQ_GetAllTexturesRelease,

    // Description:
    //      Query will return all IRenderMesh objects in the renderer,
    //      Pass an array pointer to be allocated and filled with the IRendermesh pointers. The calling function is responsible for freeing this memory.
    //      This was originally a two pass process, but proved to be non-thread-safe, leading to buffer overruns and underruns.
    EFQ_GetAllMeshes,

    // Summary:
    //      Multigpu (crossfire/sli) is enabled.
    EFQ_MultiGPUEnabled,
    EFQ_SetDrawNearFov,
    EFQ_GetDrawNearFov,
    EFQ_TextureStreamingEnabled,
    EFQ_MSAAEnabled,
    EFQ_AAMode,

    EFQ_Fullscreen,
    EFQ_GetTexStreamingInfo,
    EFQ_GetMeshPoolInfo,

    // Description:
    //      True when shading is done in linear space, de-gamma on texture lookup, gamma on frame buffer writing (sRGB), false otherwise.
    EFQ_sLinearSpaceShadingEnabled,

    // The percentages of overscan borders for left/right and top/bottom to adjust the title safe area.
    EFQ_OverscanBorders,

    // Get num active post effects
    EFQ_NumActivePostEffects,

    // Get size of textures memory pool
    EFQ_TexturesPoolSize,
    EFQ_RenderTargetPoolSize,

    EFQ_GetShaderCacheInfo,

    EFQ_GetFogCullDistance,
    EFQ_GetMaxRenderObjectsNum,

    EFQ_IsRenderLoadingThreadActive,

    EFQ_GetParticleVertexBufferSize,
    EFQ_GetParticleIndexBufferSize,
    EFQ_GetMaxParticleContainer,
    EFQ_GetSkinningDataPoolSize,

    EFQ_GetViewportDownscaleFactor,
    EFQ_ReverseDepthEnabled,

    EFQ_GetLastD3DDebugMessage
};

struct ID3DDebugMessage
{
public:
    virtual void Release() = 0;
    virtual const char* GetMessage() const = 0;

protected:
    ID3DDebugMessage() {}
    virtual ~ID3DDebugMessage() {}
};

enum EScreenAspectRatio
{
    eAspect_Unknown,
    eAspect_4_3,
    eAspect_16_9,
    eAspect_16_10,
};

class SBoundingVolume
{
public:
    SBoundingVolume()
        : m_vCenter(0, 0, 0)
        , m_fRadius(0) {}
    ~SBoundingVolume() {}

    void SetCenter(const Vec3& center)  { m_vCenter = center; }
    void SetRadius(float radius)        { m_fRadius = radius; }
    const Vec3& GetCenter() const       { return m_vCenter;   }
    float GetRadius() const             { return m_fRadius;   }

protected:
    Vec3    m_vCenter;
    float   m_fRadius;
};

class SMinMaxBox
    : public SBoundingVolume
{
public:
    SMinMaxBox()
    {
        Clear();
    }
    SMinMaxBox(const Vec3& min, const Vec3& max) :
        m_min(min), 
        m_max(max)
    {
        UpdateSphere();
    }

    // Summary:
    //  Destructor
    virtual ~SMinMaxBox() {}

    void  AddPoint(const Vec3& pt)
    {
        if (pt.x > m_max.x)
        {
            m_max.x = pt.x;
        }
        if (pt.x < m_min.x)
        {
            m_min.x = pt.x;
        }

        if (pt.y > m_max.y)
        {
            m_max.y = pt.y;
        }
        if (pt.y < m_min.y)
        {
            m_min.y = pt.y;
        }

        if (pt.z > m_max.z)
        {
            m_max.z = pt.z;
        }
        if (pt.z < m_min.z)
        {
            m_min.z = pt.z;
        }

        // Summary:
        //   Updates the center and radius.
        UpdateSphere();
    }
    void  AddPoint(float x, float y, float z)
    {
        AddPoint(Vec3(x, y, z));
    }

    void  Union(const SMinMaxBox& box)  { AddPoint(box.GetMin()); AddPoint(box.GetMax()); }

    const Vec3& GetMin() const     { return m_min; }
    const Vec3& GetMax() const     { return m_max; }

    void  SetMin(const Vec3& min)  { m_min = min; UpdateSphere(); }
    void  SetMax(const Vec3& max)  { m_max = max; UpdateSphere(); }

    float GetWidthInX() const       { return m_max.x - m_min.x; }
    float GetWidthInY() const       { return m_max.y - m_min.y; }
    float GetWidthInZ() const       { return m_max.z - m_min.z; }

    bool  PointInBBox(const Vec3& pt) const;

    bool  ViewFrustumCull(const CameraViewParameters& viewParameters, const Matrix44& mat);

    void  Transform(const Matrix34& mat)
    {
        Vec3 verts[8];
        CalcVerts(verts);
        Clear();
        for (int i = 0; i < 8; i++)
        {
            AddPoint(mat.TransformPoint(verts[i]));
        }
    }

    // Summary:
    //  Resets the bounding box.
    void  Clear()
    {
        m_min = Vec3(999999.0f, 999999.0f, 999999.0f);
        m_max = Vec3(-999999.0f, -999999.0f, -999999.0f);
    }

protected:
    void UpdateSphere()
    {
        m_vCenter =  m_min;
        m_vCenter += m_max;
        m_vCenter *= 0.5f;

        Vec3 rad  =  m_max;
        rad      -= m_vCenter;
        m_fRadius =  rad.len();
    }
    void CalcVerts(Vec3 pVerts[8]) const
    {
        pVerts[0].Set(m_max.x, m_max.y, m_max.z);
        pVerts[4].Set(m_max.x, m_max.y, m_min.z);
        pVerts[1].Set(m_min.x, m_max.y, m_max.z);
        pVerts[5].Set(m_min.x, m_max.y, m_min.z);
        pVerts[2].Set(m_min.x, m_min.y, m_max.z);
        pVerts[6].Set(m_min.x, m_min.y, m_min.z);
        pVerts[3].Set(m_max.x, m_min.y, m_max.z);
        pVerts[7].Set(m_max.x, m_min.y, m_min.z);
    }

private:
    Vec3 m_min; // Original object space BV.
    Vec3 m_max;
};



//////////////////////////////////////////////////////////////////////
// All possible primitive types

enum PublicRenderPrimitiveType
{
    prtTriangleList,
    prtTriangleStrip,
    prtLineList,
    prtLineStrip
};

//////////////////////////////////////////////////////////////////////
#define R_CULL_DISABLE  0
#define R_CULL_NONE     0
#define R_CULL_FRONT    1
#define R_CULL_BACK     2

//////////////////////////////////////////////////////////////////////
#define R_DEFAULT_LODBIAS 0

//////////////////////////////////////////////////////////////////////
#define R_SOLID_MODE    0
#define R_WIREFRAME_MODE 1

#define R_DX9_RENDERER  2
#define R_DX11_RENDERER 3
#define R_NULL_RENDERER 4
#define R_CUBAGL_RENDERER 5
#define R_GL_RENDERER 6
#define R_METAL_RENDERER 7
#define R_DX12_RENDERER 8

//////////////////////////////////////////////////////////////////////
// Render features

#define RFT_FREE_0x1          0x1
#define RFT_ALLOW_RECTTEX     0x2
#define RFT_OCCLUSIONQUERY    0x4
#define RFT_FREE_0x8          0x8
#define RFT_HWGAMMA           0x10
#define RFT_FREE_0x20         0x20
#define RFT_COMPRESSTEXTURE   0x40
#define RFT_FREE_0x80         0x80
#define RFT_ALLOWANISOTROPIC  0x100      // Allows anisotropic texture filtering.
#define RFT_SUPPORTZBIAS      0x200
#define RFT_FREE_0x400        0x400
#define RFT_FREE_0x800        0x800
#define RFT_FREE_0x1000       0x1000
#define RFT_FREE_0x2000       0x2000
#define RFT_OCCLUSIONTEST     0x8000     // Support hardware occlusion test.


#define RFT_HW_ARM_MALI       0x04000    // Unclassified ARM (MALI) hardware.
#define RFT_HW_INTEL          0x10000    // Unclassified intel hardware.
#define RFT_HW_QUALCOMM       0x10000    // Unclassified Qualcomm hardware
#define RFT_HW_ATI            0x20000    // Unclassified ATI hardware.
#define RFT_HW_NVIDIA         0x40000    // Unclassified NVidia hardware.

#define RFT_HW_MASK           0x74000    // Graphics chip mask.

#define RFT_HW_HDR            0x80000    // Hardware supports high dynamic range rendering.

#define RFT_HW_SM20           0x100000   // Shader model 2.0
#define RFT_HW_SM2X           0x200000   // Shader model 2.X
#define RFT_HW_SM30           0x400000   // Shader model 3.0
#define RFT_HW_SM40           0x800000   // Shader model 4.0
#define RFT_HW_SM50           0x1000000  // Shader model 5.0

#define RFT_FREE_0x2000000    0x2000000
#define RFT_FREE_0x4000000    0x4000000
#define RFT_FREE_0x8000000    0x8000000

#define RFT_HW_VERTEX_STRUCTUREDBUF 0x10000000 // Supports Structured Buffers in the Vertex Shader.
#define RFT_RGBA                    0x20000000 // RGBA order (otherwise BGRA).
#define RFT_COMPUTE_SHADERS         0x40000000 // Compute Shaders support
#define RFT_HW_VERTEXTEXTURES       0x80000000 // Vertex texture fetching supported.

//====================================================================
// PrecacheResources flags

#define FPR_NEEDLIGHT     1
#define FPR_2D            2
#define FPR_HIGHPRIORITY  4
#define FPR_SYNCRONOUS    8
#define FPR_STARTLOADING    16
#define FPR_SINGLE_FRAME_PRIORITY_UPDATE 32

//=====================================================================
// SetRenderTarget flags
#define SRF_SCREENTARGET  1
#define SRF_USE_ORIG_DEPTHBUF 2
#define SRF_USE_ORIG_DEPTHBUF_MSAA 4

//====================================================================
// Draw shaders flags (EF_EndEf3d)

#define SHDF_ALLOWHDR               BIT(0)
#define SHDF_CUBEMAPGEN             BIT(1)
#define SHDF_ZPASS                  BIT(2)
#define SHDF_ZPASS_ONLY             BIT(3)
#define SHDF_DO_NOT_CLEAR_Z_BUFFER  BIT(4)
#define SHDF_ALLOWPOSTPROCESS       BIT(5)
#define SHDF_ALLOW_AO               BIT(8)
#define SHDF_ALLOW_WATER            BIT(9)
#define SHDF_NOASYNC                BIT(10)
#define SHDF_NO_DRAWNEAR            BIT(11)
#define SHDF_STREAM_SYNC            BIT(13)
#define SHDF_NO_SHADOWGEN           BIT(15)

//////////////////////////////////////////////////////////////////////
// Virtual screen size
const float VIRTUAL_SCREEN_WIDTH = 800.0f;
const float VIRTUAL_SCREEN_HEIGHT = 600.0f;

//////////////////////////////////////////////////////////////////////
// Object states
#define OS_ALPHA_BLEND             0x1
#define OS_ADD_BLEND               0x2
#define OS_MULTIPLY_BLEND          0x4
#define OS_TRANSPARENT            (OS_ALPHA_BLEND | OS_ADD_BLEND | OS_MULTIPLY_BLEND)
#define OS_NODEPTH_TEST            0x8
#define OS_NODEPTH_WRITE           0x10
#define OS_ANIM_BLEND              0x20
#define OS_ENVIRONMENT_CUBEMAP     0x40

// Render State flags
#define GS_BLSRC_MASK              0xf
#define GS_BLSRC_ZERO              0x1
#define GS_BLSRC_ONE               0x2
#define GS_BLSRC_DSTCOL            0x3
#define GS_BLSRC_ONEMINUSDSTCOL    0x4
#define GS_BLSRC_SRCALPHA          0x5
#define GS_BLSRC_ONEMINUSSRCALPHA  0x6
#define GS_BLSRC_DSTALPHA          0x7
#define GS_BLSRC_ONEMINUSDSTALPHA  0x8
#define GS_BLSRC_ALPHASATURATE     0x9
#define GS_BLSRC_SRCALPHA_A_ZERO   0xa // separate alpha blend state
#define GS_BLSRC_SRC1ALPHA         0xb // dual source blending


#define GS_BLDST_MASK              0xf0
#define GS_BLDST_ZERO              0x10
#define GS_BLDST_ONE               0x20
#define GS_BLDST_SRCCOL            0x30
#define GS_BLDST_ONEMINUSSRCCOL    0x40
#define GS_BLDST_SRCALPHA          0x50
#define GS_BLDST_ONEMINUSSRCALPHA  0x60
#define GS_BLDST_DSTALPHA          0x70
#define GS_BLDST_ONEMINUSDSTALPHA  0x80
#define GS_BLDST_ONE_A_ZERO        0x90 // separate alpha blend state
#define GS_BLDST_ONEMINUSSRC1ALPHA 0xa0 // dual source blending


#define GS_DEPTHWRITE              0x00000100

#define GS_COLMASK_RT1             0x00000200
#define GS_COLMASK_RT2             0x00000400
#define GS_COLMASK_RT3             0x00000800

#define GS_NOCOLMASK_R             0x00001000
#define GS_NOCOLMASK_G             0x00002000
#define GS_NOCOLMASK_B             0x00004000
#define GS_NOCOLMASK_A             0x00008000
#define GS_COLMASK_RGB             (GS_NOCOLMASK_A)
#define GS_COLMASK_A               (GS_NOCOLMASK_R | GS_NOCOLMASK_G | GS_NOCOLMASK_B)
#define GS_COLMASK_NONE            (GS_NOCOLMASK_R | GS_NOCOLMASK_G | GS_NOCOLMASK_B | GS_NOCOLMASK_A)
#define GS_COLMASK_MASK            GS_COLMASK_NONE
#define GS_COLMASK_SHIFT           12

#define GS_WIREFRAME               0x00010000
#define GS_NODEPTHTEST             0x00040000

#define GS_BLEND_MASK              0x0f0000ff

#define GS_DEPTHFUNC_LEQUAL        0x00000000
#define GS_DEPTHFUNC_EQUAL         0x00100000
#define GS_DEPTHFUNC_GREAT         0x00200000
#define GS_DEPTHFUNC_LESS          0x00300000
#define GS_DEPTHFUNC_GEQUAL        0x00400000
#define GS_DEPTHFUNC_NOTEQUAL      0x00500000
#define GS_DEPTHFUNC_HIZEQUAL      0x00600000 // keep hi-z test, always pass fine depth. Useful for debug display
#define GS_DEPTHFUNC_ALWAYS        0x00700000
#define GS_DEPTHFUNC_MASK          0x00700000

#define GS_STENCIL                 0x00800000

#define GS_BLEND_OP_MASK           0x03000000
#define GS_BLOP_MAX                              0x01000000
#define GS_BLOP_MIN                              0x02000000

// Separate alpha blend mode
#define GS_BLALPHA_MASK            0x0c000000
#define GS_BLALPHA_MIN             0x04000000
#define GS_BLALPHA_MAX             0x08000000

#define GS_ALPHATEST_MASK          0xf0000000
#define GS_ALPHATEST_GREATER       0x10000000
#define GS_ALPHATEST_LESS          0x20000000
#define GS_ALPHATEST_GEQUAL        0x40000000
#define GS_ALPHATEST_LEQUAL        0x80000000

#define FORMAT_8_BIT   8
#define FORMAT_24_BIT 24
#define FORMAT_32_BIT 32

//==================================================================
// StencilStates

//Note: If these are altered, g_StencilFuncLookup and g_StencilOpLookup arrays
//          need to be updated in turn

#define FSS_STENCFUNC_ALWAYS   0x0
#define FSS_STENCFUNC_NEVER    0x1
#define FSS_STENCFUNC_LESS     0x2
#define FSS_STENCFUNC_LEQUAL   0x3
#define FSS_STENCFUNC_GREATER  0x4
#define FSS_STENCFUNC_GEQUAL   0x5
#define FSS_STENCFUNC_EQUAL    0x6
#define FSS_STENCFUNC_NOTEQUAL 0x7
#define FSS_STENCFUNC_MASK     0x7

#define FSS_STENCIL_TWOSIDED   0x8

#define FSS_CCW_SHIFT          16

#define FSS_STENCOP_KEEP    0x0
#define FSS_STENCOP_REPLACE 0x1
#define FSS_STENCOP_INCR    0x2
#define FSS_STENCOP_DECR    0x3
#define FSS_STENCOP_ZERO    0x4
#define FSS_STENCOP_INCR_WRAP 0x5
#define FSS_STENCOP_DECR_WRAP 0x6
#define FSS_STENCOP_INVERT 0x7

#define FSS_STENCFAIL_SHIFT   4
#define FSS_STENCFAIL_MASK    (0x7 << FSS_STENCFAIL_SHIFT)

#define FSS_STENCZFAIL_SHIFT  8
#define FSS_STENCZFAIL_MASK   (0x7 << FSS_STENCZFAIL_SHIFT)

#define FSS_STENCPASS_SHIFT   12
#define FSS_STENCPASS_MASK    (0x7 << FSS_STENCPASS_SHIFT)

#define STENC_FUNC(op) (op)
#define STENC_CCW_FUNC(op) (op << FSS_CCW_SHIFT)
#define STENCOP_FAIL(op) (op << FSS_STENCFAIL_SHIFT)
#define STENCOP_ZFAIL(op) (op << FSS_STENCZFAIL_SHIFT)
#define STENCOP_PASS(op) (op << FSS_STENCPASS_SHIFT)
#define STENCOP_CCW_FAIL(op) (op << (FSS_STENCFAIL_SHIFT + FSS_CCW_SHIFT))
#define STENCOP_CCW_ZFAIL(op) (op << (FSS_STENCZFAIL_SHIFT + FSS_CCW_SHIFT))
#define STENCOP_CCW_PASS(op) (op << (FSS_STENCPASS_SHIFT + FSS_CCW_SHIFT))

//Stencil masks
#define BIT_STENCIL_RESERVED 0x80
#define BIT_STENCIL_INSIDE_CLIPVOLUME 0x40
#define STENC_VALID_BITS_NUM 7
#define STENC_MAX_REF ((1 << STENC_VALID_BITS_NUM) - 1)

// Read FrameBuffer type
enum ERB_Type
{
    eRB_BackBuffer,
    eRB_FrontBuffer,
    eRB_ShadowBuffer
};

enum EVertexCostTypes
{
    EVCT_STATIC = 0,
    EVCT_VEGETATION,
    EVCT_SKINNED,
    EVCT_NUM
};

//////////////////////////////////////////////////////////////////////

struct SDispFormat
{
    int m_Width;
    int m_Height;
    int m_BPP;
};

struct SAAFormat
{
    char szDescr[64];
    int nSamples;
    int nQuality;
};

// Summary:
//   Info about Terrain sector texturing.
struct SSectorTextureSet
{
    SSectorTextureSet(unsigned short nT0)
    {
        nTex0 = nT0;
        fTexOffsetX = fTexOffsetY = 0;
        fTexScale = 1.f;
    }

    unsigned short nTex0;
    float fTexOffsetX, fTexOffsetY, fTexScale;
};

struct IRenderNode;
struct SShaderItem;
struct IParticleVertexCreator;

struct SAddParticlesToSceneJob
{
    void GetMemoryUsage(ICrySizer* pSizer) const {}

    SShaderItem* pShaderItem;
    CRenderObject* pRenderObject;
    IParticleVertexCreator* pPVC;
    int16 nCustomTexId;
}
_ALIGN(16)
;

#ifdef SUPPORT_HW_MOUSE_CURSOR
class IHWMouseCursor
{
public:
    virtual ~IHWMouseCursor() {}
    virtual void SetPosition(int x, int y) = 0;
    virtual void Show() = 0;
    virtual void Hide() = 0;
};
#endif

//////////////////////////////////////////////////////////////////////
//DOC-IGNORE-BEGIN
#include <IShader.h> // <> required for Interfuscator
//DOC-IGNORE-END
#include <IRenderMesh.h>
#include "IMeshBaking.h"

// Flags passed in function FreeResources.
#define FRR_SHADERS   1
#define FRR_SHADERTEXTURES 2
#define FRR_TEXTURES  4
#define FRR_SYSTEM    8
#define FRR_RESTORE   0x10
#define FRR_REINITHW  0x20
#define FRR_DELETED_MESHES 0x40
#define FRR_FLUSH_TEXTURESTREAMING 0x80
#define FRR_OBJECTS     0x100
#define FRR_RENDERELEMENTS 0x200
#define FRR_RP_BUFFERS 0x400
#define FRR_SYSTEM_RESOURCES 0x800
#define FRR_POST_EFFECTS 0x1000
#define FRR_ALL      -1

// Refresh render resources flags.
// Flags passed in function RefreshResources.
#define FRO_SHADERS  1
#define FRO_SHADERTEXTURES  2
#define FRO_TEXTURES 4
#define FRO_GEOMETRY 8
#define FRO_FORCERELOAD 0x10

//=============================================================================
// Shaders render target stuff.

#define FRT_CLEAR_DEPTH   0x1
#define FRT_CLEAR_STENCIL 0x2
#define FRT_CLEAR_COLOR   0x4
#define FRT_CLEAR (FRT_CLEAR_COLOR | FRT_CLEAR_DEPTH | FRT_CLEAR_STENCIL)
#define FRT_CLEAR_FOGCOLOR 0x8
#define FRT_CLEAR_IMMEDIATE 0x10
#define FRT_CLEAR_COLORMASK 0x20
#define FRT_CLEAR_RESET_VIEWPORT 0x40

#define FRT_CAMERA_REFLECTED_WATERPLANE 0x40
#define FRT_CAMERA_REFLECTED_PLANE      0x80
#define FRT_CAMERA_CURRENT              0x100

#define FRT_USE_FRONTCLIPPLANE          0x200
#define FRT_USE_BACKCLIPPLANE           0x400

#define FRT_GENERATE_MIPS               0x800

#define FRT_RENDTYPE_CUROBJECT          0x1000
#define FRT_RENDTYPE_CURSCENE           0x2000
#define FRT_RENDTYPE_RECURSIVECURSCENE  0x4000
#define FRT_RENDTYPE_COPYSCENE          0x8000

// Summary:
//   Flags used in DrawText function.
// See also:
//   SDrawTextInfo
// Remarks:
//   Text must be fixed pixel size.
enum EDrawTextFlags
{
    eDrawText_Left          = 0,        // default left alignment if neither Center or Right are specified
    eDrawText_Center        = BIT(0),   // centered alignment, otherwise right or left
    eDrawText_Right         = BIT(1),   // right alignment, otherwise center or left
    eDrawText_CenterV       = BIT(2),   // center vertically, otherwise top
    eDrawText_Bottom        = BIT(3),   // bottom alignment

    eDrawText_2D            = BIT(4),   // 3 component vector is used for xy screen position, otherwise it's 3d world space position

    eDrawText_FixedSize     = BIT(5),   // font size is defined in the actual pixel resolution, otherwise it's in the virtual 800x600
    eDrawText_800x600       = BIT(6),   // position are specified in the virtual 800x600 resolution, otherwise coordinates are in pixels

    eDrawText_Monospace     = BIT(7),   // non proportional font rendering (Font width is same for all characters)

    eDrawText_Framed        = BIT(8),   // draw a transparent, rectangular frame behind the text to ease readability independent from the background

    eDrawText_DepthTest     = BIT(9),   // text should be occluded by world geometry using the depth buffer
    eDrawText_IgnoreOverscan = BIT(10),  // ignore the overscan borders, text should be drawn at the location specified
    eDrawText_UseTransform  = BIT(11),  // use a transform for the text
};

// Debug stats/views for Partial resolves
// if REFRACTION_PARTIAL_RESOLVE_DEBUG_VIEWS is enabled, make sure REFRACTION_PARTIAL_RESOLVE_STATS is too
#if defined(PERFORMANCE_BUILD)
    #define REFRACTION_PARTIAL_RESOLVE_STATS 1
    #define REFRACTION_PARTIAL_RESOLVE_DEBUG_VIEWS 0
#elif defined(_RELEASE) // note: _RELEASE is defined in PERFORMANCE_BUILD, so this check must come second
    #define REFRACTION_PARTIAL_RESOLVE_STATS 0
    #define REFRACTION_PARTIAL_RESOLVE_DEBUG_VIEWS 0
#else
    #define REFRACTION_PARTIAL_RESOLVE_STATS 1
    #define REFRACTION_PARTIAL_RESOLVE_DEBUG_VIEWS 1
#endif

#if REFRACTION_PARTIAL_RESOLVE_DEBUG_VIEWS
enum ERefractionPartialResolvesDebugViews
{
    eRPR_DEBUG_VIEW_2D_AREA = 1,
    eRPR_DEBUG_VIEW_3D_BOUNDS,
    eRPR_DEBUG_VIEW_2D_AREA_OVERLAY
};
#endif

//////////////////////////////////////////////////////////////////////////
// Description:
//   This structure used in DrawText method of renderer.
//   It provide all necessary information of how to render text on screen.
// See also:
//   IRenderer::Draw2dText
struct SDrawTextInfo
{
    // Summary:
    //  One of EDrawTextFlags flags.
    // See also:
    //  EDrawTextFlags
    int     flags;
    // Summary:
    //  Text color, (r,g,b,a) all members must be specified.
    float   color[4];
    float xscale;
    float yscale;

    SDrawTextInfo()
    {
        flags = 0;
        color[0] = color[1] = color[2] = color[3] = 1;
        xscale = 1.0f;
        yscale = 1.0f;
    }
};

#define UIDRAW_TEXTSIZEFACTOR (12.0f)
#define MIN_RESOLUTION_SCALE (0.25f)
#define MAX_RESOLUTION_SCALE (4.0f)

#if defined(AZ_RESTRICTED_PLATFORM)
    #include AZ_RESTRICTED_FILE(IRenderer_h, AZ_RESTRICTED_PLATFORM)
#else
//SLI/CROSSFIRE GPU maximum count
    #define MAX_GPU_NUM 4
#endif

#define MAX_FRAME_ID_STEP_PER_FRAME 20
const int MAX_GSM_LODS_NUM = 16;

const f32 DRAW_NEAREST_MIN = 0.03f;
const f32 DRAW_NEAREST_MAX = 40.0f;

//===================================================================

//////////////////////////////////////////////////////////////////////
struct IRenderDebugListener
{
    virtual ~IRenderDebugListener() {}

    virtual void OnDebugDraw() = 0;
};

//////////////////////////////////////////////////////////////////////
struct ILoadtimeCallback
{
    virtual void LoadtimeUpdate(float fDeltaTime) = 0;
    virtual void LoadtimeRender() = 0;
    virtual ~ILoadtimeCallback(){}
};

//////////////////////////////////////////////////////////////////////
struct ISyncMainWithRenderListener
{
    virtual void SyncMainWithRender() = 0;
    virtual ~ISyncMainWithRenderListener(){}
};

//////////////////////////////////////////////////////////////////////
enum ERenderType
{
    eRT_Undefined,
    eRT_Null,
    eRT_DX11,
    eRT_DX12,
    eRT_XboxOne, // ACCEPTED_USE
    eRT_PS4, // ACCEPTED_USE
    eRT_OpenGL,
    eRT_Metal,
};

//////////////////////////////////////////////////////////////////////
// Enum for types of deferred lights
enum eDeferredLightType
{
    eDLT_DeferredLight = 0,

    eDLT_NumShadowCastingLights = eDLT_DeferredLight + 1,
    // these lights cannot cast shadows
    eDLT_DeferredCubemap = eDLT_NumShadowCastingLights,
    eDLT_DeferredAmbientLight,
    eDLT_NumLightTypes,
};

const float RENDERER_LIGHT_UNIT_SCALE = 10000.0f;  // Scale factor between photometric and internal light units

//////////////////////////////////////////////////////////////////////
struct SCustomRenderInitArgs
{
    bool appStartedFromMediaCenter;
};

#if defined(ANDROID)
enum
{
    CULL_SIZEX = 128
};
enum
{
    CULL_SIZEY = 64
};
#else
enum
{
    CULL_SIZEX = 256
};
enum
{
    CULL_SIZEY = 128
};
#endif

//////////////////////////////////////////////////////////////////////
// Description:
//   Z-buffer as occlusion buffer definitions: used, shared and initialized in engine and renderer.
struct SHWOccZBuffer
{
    uint32* pHardwareZBuffer;
    uint32* pZBufferVMem;
    uint32 ZBufferSizeX;
    uint32 ZBufferSizeY;
    uint32 HardwareZBufferRSXOff;
    uint32 ZBufferVMemRSXOff;
    uint32 pad[2];  // Keep 32 byte aligned
    SHWOccZBuffer()
        : pHardwareZBuffer(NULL)
        , pZBufferVMem(NULL)
        , ZBufferSizeX(CULL_SIZEX)
        , ZBufferSizeY(CULL_SIZEY)
        , ZBufferVMemRSXOff(0)
        , HardwareZBufferRSXOff(0){}
};

class ITextureStreamListener
{
public:
    virtual void OnCreatedStreamedTexture(void* pHandle, const char* name, int nMips, int nMinMipAvailable) = 0;
    virtual void OnDestroyedStreamedTexture(void* pHandle) = 0;
    virtual void OnTextureWantsMip(void* pHandle, int nMinMip) = 0;
    virtual void OnTextureHasMip(void* pHandle, int nMinMip) = 0;
    virtual void OnBegunUsingTextures(void** pHandles, size_t numHandles) = 0;
    virtual void OnEndedUsingTextures(void** pHandle, size_t numHandles) = 0;

protected:
    virtual ~ITextureStreamListener() {}
};

#if defined(CRY_ENABLE_RC_HELPER)
////////////////////////////////////////////////////////////////////////////
// Listener for asynchronous texture compilation.
// Connects the listener to the task-queue of pending compilation requests.
enum ERcExitCode;
struct IAsyncTextureCompileListener
{
public:
    virtual void OnCompilationStarted(const char* source, const char* target, int nPending) = 0;
    virtual void OnCompilationFinished(const char* source, const char* target, IResourceCompilerHelper::ERcCallResult nReturnCode) = 0;

    virtual void OnCompilationQueueTriggered(int nPending) = 0;
    virtual void OnCompilationQueueDepleted() = 0;

protected:
    virtual ~IAsyncTextureCompileListener() {}
};
#endif

enum eDolbyVisionMode
{
    eDVM_Disabled,
    eDVM_RGBPQ,
    eDVM_Vision,
};

enum ERenderPipelineProfilerStats
{
    eRPPSTATS_OverallFrame = 0,
    eRPPSTATS_Recursion,

    // Scene
    eRPPSTATS_SceneOverall,
    eRPPSTATS_SceneDecals,
    eRPPSTATS_SceneForward,
    eRPPSTATS_SceneWater,

    // Shadows
    eRPPSTATS_ShadowsOverall,
    eRPPSTATS_ShadowsSun,
    eRPPSTATS_ShadowsSunCustom,
    eRPPSTATS_ShadowsLocal,

    // Lighting
    eRPPSTATS_LightingOverall,
    eRPPSTATS_LightingGI,

    // VFX
    eRPPSTATS_VfxOverall,
    eRPPSTATS_VfxTransparent,
    eRPPSTATS_VfxFog,
    eRPPSTATS_VfxFlares,

    // Individual Total Illumination stats
    eRPPSTATS_TI_INJECT_CLEAR,
    eRPPSTATS_TI_VOXELIZE,
    eRPPSTATS_TI_INJECT_AIR,
    eRPPSTATS_TI_INJECT_LIGHT,
    eRPPSTATS_TI_INJECT_REFL0,
    eRPPSTATS_TI_INJECT_REFL1,
    eRPPSTATS_TI_INJECT_DYNL,
    eRPPSTATS_TI_NID_DIFF,
    eRPPSTATS_TI_GEN_DIFF,
    eRPPSTATS_TI_GEN_SPEC,
    eRPPSTATS_TI_GEN_AIR,
    eRPPSTATS_TI_DEMOSAIC_DIFF,
    eRPPSTATS_TI_DEMOSAIC_SPEC,
    eRPPSTATS_TI_UPSCALE_DIFF,
    eRPPSTATS_TI_UPSCALE_SPEC,

    RPPSTATS_NUM
};

struct RPProfilerStats
{
    float   gpuTime;
    float   gpuTimeSmoothed;
    float   gpuTimeMax;
    float   cpuTime;
    uint32  numDIPs;
    uint32  numPolys;

    // Internal
    float   _gpuTimeMaxNew;
};

struct TransformationMatrices
{
    Matrix44A m_viewMatrix;
    Matrix44A m_projectMatrix;
};

struct ISvoRenderer
{
    virtual bool IsShaderItemUsedForVoxelization(SShaderItem& rShaderItem, IRenderNode* pRN){ return false; }
    virtual void SetEditingHelper(const Sphere& sp){}
    virtual void Release(){}
};

//////////////////////////////////////////////////////////////////////
struct SRenderPipeline;
struct SRenderThread;
struct SShaderTechnique;
struct SShaderPass;
struct SDepthTexture;
struct SRenderTileInfo;

class CShaderMan;
class CDeviceBufferManager;
class CShaderResources;
class PerInstanceConstantBufferPool;

namespace AZ {
    class Plane;
    namespace Vertex {
        class Format;
    }
}
enum eRenderPrimitiveType : int8;
enum RenderIndexType : int;

struct IRenderAPI
{
};

struct IRenderer
    : public IRenderAPI
{
    virtual ~IRenderer(){}

    virtual void AddRenderDebugListener(IRenderDebugListener* pRenderDebugListener) = 0;
    virtual void RemoveRenderDebugListener(IRenderDebugListener* pRenderDebugListener) = 0;

    virtual ERenderType GetRenderType() const = 0;

    // Summary:
    //  Initializes the renderer, params are self-explanatory.
    virtual WIN_HWND Init(int x, int y, int width, int height, unsigned int cbpp, int zbpp, int sbits, bool fullscreen, bool isEditor, WIN_HINSTANCE hinst, WIN_HWND Glhwnd = 0, bool bReInit = false, const SCustomRenderInitArgs* pCustomArgs = 0, bool bShaderCacheGen = false) = 0;
    virtual void PostInit() = 0;

    virtual bool IsPost3DRendererEnabled() const { return false; }

    virtual int GetFeatures() = 0;
    virtual void GetVideoMemoryUsageStats(size_t& vidMemUsedThisFrame, size_t& vidMemUsedRecently, bool bGetPoolsSizes = false) = 0;
    virtual int GetNumGeomInstances() = 0;
    virtual int GetNumGeomInstanceDrawCalls() = 0;
    virtual int GetCurrentNumberOfDrawCalls() = 0;
    virtual void GetCurrentNumberOfDrawCalls(int& nGeneral, int& nShadowGen) = 0;
    //Sums DIP counts for the EFSLIST_* passes that match the submitted mask.
    //Compose the mask with bitwise arithmetic, use (1 << EFSLIST_*) per list.
    //e.g. to sum general and transparent, pass in ( (1 << EFSLIST_GENERAL) | (1 << EFSLIST_TRANSP) )
    virtual int GetCurrentNumberOfDrawCalls(const uint32 EFSListMask) = 0;
    virtual float GetCurrentDrawCallRTTimes(const uint32 EFSListMask) = 0;

    virtual void SetDebugRenderNode(IRenderNode* pRenderNode) = 0;
    virtual bool IsDebugRenderNode(IRenderNode* pRenderNode) const = 0;

    /////////////////////////////////////////////////////////////////////////////////
    // Render-context management
    /////////////////////////////////////////////////////////////////////////////////
    virtual bool DeleteContext(WIN_HWND hWnd) = 0;
    virtual bool CreateContext(WIN_HWND hWnd, bool bAllowMSAA = false, int SSX = 1, int SSY = 1) = 0;
    virtual bool SetCurrentContext(WIN_HWND hWnd) = 0;
    virtual void MakeMainContextActive() = 0;
    virtual WIN_HWND GetCurrentContextHWND() = 0;
    virtual bool IsCurrentContextMainVP() = 0;

    // Summary:
    //  Gets height of the current viewport.
    virtual int   GetCurrentContextViewportHeight() const = 0;

    // Summary:
    //  Gets width of the current viewport.
    virtual int   GetCurrentContextViewportWidth() const = 0;
    /////////////////////////////////////////////////////////////////////////////////

    // Summary:
    //  Shuts down the renderer.
    virtual void  ShutDown(bool bReInit = false) = 0;
    virtual void  ShutDownFast() = 0;

    // Description:
    //  Creates array of all supported video formats (except low resolution formats).
    // Return value:
    //  Number of formats in memory.
    virtual int EnumDisplayFormats(SDispFormat* Formats) = 0;

    // Summary:
    //  Returns all supported by video card video AA formats.
    virtual int EnumAAFormats(SAAFormat* Formats) = 0;

    // Summary:
    //  Changes resolution of the window/device (doesn't require to reload the level.
    virtual bool  ChangeResolution(int nNewWidth, int nNewHeight, int nNewColDepth, int nNewRefreshHZ, bool bFullScreen, bool bForceReset) = 0;

    // Note:
    //  Should be called at the beginning of every frame.
    virtual void  BeginFrame() = 0;

    // Summary:
    //  Creates default system shaders and textures.
    virtual void  InitSystemResources(int nFlags) = 0;
    virtual void  InitTexturesSemantics() = 0;

    // Summary:
    //  Frees the allocated resources.
    virtual void  FreeResources(int nFlags) = 0;

    // Summary:
    //  Shuts down the renderer.
    virtual void  Release() = 0;

    // See also:
    //   r_ShowDynTextures
    virtual void RenderDebug(bool bRenderStats = true) = 0;

    // Note:
    //   Should be called at the end of every frame.
    virtual void  EndFrame() = 0;

    // Force a swap on the backbuffer
    virtual void    ForceSwapBuffers() = 0;

    // Summary:
    //      Try to flush the render thread commands to keep the render thread active during
    //      level loading, but simpy return if the render thread is still busy
    virtual void TryFlush() = 0;

    virtual void GetViewport(int* x, int* y, int* width, int* height) const = 0;
    virtual void SetViewport(int x, int y, int width, int height, int id = 0) = 0;
    virtual void SetRenderTile(f32 nTilesPosX = 0.f, f32 nTilesPosY = 0.f, f32 nTilesGridSizeX = 1.f, f32 nTilesGridSizeY = 1.f) = 0;
    virtual void SetScissor(int x = 0, int y = 0, int width = 0, int height = 0) = 0;
    virtual Matrix44A& GetViewProjectionMatrix() = 0;
    virtual void SetTranspOrigCameraProjMatrix(Matrix44A& matrix) = 0;

    virtual EScreenAspectRatio GetScreenAspect(int nWidth, int nHeight) = 0;

    virtual Vec2 SetViewportDownscale(float xscale, float yscale) = 0;
    virtual void SetViewParameters(const CameraViewParameters& viewParameters) = 0; // Direct setter
    virtual void ApplyViewParameters(const CameraViewParameters& viewParameters) = 0; // Uses CameraViewParameters to create matrices.

    // Summary:
    //  Draws user primitives.
    virtual void DrawDynVB(SVF_P3F_C4B_T2F* pBuf, uint16* pInds, int nVerts, int nInds, const PublicRenderPrimitiveType nPrimType) = 0;

    // Summary:
    //  Sets the renderer camera.
    virtual void  SetCamera(const CCamera& cam) = 0;

    // Summary:
    //  Gets the renderer camera.
    virtual const CCamera& GetCamera() = 0;

    virtual CRenderView* GetRenderViewForThread(int nThreadID) = 0;

    // Summary:
    //  Sets delta gamma.
    virtual bool  SetGammaDelta(const float fGamma) = 0;

    // Summary:
    //  Restores gamma
    // Note:
    //  Reset gamma setting if not in fullscreen mode.
    virtual void  RestoreGamma(void) = 0;

    // Summary:
    //  Changes display size.
    virtual bool  ChangeDisplay(unsigned int width, unsigned int height, unsigned int cbpp) = 0;

    // Summary:
    //  Changes viewport size.
    virtual void  ChangeViewport(unsigned int x, unsigned int y, unsigned int width, unsigned int height, bool bMainViewport = false) = 0;

    // Summary:
    //  Saves source data to a Tga file.
    // Note:
    //  Should not be here.
    virtual bool  SaveTga(unsigned char* sourcedata, int sourceformat, int w, int h, const char* filename, bool flip) const = 0;

    // Summary:
    //  Sets the current binded texture.
    virtual void  SetTexture(int tnum) = 0;

    // Summary:
    //  Sets the white texture.
    virtual void  SetWhiteTexture() = 0;

    // Summary:
    //  Gets the white texture Id.
    virtual int  GetWhiteTextureId() const = 0;

    // Summary:
    //  Gets the white texture Id.
    virtual int  GetBlackTextureId() const = 0;

    // Summary:
    //  Draws a 2d image on the screen.
    // Example:
    //  Hud etc.
    virtual void  Draw2dImage(float xpos, float ypos, float w, float h, int texture_id, float s0 = 0, float t0 = 0, float s1 = 1, float t1 = 1, float angle = 0, float r = 1, float g = 1, float b = 1, float a = 1, float z = 1) = 0;

    virtual void  Draw2dImageStretchMode(bool stretch) = 0;

    // Summary:
    //  Adds a 2d image that should be drawn on the screen to an internal render list. The list can be drawn with Draw2dImageList.
    //  If several images will be drawn, using this function is more efficient than calling Draw2dImage as it allows better batching.
    //  The function supports placing images in stereo 3d space.
    // Arguments:
    //      stereoDepth - Places image in stereo 3d space. The depth is specified in camera space, the stereo params are the same that
    //                                  are used for the scene. A value of 0 is handled as a special case and always places the image on the screen plane.
    virtual void  Push2dImage(float xpos, float ypos, float w, float h, int texture_id, float s0 = 0, float t0 = 0, float s1 = 1, float t1 = 1, float angle = 0, float r = 1, float g = 1, float b = 1, float a = 1, float z = 1, float stereoDepth = 0) = 0;

    // Summary:
    //  Draws all images to the screen that were collected with Push2dImage.
    virtual void  Draw2dImageList() = 0;

    // Summary:
    //  Draws a image using the current matrix.
    virtual void DrawImage(float xpos, float ypos, float w, float h, int texture_id, float s0, float t0, float s1, float t1, float r, float g, float b, float a, bool filtered = true) = 0;

    // Description:
    //  Draws a image using the current matrix, more flexible than DrawImage
    //  order for s and t: 0=left_top, 1=right_top, 2=right_bottom, 3=left_bottom.
    virtual void DrawImageWithUV(float xpos, float ypos, float z, float width, float height, int texture_id, float* s, float* t, float r = 1, float g = 1, float b = 1, float a = 1, bool filtered = true) = 0;

    // Summary:
    //  Sets the polygon mode with Push, Pop restores the last used one
    // Example:
    //  Wireframe, solid.
    virtual void PushWireframeMode(int mode) = 0;
    virtual void PopWireframeMode() = 0;

    // Summary:
    //  Gets height of the main rendering resolution.
    virtual int   GetHeight() = 0;

    // Summary:
    //  Gets width of the main rendering resolution.
    virtual int   GetWidth() = 0;

    // Summary:
    //  Gets Pixel Aspect Ratio.
    virtual float GetPixelAspectRatio() const = 0;

    // Summary:
    //  Gets the height of the overlay viewport where UI and debug output are rendered.
    virtual int   GetOverlayHeight() = 0;

    // Summary:
    //  Gets the width of the overlay viewport where UI and debug output are rendered.
    virtual int   GetOverlayWidth() = 0;

    // Summary:
    //  Gets the maximum dimension for a square custom render resolution.
    virtual int   GetMaxSquareRasterDimension() const = 0;

    // Summary:
    //  Switches subsequent rendering from the internal backbuffer to the native resolution backbuffer if available.
    virtual void  SwitchToNativeResolutionBackbuffer() = 0;

    // Summary:
    //  Gets memory status information
    virtual void GetMemoryUsage(ICrySizer* Sizer) = 0;

    // Summary:
    //  Gets textures streaming bandwidth information
    virtual void GetBandwidthStats(float* fBandwidthRequested) = 0;

    // Summary:
    //  Sets an event listener for texture streaming updates
    virtual void SetTextureStreamListener(ITextureStreamListener* pListener) = 0;

    // Summary:
    //  Populates a CPU-side occlusion buffer with the contents from the previous frame's downsampled depth buffer.
    //  This will be called from a job thread within the occlusion system.
    virtual int GetOcclusionBuffer(uint16* pOutOcclBuffer, Matrix44* pmCamBuffer) = 0;

    // Summary:
    //   Gets a screenshot and save to a file
    // Returns:
    //   true=success
    virtual bool ScreenShot(const char* filename = NULL, int width = 0) = 0;

    // Summary:
    //  Gets current bpp.
    virtual int GetColorBpp() = 0;

    // Summary:
    //  Gets current z-buffer depth.
    virtual int GetDepthBpp() = 0;

    // Summary:
    //  Gets current stencil bits.
    virtual int GetStencilBpp() = 0;

    // Summary:
    //  Returns true if stereo rendering is enabled.
    virtual bool IsStereoEnabled() const = 0;

    // Summary:
    //  Returns values of nearest rendering z-range max
    virtual float GetNearestRangeMax() const = 0;

    // Summary:
    //  Returns the PerInstanceConstantBufferPool
    virtual PerInstanceConstantBufferPool* GetPerInstanceConstantBufferPoolPointer() = 0;

    // Summary:
    //  Projects to screen.
    //  Returns true if successful.
    virtual bool ProjectToScreen(
        float ptx, float pty, float ptz,
        float* sx, float* sy, float* sz) = 0;

    // Summary:
    //  Unprojects to screen.
    virtual int UnProject(
        float sx, float sy, float sz,
        float* px, float* py, float* pz,
        const float modelMatrix[16],
        const float projMatrix[16],
        const int    viewport[4]) = 0;

    // Summary:
    //  Unprojects from screen.
    virtual int UnProjectFromScreen(
        float  sx, float  sy, float  sz,
        float* px, float* py, float* pz) = 0;

    // Remarks:
    //  For editor.
    virtual void  GetModelViewMatrix(float* mat) = 0;

    // Remarks:
    //  For editor.
    virtual void  GetProjectionMatrix(float* mat) = 0;

    virtual bool WriteDDS(const byte* dat, int wdt, int hgt, int Size, const char* name, ETEX_Format eF, int NumMips) = 0;
    virtual bool WriteTGA(const byte* dat, int wdt, int hgt, const char* name, int src_bits_per_pixel, int dest_bits_per_pixel) = 0;
    virtual bool WriteJPG(const byte* dat, int wdt, int hgt, char* name, int src_bits_per_pixel, int nQuality = 100) = 0;

    /////////////////////////////////////////////////////////////////////////////////
    //Replacement functions for Font

    virtual int  FontCreateTexture(int Width, int Height, byte* pData, ETEX_Format eTF = eTF_R8G8B8A8, bool genMips = false) = 0;
    virtual bool FontUpdateTexture(int nTexId, int X, int Y, int USize, int VSize, byte* pData) = 0;
    virtual void FontSetTexture(int nTexId, int nFilterMode) = 0;
    virtual void FontSetRenderingState(bool overrideViewProjMatrices, TransformationMatrices& backupMatrices) = 0;
    virtual void FontSetBlending(int src, int dst, int baseState) = 0;
    virtual void FontRestoreRenderingState(bool overrideViewProjMatrices, const TransformationMatrices& restoringMatrices) = 0;

    virtual bool FlushRTCommands(bool bWait, bool bImmediatelly, bool bForce) = 0;
    virtual void DrawStringU(IFFont_RenderProxy* pFont, float x, float y, float z, const char* pStr, const bool asciiMultiLine, const STextDrawContext& ctx) const = 0;

    virtual int  RT_CurThreadList() = 0;

    /////////////////////////////////////////////////////////////////////////////////
    // External interface for shaders
    /////////////////////////////////////////////////////////////////////////////////
    virtual bool EF_PrecacheResource(SShaderItem* pSI, float fMipFactor, float fTimeToReady, int Flags, int nUpdateId, int nCounter = 1) = 0;
    virtual bool EF_PrecacheResource(IShader* pSH, float fMipFactor, float fTimeToReady, int Flags) = 0;
    virtual bool EF_PrecacheResource(ITexture* pTP, float fMipFactor, float fTimeToReady, int Flags, int nUpdateId, int nCounter = 1) = 0;
    virtual bool EF_PrecacheResource(IRenderMesh* pPB, _smart_ptr<IMaterial> pMaterial, float fMipFactor, float fTimeToReady, int Flags, int nUpdateId) = 0;
    virtual bool EF_PrecacheResource(CDLight* pLS, float fMipFactor, float fTimeToReady, int Flags, int nUpdateId) = 0;

    virtual ITexture* EF_CreateCompositeTexture(int type, const char* szName, int nWidth, int nHeight, int nDepth, int nMips, int nFlags, ETEX_Format eTF, const STexComposition* pCompositions, size_t nCompositions, int8 nPriority = -1) = 0;

    virtual void PostLevelLoading() = 0;
    virtual void PostLevelUnload() = 0;

    virtual void EF_AddMultipleParticlesToScene(const SAddParticlesToSceneJob* jobs, size_t numJobs, const SRenderingPassInfo& passInfo) = 0;
    virtual void GetMemoryUsageParticleREs(ICrySizer* pSizer) {}

    virtual CRenderObject* EF_AddPolygonToScene(SShaderItem& si, int numPts, const SVF_P3F_C4B_T2F* verts, const SPipTangents* tangs, CRenderObject* obj, const SRenderingPassInfo& passInfo, uint16* inds, int ninds, int nAW, const SRendItemSorter& rendItemSorter) = 0;
    virtual CRenderObject* EF_AddPolygonToScene(SShaderItem& si, CRenderObject* obj, const SRenderingPassInfo& passInfo, int numPts, int ninds, SVF_P3F_C4B_T2F*& verts, SPipTangents*& tangs, uint16*& inds, int nAW, const SRendItemSorter& rendItemSorter) = 0;

    // This is a workaround for when an editor viewport needs to do immediate rendering
    // in the editor. Specifically, global constants are updated in a deferred fashion, so
    // if a viewport (like the lens flare view) starts doing main-thread rendering, those
    // parameters are not bound.
    virtual void ForceUpdateGlobalShaderParameters() {}

    /////////////////////////////////////////////////////////////////////////////////
    // Shaders/Shaders management /////////////////////////////////////////////////////////////////////////////////

    virtual void                EF_SetShaderMissCallback(ShaderCacheMissCallback callback) = 0;
    virtual const char* EF_GetShaderMissLogPath() = 0;

    /////////////////////////////////////////////////////////////////////////////////
    virtual string* EF_GetShaderNames(int& nNumShaders) = 0;
    // Summary:
    //  Reloads file
    virtual bool          EF_ReloadFile (const char* szFileName) = 0;
    // Summary:
    //  Reloads file at any time the renderer feels to do so (no guarantees, but likely on next frame update)
    //  Is threadsafe
    virtual bool          EF_ReloadFile_Request (const char* szFileName) = 0;

    virtual _smart_ptr<IImageFile> EF_LoadImage(const char* szFileName, uint32 nFlags) = 0;
    // Summary:
    //      Remaps shader gen mask to common global mask.
    virtual uint64      EF_GetRemapedShaderMaskGen(const char* name, uint64 nMaskGen = 0, bool bFixup = 0) = 0;

    virtual uint64      EF_GetShaderGlobalMaskGenFromString(const char* szShaderName, const char* szShaderGen, uint64 nMaskGen = 0) = 0;
    virtual const char* EF_GetStringFromShaderGlobalMaskGen(const char* szShaderName, uint64 nMaskGen = 0) = 0;

    virtual const SShaderProfile& GetShaderProfile(EShaderType eST) const = 0;
    virtual void          EF_SetShaderQuality(EShaderType eST, EShaderQuality eSQ) = 0;

    // Summary:
    //  Gets renderer quality.
    virtual ERenderQuality EF_GetRenderQuality() const = 0;
    // Summary:
    //  Gets shader type quality.
    virtual EShaderQuality EF_GetShaderQuality(EShaderType eST) = 0;
    // Summary:
    //  Loads shader item for name (name).
    virtual SShaderItem   EF_LoadShaderItem (const char* szName, bool bShare, int flags = 0, SInputShaderResources* Res = NULL, uint64 nMaskGen = 0) = 0;
    // Summary:
    //  Loads shader for name (name).
    virtual IShader* EF_LoadShader (const char* name, int flags = 0, uint64 nMaskGen = 0) = 0;
    // Summary:
    //  Reinitializes all shader files (build hash tables).
    virtual void          EF_ReloadShaderFiles (int nCategory) = 0;
    // Summary:
    //  Reloads all texture files.
    virtual void          EF_ReloadTextures () = 0;
    // Summary:
    //  Gets texture object by ID.
    virtual ITexture* EF_GetTextureByID(int Id) = 0;
    // Summary:
    //  Gets texture object by Name.
    virtual ITexture* EF_GetTextureByName(const char* name, uint32 flags = 0) = 0;
    // Summary:
    //  Loads the texture for name(nameTex).
    virtual ITexture* EF_LoadTexture(const char* nameTex, const uint32 flags = 0) = 0;
    virtual ITexture* EF_LoadCubemapTexture(const char* nameTex, const uint32 flags = 0) = 0;
    // Summary:
    //  Loads default texture whose life cycle is managed by Texture Manager, do not try to release them by yourself!
    virtual ITexture* EF_LoadDefaultTexture(const char* nameTex) = 0;

    // Summary:
    //  Loads lightmap for name.
    virtual int           EF_LoadLightmap (const char* name) = 0;
    virtual bool          EF_RenderEnvironmentCubeHDR (int size, Vec3& Pos, TArray<unsigned short>& vecData) = 0;

    // Summary:
    //  Creates new RE (RenderElement) of type (edt).
    virtual CRendElementBase* EF_CreateRE (EDataType edt) = 0;

    // Summary:
    //  Starts using of the shaders (return first index for allow recursions).
    virtual void EF_StartEf (const SRenderingPassInfo& passInfo) = 0;

    virtual SRenderObjData* EF_GetObjData(CRenderObject* pObj, bool bCreate, int nThreadID) = 0;

    // Summary:
    //  Gets CRenderObject for RE transformation.
    //Get temporary RenderObject
    virtual CRenderObject* EF_GetObject_Temp (int nThreadID) = 0;

    //Get permanent RenderObject
    virtual CRenderObject* EF_DuplicateRO(CRenderObject* pObj, const SRenderingPassInfo& passInfo) = 0;

    // Summary:
    //  Adds shader to the list.
    virtual void EF_AddEf (CRendElementBase* pRE, SShaderItem& pSH, CRenderObject* pObj, const SRenderingPassInfo& passInfo, int nList, int nAW, const SRendItemSorter& rendItemSorter) = 0;

    //! Draw all shaded REs in the list
    virtual void EF_EndEf3D (const int nFlags, const int nPrecacheUpdateId, const int nNearPrecacheUpdateId, const SRenderingPassInfo& passInfo) = 0;

    virtual void EF_InvokeShadowMapRenderJobs(const int nFlags) = 0;

    // Dynamic lights
    void EF_ClearLightsList() {}; // For FC Compatibility.
    virtual bool EF_IsFakeDLight (const CDLight* Source) = 0;
    virtual void EF_ADDDlight(CDLight* Source, const SRenderingPassInfo& passInfo) = 0;
    virtual bool EF_UpdateDLight(SRenderLight* pDL) = 0;
    virtual bool EF_AddDeferredDecal(const SDeferredDecal& rDecal){return true; }

    // Deferred lights/vis areas

    virtual int EF_AddDeferredLight(const CDLight& pLight, float fMult, const SRenderingPassInfo& passInfo, const SRendItemSorter& rendItemSorter) = 0;
    virtual uint32 EF_GetDeferredLightsNum(const eDeferredLightType eLightType = eDLT_DeferredLight) = 0;
    virtual void EF_ClearDeferredLightsList() = 0;
    virtual TArray<SRenderLight>* EF_GetDeferredLights(const SRenderingPassInfo& passInfo, const eDeferredLightType eLightType = eDLT_DeferredLight) = 0;

    virtual uint8 EF_AddDeferredClipVolume(const IClipVolume* pClipVolume) = 0;
    virtual bool EF_SetDeferredClipVolumeBlendData(const IClipVolume* pClipVolume, const SClipVolumeBlendInfo& blendInfo) = 0;
    virtual void EF_ClearDeferredClipVolumesList() = 0;

    // called in between levels to free up memory
    virtual void EF_ReleaseDeferredData() = 0;

    // called in between levels to free up memory
    virtual void EF_ReleaseInputShaderResource(SInputShaderResources* pRes) = 0;

    //////////////////////////////////////////////////////////////////////////
    // Post processing effects interfaces

    virtual void EF_SetPostEffectParam(const char* pParam, float fValue, bool bForceValue = false) = 0;
    virtual void EF_SetPostEffectParamVec4(const char* pParam, const Vec4& pValue, bool bForceValue = false) = 0;
    virtual void EF_SetPostEffectParamString(const char* pParam, const char* pszArg) = 0;

    virtual void EF_GetPostEffectParam(const char* pParam, float& fValue) = 0;
    virtual void EF_GetPostEffectParamVec4(const char* pParam, Vec4& pValue) = 0;
    virtual void EF_GetPostEffectParamString(const char* pParam, const char*& pszArg) = 0;

    virtual int32 EF_GetPostEffectID(const char* pPostEffectName) = 0;

    virtual void EF_ResetPostEffects(bool bOnSpecChange = false) = 0;

    virtual void SyncPostEffects() = 0;

    virtual void EF_DisableTemporalEffects() = 0;

    //////////////////////////////////////////////////////////////////////////

    virtual void EF_AddWaterSimHit(const Vec3& vPos, const float scale, const float strength) = 0;
    virtual void EF_DrawWaterSimHits() = 0;

    /////////////////////////////////////////////////////////////////////////////////
    // 2d interface for the shaders
    /////////////////////////////////////////////////////////////////////////////////
    virtual void EF_EndEf2D(const bool bSort) = 0;

    // Summary:
    //   Returns various Renderer Settings, see ERenderQueryTypes.
    // Arguments:
    //   Query - e.g. EFQ_GetShaderCombinations.
    //   rInOut - Input/Output Parameter, depends on the query if written to/read from, or both
    void EF_Query(ERenderQueryTypes eQuery)
    {
        EF_QueryImpl(eQuery, NULL, 0, NULL, 0);
    }
    template<typename T>
    void EF_Query(ERenderQueryTypes eQuery, T& rInOut)
    {
        EF_QueryImpl(eQuery, static_cast<void*>(&rInOut), sizeof(T), NULL, 0);
    }
    template<typename T0, typename T1>
    void EF_Query(ERenderQueryTypes eQuery, T0& rInOut0, T1& rInOut1)
    {
        EF_QueryImpl(eQuery, static_cast<void*>(&rInOut0), sizeof(T0), static_cast<void*>(&rInOut1), sizeof(T1));
    }

    // Summary:
    //   Toggles render mesh garbage collection
    // Arguments:
    //   Param -
    virtual void ForceGC() = 0;

    // Remarks:
    //  For stats.
    virtual int  GetPolyCount() = 0;
    virtual void GetPolyCount(int& nPolygons, int& nShadowVolPolys) = 0;

    // Note:
    //  3d engine set this color to fog color.
    virtual void SetClearColor(const Vec3& vColor) = 0;

    // Summary:
    //  Creates/deletes RenderMesh object.
    virtual _smart_ptr<IRenderMesh> CreateRenderMesh(
        const char* szType
        , const char* szSourceName
        , IRenderMesh::SInitParamerers* pInitParams = NULL
        , ERenderMeshType eBufType = eRMT_Static
        ) = 0;

    virtual _smart_ptr<IRenderMesh> CreateRenderMeshInitialized(
        const void* pVertBuffer, int nVertCount, const AZ::Vertex::Format& vertexFormat,
        const vtx_idx* pIndices, int nIndices,
        const PublicRenderPrimitiveType nPrimetiveType, const char* szType, const char* szSourceName, ERenderMeshType eBufType = eRMT_Static,
        int nMatInfoCount = 1, int nClientTextureBindID = 0,
        bool (* PrepareBufferCallback)(IRenderMesh*, bool) = NULL,
        void* CustomData = NULL,
        bool bOnlyVideoBuffer = false,
        bool bPrecache = true,
        const SPipTangents* pTangents = NULL, bool bLockForThreadAcc = false, Vec3* pNormals = NULL) = 0;

    //Pass false to get a frameID that increments by one each frame. For this case the increment happens in the game thread at the beginning of the frame.
    virtual int GetFrameID(bool bIncludeRecursiveCalls = true) = 0;

    virtual void MakeMatrix(const Vec3& pos, const Vec3& angles, const Vec3& scale, Matrix34* mat) = 0;

    // Description:
    //   Draws text queued.
    // Note:
    //   Position can be in 3d or in 2d depending on the flags.
    virtual void DrawTextQueued(Vec3 pos, SDrawTextInfo& ti, const char* format, va_list args) = 0;

    // Description:
    //   Draws text queued.
    // Note:
    //   Position can be in 3d or in 2d depending on the flags.
    virtual void DrawTextQueued(Vec3 pos, SDrawTextInfo& ti, const char* text) = 0;

    //////////////////////////////////////////////////////////////////////

    virtual float ScaleCoordX(float value) const = 0;
    virtual float ScaleCoordY(float value) const = 0;
    virtual void ScaleCoord(float& x, float& y) const = 0;

    virtual void SetState(int State, int AlphaRef = -1) = 0;
    virtual void SetCullMode  (int mode = R_CULL_BACK) = 0;
    virtual void SetStencilState(int st, uint32 nStencRef, uint32 nStencMask, uint32 nStencWriteMask, bool bForceFullReadMask = false) = 0;

    virtual void PushProfileMarker(const char* label) = 0;
    virtual void PopProfileMarker(const char* label) = 0;

    virtual bool EnableFog(bool enable) = 0;
    virtual void SetFogColor(const ColorF& color) = 0;

    virtual void SetColorOp(byte eCo, byte eAo, byte eCa, byte eAa) = 0;
    virtual void SetSrgbWrite(bool srgbWrite) = 0;

    // for one frame allows to disable limit of texture streaming requests
    virtual void RequestFlushAllPendingTextureStreamingJobs(int nFrames) { }

    // allows to dynamically adjust texture streaming load depending on game conditions
    virtual void SetTexturesStreamingGlobalMipFactor(float fFactor) { }

    //////////////////////////////////////////////////////////////////////
    // Summary:
    //  Interface for auxiliary geometry (for debugging, editor purposes, etc.)
    virtual IRenderAuxGeom* GetIRenderAuxGeom(void* jobID = 0) = 0;
    //////////////////////////////////////////////////////////////////////

    //  Interface for renderer side SVO
    virtual ISvoRenderer* GetISvoRenderer() { return 0; }

    virtual IColorGradingController* GetIColorGradingController() = 0;
    virtual IStereoRenderer* GetIStereoRenderer() = 0;

    virtual void TextToScreen(float x, float y, const char* format, ...) PRINTF_PARAMS(4, 5) = 0;
    virtual void TextToScreenColor(int x, int y, float r, float g, float b, float a, const char* format, ...) PRINTF_PARAMS(8, 9) = 0;
    virtual void ResetToDefault() = 0;
    virtual void SetMaterialColor(float r, float g, float b, float a) = 0;

    // Sets default Blend, DepthStencil and Raster states.
    virtual void SetDefaultRenderStates() = 0;

    virtual void Graph(byte* g, int x, int y, int wdt, int hgt, int nC, int type, const char* text, ColorF& color, float fScale) = 0;
    virtual void EF_RenderTextMessages() = 0;

    virtual void ClearTargetsImmediately(uint32 nFlags) = 0;
    virtual void ClearTargetsImmediately(uint32 nFlags, const ColorF& Colors, float fDepth) = 0;
    virtual void ClearTargetsImmediately(uint32 nFlags, const ColorF& Colors) = 0;
    virtual void ClearTargetsImmediately(uint32 nFlags, float fDepth) = 0;

    virtual void ClearTargetsLater(uint32 nFlags) = 0;
    virtual void ClearTargetsLater(uint32 nFlags, const ColorF& Colors, float fDepth) = 0;
    virtual void ClearTargetsLater(uint32 nFlags, const ColorF& Colors) = 0;
    virtual void ClearTargetsLater(uint32 nFlags, float fDepth) = 0;

    virtual void ReadFrameBuffer(unsigned char* pRGB, int nImageX, int nSizeX, int nSizeY, ERB_Type eRBType, bool bRGBA, int nScaledX = -1, int nScaledY = -1) = 0;
    virtual void ReadFrameBufferFast(uint32* pDstARGBA8, int dstWidth, int dstHeight, bool BGRA = true) = 0;

    // Note:
    //  The following functions will be removed.
    virtual void EnableVSync(bool enable) = 0;

    virtual void CreateResourceAsync(SResourceAsync* Resource) = 0;
    virtual void ReleaseResourceAsync(SResourceAsync* Resource) = 0;
    virtual unsigned int DownLoadToVideoMemory(const byte* data, int w, int h, ETEX_Format eTFSrc, ETEX_Format eTFDst, int nummipmap, bool repeat = true, int filter = FILTER_BILINEAR, int Id = 0, const char* szCacheName = NULL, int flags = 0, EEndian eEndian = eLittleEndian, RectI* pRegion = NULL, bool bAsynDevTexCreation = false) = 0;
    virtual unsigned int DownLoadToVideoMemory3D(const byte* data, int w, int h, int d, ETEX_Format eTFSrc, ETEX_Format eTFDst, int nummipmap, bool repeat = true, int filter = FILTER_BILINEAR, int Id = 0, const char* szCacheName = NULL, int flags = 0, EEndian eEndian = eLittleEndian, RectI* pRegion = NULL, bool bAsynDevTexCreation = false) = 0;
    virtual unsigned int DownLoadToVideoMemoryCube(const byte* data, int w, int h, ETEX_Format eTFSrc, ETEX_Format eTFDst, int nummipmap, bool repeat = true, int filter = FILTER_BILINEAR, int Id = 0, const char* szCacheName = NULL, int flags = 0, EEndian eEndian = eLittleEndian, RectI* pRegion = NULL, bool bAsynDevTexCreation = false) = 0;
    virtual void UpdateTextureInVideoMemory(uint32 tnum, const byte* newdata, int posx, int posy, int w, int h, ETEX_Format eTFSrc = eTF_B8G8R8, int posz = 0, int sizez = 1) = 0;

    virtual bool DXTCompress(const byte* raw_data, int nWidth, int nHeight, ETEX_Format eTF, bool bUseHW, bool bGenMips, int nSrcBytesPerPix, MIPDXTcallback callback) = 0;
    virtual bool DXTDecompress(const byte* srcData, const size_t srcFileSize, byte* dstData, int nWidth, int nHeight, int nMips, ETEX_Format eSrcTF, bool bUseHW, int nDstBytesPerPix) = 0;
    virtual void RemoveTexture(unsigned int TextureId) = 0;
    virtual void DeleteFont(IFFont* font) = 0;

    virtual bool BakeMesh(const SMeshBakingInputParams* pInputParams, SMeshBakingOutput* pReturnValues) = 0;

    /////////////////////////////////////////////////////////////////////////////////////////////////////
    // This routines uses 2 destination surfaces.  It triggers a backbuffer copy to one of its surfaces,
    // and then copies the other surface to system memory.  This hopefully will remove any
    // CPU stalls due to the rect lock call since the buffer will already be in system
    // memory when it is called
    // Inputs :
    //          pDstARGBA8          :   Pointer to a buffer that will hold the captured frame (should be at least 4*dstWidth*dstHieght for RGBA surface)
    //          destinationWidth    :   Width of the frame to copy
    //          destinationHeight   :   Height of the frame to copy
    //
    //          Note :  If dstWidth or dstHeight is larger than the current surface dimensions, the dimensions
    //                  of the surface are used for the copy
    //
    virtual bool CaptureFrameBufferFast(unsigned char* pDstRGBA8, int destinationWidth, int destinationHeight) = 0;


    /////////////////////////////////////////////////////////////////////////////////////////////////////
    // Copy a captured surface to a buffer
    //
    // Inputs :
    //          pDstARGBA8          :   Pointer to a buffer that will hold the captured frame (should be at least 4*dstWidth*dstHieght for RGBA surface)
    //          destinationWidth    :   Width of the frame to copy
    //          destinationHeight   :   Height of the frame to copy
    //
    //          Note :  If dstWidth or dstHeight is larger than the current surface dimensions, the dimensions
    //                  of the surface are used for the copy
    //
    virtual bool CopyFrameBufferFast(unsigned char* pDstRGBA8, int destinationWidth, int destinationHeight) = 0;



    /////////////////////////////////////////////////////////////////////////////////////////////////////
    // This routine registers a callback address that is called when a new frame is available
    // Inputs :
    //          pCapture            :   Address of the ICaptureFrameListener object
    //
    // Outputs : returns true if successful, otherwise false
    //
    virtual bool RegisterCaptureFrame(ICaptureFrameListener* pCapture) = 0;

    /////////////////////////////////////////////////////////////////////////////////////////////////////
    // This routine unregisters a callback address that was previously registered
    // Inputs :
    //          pCapture            :   Address of the ICaptureFrameListener object to unregister
    //
    // Outputs : returns true if successful, otherwise false
    //
    virtual bool UnRegisterCaptureFrame(ICaptureFrameListener* pCapture) = 0;


    /////////////////////////////////////////////////////////////////////////////////////////////////////
    // This routine initializes 2 destination surfaces for use by the CaptureFrameBufferFast routine
    // It also, captures the current backbuffer into one of the created surfaces
    //
    // Inputs :
    //          bufferWidth : Width of capture buffer, on consoles the scaling is done on the GPU. Pass in 0 (the default) to use backbuffer dimensions
    //          bufferHeight    : Height of capture buffer.
    //
    // Outputs : returns true if surfaces were created otherwise returns false
    //
    virtual bool InitCaptureFrameBufferFast(uint32 bufferWidth = 0, uint32 bufferHeight = 0) = 0;

    /////////////////////////////////////////////////////////////////////////////////////////////////////
    // This routine releases the 2 surfaces used for frame capture by the CaptureFrameBufferFast routine
    //
    // Inputs : None
    //
    // Returns : None
    //
    virtual void CloseCaptureFrameBufferFast(void) = 0;


    /////////////////////////////////////////////////////////////////////////////////////////////////////
    // This routine checks for any frame buffer callbacks that are needed and calls them
    //
    // Inputs : None
    //
    //  Outputs : None
    //
    virtual void CaptureFrameBufferCallBack(void) = 0;

    virtual void RegisterSyncWithMainListener(ISyncMainWithRenderListener* pListener) = 0;
    virtual void RemoveSyncWithMainListener(const ISyncMainWithRenderListener* pListener) = 0;

    virtual void Set2DMode(uint32 orthoX, uint32 orthoY, TransformationMatrices& backupMatrices, float znear = -1e10f, float zfar = 1e10f) = 0;

    virtual void Unset2DMode(const TransformationMatrices& restoringMatrices) = 0;

    virtual int ScreenToTexture(int nTexID) = 0;
    virtual void EnableSwapBuffers(bool bEnable) = 0;
    virtual WIN_HWND GetHWND() = 0;

    // Set the window icon to be displayed on the output window.
    // The parameter is the path to a DDS texture file to be used as the icon.
    // For best results, pass a square power-of-two sized texture, with a mip-chain.
    virtual bool SetWindowIcon(const char* path) = 0;

    virtual void OnEntityDeleted(struct IRenderNode* pRenderNode) = 0;

    virtual int CreateRenderTarget(const char* name, int nWidth, int nHeight, const ColorF& clearColor, ETEX_Format eTF) = 0;
    virtual bool DestroyRenderTarget (int nHandle) = 0;
    virtual bool SetRenderTarget(int nHandle, SDepthTexture* pDepthSurf = nullptr) = 0;
    virtual SDepthTexture* CreateDepthSurface(int nWidth, int nHeight, bool bAA) = 0;
    virtual void DestroyDepthSurface(SDepthTexture* pDepthSurf) = 0;

    virtual IOpticsElementBase* CreateOptics(EFlareType type) const = 0;

    // Note:
    //  Used for pausing timer related stuff.
    // Example:
    //  For texture animations, and shader 'time' parameter.
    virtual void PauseTimer(bool bPause) = 0;

    // Description:
    //    Creates an Interface to the public params container.
    // Return:
    //    Created IShaderPublicParams interface.
    virtual IShaderPublicParams* CreateShaderPublicParams() = 0;

    virtual void GetThreadIDs(threadID& mainThreadID, threadID& renderThreadID) const = 0;

    struct SArtProfileData
    {
        enum EArtProfileUnit
        {
            eArtProfileUnit_GPU = 0,
            eArtProfileUnit_CPU,
            eArtProfile_NumUnits
        };

        enum EArtProfileSections
        {
            eArtProfile_Shadows = 0,
            eArtProfile_ZPass,
            eArtProfile_Decals,
            eArtProfile_Lighting,
            eArtProfile_Opaque,
            eArtProfile_Transparent,
            eArtProfile_Max,
        };

        float times[eArtProfile_Max];
        float budgets[eArtProfile_Max];
        float total, budgetTotal;

        // detailed values for anything that is grouped together and can be timed
        enum EBreakdownDetailValues
        {
            // Lighting
            eArtProfileDetail_LightsAmbient,
            eArtProfileDetail_LightsCubemaps,
            eArtProfileDetail_LightsDeferred,
            eArtProfileDetail_LightsShadowMaps, // just the cost of the shadow maps

            // Transparent
            eArtProfileDetail_Reflections,
            eArtProfileDetail_Caustics,
            eArtProfileDetail_RefractionOverhead, // partial resolves
            eArtProfileDetail_Rain,
            eArtProfileDetail_LensOptics,

            eArtProfileDetail_Max,
        };

        float breakdowns[eArtProfileDetail_Max];

        int batches, drawcalls, processedLights;

#if defined(ENABLE_ART_RT_TIME_ESTIMATE)
        int numStandardBatches;
        int numStandardDrawCalls;
        int numLightDrawCalls;
        float actualRenderTimeMinusPost;
        float actualRenderTimePost;
        float actualMiscRTTime;
        float actualTotalRTTime;
#endif
    };

    virtual void EnableGPUTimers2(bool bEnabled) = 0;
    virtual void AllowGPUTimers2(bool bAllow) = 0;
    virtual const RPProfilerStats* GetRPPStats(ERenderPipelineProfilerStats eStat, bool bCalledFromMainThread = true) = 0;
    virtual const RPProfilerStats* GetRPPStatsArray(bool bCalledFromMainThread = true) = 0;

    virtual int GetPolygonCountByType(uint32 EFSList, EVertexCostTypes vct, uint32 z, bool bCalledFromMainThread = true) = 0;

    virtual void SetCloudShadowsParams(int nTexID, const Vec3& speed, float tiling, bool invert, float brightness) = 0;
    virtual uint16 PushFogVolumeContribution(const ColorF& fogVolumeContrib, const SRenderingPassInfo& passInfo) = 0;
    virtual void PushFogVolume(class CREFogVolume* pFogVolume, const SRenderingPassInfo& passInfo) = 0;

    virtual int GetMaxTextureSize() = 0;

    virtual const char* GetTextureFormatName(ETEX_Format eTF) = 0;
    virtual int GetTextureFormatDataSize(int nWidth, int nHeight, int nDepth, int nMips, ETEX_Format eTF) = 0;

    virtual void SetDefaultMaterials(_smart_ptr<IMaterial> pDefMat, _smart_ptr<IMaterial> pTerrainDefMat) = 0;

    virtual IGPUParticleEngine* GetGPUParticleEngine() const { return 0; }

    virtual uint32 GetActiveGPUCount() const = 0;
    virtual ShadowFrustumMGPUCache* GetShadowFrustumMGPUCache() = 0;
    virtual const StaticArray<int, MAX_GSM_LODS_NUM>& GetCachedShadowsResolution() const = 0;
    virtual void SetCachedShadowsResolution(const StaticArray<int, MAX_GSM_LODS_NUM>& arrResolutions) = 0;
    virtual void UpdateCachedShadowsLodCount(int nGsmLods) const = 0;

    virtual void SetTexturePrecaching(bool stat) = 0;

    //platform specific
    virtual void    RT_InsertGpuCallback(uint32 context, GpuCallbackFunc callback) = 0;
    virtual void EnablePipelineProfiler(bool bEnable) = 0;

    struct SRenderTimes
    {
        float fWaitForMain;
        float fWaitForRender;
        float fWaitForGPU;
        float fTimeProcessedRT;
        float fTimeProcessedRTScene;    //The part of the render thread between the "SCENE" profiler labels
        float fTimeProcessedGPU;
        float fTimeGPUIdlePercent;
    };
    virtual void GetRenderTimes(SRenderTimes& outTimes) = 0;
    virtual float GetGPUFrameTime() = 0;

    // Enable the batch mode if the meshpools are used to enable quick and dirty flushes.
    virtual void EnableBatchMode(bool enable) = 0;
    // Flag level unloading in progress to disable f.i. rendermesh creation requests
    virtual void EnableLevelUnloading(bool enable) = 0;
    // Function to handle cleanup required if a level load fails
    virtual void OnLevelLoadFailed() = 0;

    struct SDrawCallCountInfo
    {
        static const uint32 MESH_NAME_LENGTH = 32;
        static const uint32 TYPE_NAME_LENGTH = 16;

        SDrawCallCountInfo()
            : pPos(0, 0, 0)
            , nZpass(0)
            , nShadows(0)
            , nGeneral(0)
            , nTransparent(0)
            , nMisc(0)
        {
            meshName[0] = '\0';
            typeName[0] = '\0';
        }

        void Update(CRenderObject* pObj, IRenderMesh* pRM);

        Vec3 pPos;
        uint8 nZpass, nShadows, nGeneral, nTransparent, nMisc;
        char meshName[MESH_NAME_LENGTH];
        char typeName[TYPE_NAME_LENGTH];
    };

    //Debug draw call info (per node)
    typedef std::map< IRenderNode*, IRenderer::SDrawCallCountInfo > RNDrawcallsMapNode;
    typedef RNDrawcallsMapNode::iterator RNDrawcallsMapNodeItor;

    //Debug draw call info (per mesh)
    typedef std::map< IRenderMesh*, IRenderer::SDrawCallCountInfo > RNDrawcallsMapMesh;
    typedef RNDrawcallsMapMesh::iterator RNDrawcallsMapMeshItor;

#if !defined(_RELEASE)
    //Get draw call info for frame
    virtual RNDrawcallsMapMesh& GetDrawCallsInfoPerMesh(bool mainThread = true) = 0;
    virtual int GetDrawCallsPerNode(IRenderNode* pRenderNode) = 0;
    virtual void ForceRemoveNodeFromDrawCallsMap(IRenderNode* pNode) = 0;
#endif

    virtual void CollectDrawCallsInfo(bool status) = 0;
    virtual void CollectDrawCallsInfoPerNode(bool status) = 0;

    //////////////////////////////////////////////////////////////////////////
    // Summary:
    //   Helper functions to draw text.
    //////////////////////////////////////////////////////////////////////////
    void DrawLabel(Vec3 pos, float font_size, const char* label_text, ...) PRINTF_PARAMS(4, 5)
    {
        va_list args;
        va_start(args, label_text);
        SDrawTextInfo ti;
        ti.xscale = ti.yscale = font_size;
        ti.flags = eDrawText_FixedSize | eDrawText_800x600;
        DrawTextQueued(pos, ti, label_text, args);
        va_end(args);
    }

    void DrawLabelEx(Vec3 pos, float font_size, const float* pfColor, bool bFixedSize, bool bCenter, const char* label_text, ...) PRINTF_PARAMS(7, 8)
    {
        va_list args;
        va_start(args, label_text);
        SDrawTextInfo ti;
        ti.xscale = ti.yscale = font_size;
        ti.flags = ((bFixedSize) ? eDrawText_FixedSize : 0) | ((bCenter) ? eDrawText_Center : 0) | eDrawText_800x600;
        if (pfColor)
        {
            ti.color[0] = pfColor[0];
            ti.color[1] = pfColor[1];
            ti.color[2] = pfColor[2];
            ti.color[3] = pfColor[3];
        }
        DrawTextQueued(pos, ti, label_text, args);
        va_end(args);
    }

    void Draw2dLabelEx(float x, float y, float font_size, const ColorF& fColor, EDrawTextFlags flags, const char* label_text, ...) PRINTF_PARAMS(7, 8)
    {
        va_list args;
        va_start(args, label_text);
        SDrawTextInfo ti;
        ti.xscale = ti.yscale = font_size;
        ti.flags = flags;
        {
            ti.color[0] = fColor[0];
            ti.color[1] = fColor[1];
            ti.color[2] = fColor[2];
            ti.color[3] = fColor[3];
        }
        DrawTextQueued(Vec3(x, y, 0.5f), ti, label_text, args);
        va_end(args);
    }

    void Draw2dLabel(float x, float y, float font_size, const float* pfColor, bool bCenter, const char* label_text, ...) PRINTF_PARAMS(7, 8)
    {
        va_list args;
        va_start(args, label_text);
        SDrawTextInfo ti;
        ti.xscale = ti.yscale = font_size;
        ti.flags = eDrawText_2D | eDrawText_800x600 | eDrawText_FixedSize | ((bCenter) ? eDrawText_Center : 0);
        if (pfColor)
        {
            ti.color[0] = pfColor[0];
            ti.color[1] = pfColor[1];
            ti.color[2] = pfColor[2];
            ti.color[3] = pfColor[3];
        }
        DrawTextQueued(Vec3(x, y, 0.5f), ti, label_text, args);
        va_end(args);
    }

    void Draw2dLabel(float x, float y, float font_size, const ColorF& fColor, bool bCenter, const char* label_text, ...) PRINTF_PARAMS(7, 8)
    {
        va_list args;
        va_start(args, label_text);
        SDrawTextInfo ti;
        ti.xscale = ti.yscale = font_size;
        ti.flags = eDrawText_2D | eDrawText_800x600 | eDrawText_FixedSize | ((bCenter) ? eDrawText_Center : 0);
        {
            ti.color[0] = fColor[0];
            ti.color[1] = fColor[1];
            ti.color[2] = fColor[2];
            ti.color[3] = fColor[3];
        }
        DrawTextQueued(Vec3(x, y, 0.5f), ti, label_text, args);
        va_end(args);
    }

    // BLM - Added override that takes flags manually, so we can draw monospaced, etc.
    void Draw2dLabelWithFlags(float x, float y, float font_size, const ColorF& fColor, uint32 flags, const char* label_text, ...) PRINTF_PARAMS(7, 8)
    {
        va_list args;
        va_start(args, label_text);
        SDrawTextInfo ti;
        ti.xscale = ti.yscale = font_size;
        ti.flags = flags;
        {
            ti.color[0] = fColor[0];
            ti.color[1] = fColor[1];
            ti.color[2] = fColor[2];
            ti.color[3] = fColor[3];
        }
        DrawTextQueued(Vec3(x, y, 0.5f), ti, label_text, args);
        va_end(args);
    }

    /**
    * Used to determine if the renderer has loaded default system
    * textures yet.
    *
    * Some textures like s_ptexWhite aren't available until this is true.
    *
    * @return True if the renderer has loaded default resources
    */
    virtual bool HasLoadedDefaultResources() { return false; }

    // Summary:
    virtual SSkinningData* EF_CreateSkinningData(uint32 nNumBones, bool bNeedJobSyncVar, bool bUseMatrixSkinning = false) = 0;
    virtual SSkinningData* EF_CreateRemappedSkinningData(uint32 nNumBones, SSkinningData* pSourceSkinningData, uint32 nCustomDataSize, uint32 pairGuid) = 0;
    virtual void EF_ClearSkinningDataPool() = 0;
    virtual int EF_GetSkinningPoolID() = 0;

    virtual void ClearShaderItem(SShaderItem* pShaderItem) = 0;
    virtual void UpdateShaderItem(SShaderItem* pShaderItem, _smart_ptr<IMaterial> pMaterial) = 0;
    virtual void ForceUpdateShaderItem(SShaderItem* pShaderItem, _smart_ptr<IMaterial> pMaterial) = 0;
    virtual void RefreshShaderResourceConstants(SShaderItem* pShaderItem, _smart_ptr<IMaterial> pMaterial) = 0;

    // Summary:
    //  Determine if a switch to stereo mode will occur at the start of the next frame
    virtual bool IsStereoModeChangePending() = 0;

    // Summary:
    // Wait for all particle ComputeVertices jobs to finish
    virtual void SyncComputeVerticesJobs() = 0;

    // Summary:
    // Lock/Unlock the video memory buffer used by particles when using the jobsystem
    virtual void LockParticleVideoMemory(uint32 nId) = 0;
    virtual void UnLockParticleVideoMemory(uint32 nId) = 0;

    // Summary:
    // tell the renderer that we will begin/stop spawning jobs which generate SRendItems
    virtual void BeginSpawningGeneratingRendItemJobs(int nThreadID) = 0;
    virtual void BeginSpawningShadowGeneratingRendItemJobs(int nThreadID) = 0;
    virtual void EndSpawningGeneratingRendItemJobs(int nThreadID) = 0;

    // Summary:
    // get the shared job state for SRendItem Generating jobs
    virtual AZ::LegacyJobExecutor* GetGenerateRendItemJobExecutor(int nThreadID) = 0;
    virtual AZ::LegacyJobExecutor* GetGenerateShadowRendItemJobExecutor(int nThreadID) = 0;
    virtual AZ::LegacyJobExecutor* GetGenerateRendItemJobExecutorPreProcess(int nThreadID) = 0;
    virtual AZ::LegacyJobExecutor* GetFinalizeRendItemJobExecutor(int nThreadID) = 0;
    virtual AZ::LegacyJobExecutor* GetFinalizeShadowRendItemJobExecutor(int nThreadID) = 0;

    virtual void FlushPendingTextureTasks() = 0;

    virtual void SetShadowJittering(float fShadowJittering) = 0;
    virtual float GetShadowJittering() const = 0;

    virtual bool LoadShaderStartupCache() = 0;
    virtual void UnloadShaderStartupCache() = 0;

    virtual bool LoadShaderLevelCache() = 0;
    virtual void UnloadShaderLevelCache() = 0;

    virtual void StartScreenShot(int e_ScreenShot) {};
    virtual void EndScreenShot(int e_ScreenShot) {};

    // Sets a renderer tracked cvar
    virtual void SetRendererCVar(ICVar* pCVar, const char* pArgText, const bool bSilentMode = false) = 0;

    // Get the render piepline
    virtual SRenderPipeline* GetRenderPipeline() = 0;

    // Get the sahder manager
    virtual CShaderMan* GetShaderManager() = 0;

    // Get render thread
    virtual SRenderThread* GetRenderThread() = 0;

    // Get premade white texture
    virtual ITexture* GetWhiteTexture() = 0;

    // Get the texture for the name and format given
    virtual ITexture* GetTextureForName(const char* name, uint32 nFlags, ETEX_Format eFormat) = 0;

    // Get the camera view parameters
    virtual const CameraViewParameters& GetViewParameters() = 0;

    // Get frame reset number
    virtual uint32 GetFrameReset() = 0;

    // Get original depth buffer
    virtual SDepthTexture* GetDepthBufferOrig() = 0;

    // Get width of backbuffer
    virtual uint32 GetBackBufferWidth() = 0;

    // Get height of backbuffer
    virtual uint32 GetBackBufferHeight() = 0;

    // Get the device buffer manager
    virtual CDeviceBufferManager* GetDeviceBufferManager() = 0;

    // Get render tile info
    virtual const SRenderTileInfo* GetRenderTileInfo() const = 0;

    // Returns precomputed identity matrix
    virtual Matrix44A GetIdentityMatrix() = 0;

    // Get current GPU group Id. Used for tracking which GPU is being used
    virtual int32 RT_GetCurrGpuID() const = 0;

    // Generate the next texture id
    virtual int GenerateTextureId() = 0;

    // Set culling mode
    virtual void SetCull(ECull eCull, bool bSkipMirrorCull = false) = 0;

    // Draw a quad
    virtual void DrawQuad3D(const Vec3& v0, const Vec3& v1, const Vec3& v2, const Vec3& v3, const ColorF& color, float ftx0, float fty0, float ftx1, float fty1) = 0;

    // Resets render pipeline state
    virtual void FX_ResetPipe() = 0;

    // Gets an (existing) depth surface of the dimensions given
    virtual SDepthTexture* FX_GetDepthSurface(int nWidth, int nHeight, bool bAA) = 0;

    // Creates a new depth surface
    virtual SDepthTexture* FX_CreateDepthSurface(int nWidth, int nHeight, bool bAA) = 0;

    // Check to see if buffers are full and if so flush
    virtual void FX_CheckOverflow(int nVerts, int nInds, CRendElementBase* re, int* nNewVerts = nullptr, int* nNewInds = nullptr) = 0;

    // Perform pre render work
    virtual void FX_PreRender(int Stage) = 0;

    // Perform post render work
    virtual void FX_PostRender() = 0;

    // Set render states
    virtual void FX_SetState(int st, int AlphaRef = -1, int RestoreState = 0) = 0;

    // Commit render states
    virtual void FX_CommitStates(const SShaderTechnique* pTech, const SShaderPass* pPass, bool bUseMaterialState) = 0;

    // Commit changes made thus dar
    virtual void FX_Commit(bool bAllowDIP = false) = 0;

    // Sets vertex declaration
    virtual long FX_SetVertexDeclaration(int StreamMask, const AZ::Vertex::Format& vertexFormat) = 0;

    // Draw indexed prim
    virtual void FX_DrawIndexedPrimitive(const eRenderPrimitiveType eType, const int nVBOffset, const int nMinVertexIndex, const int nVerticesCount, const int nStartIndex, const int nNumIndices, bool bInstanced = false) = 0;

    // Set Index stream
    virtual long FX_SetIStream(const void* pB, uint32 nOffs, RenderIndexType idxType) = 0;

    // Set vertex stream
    virtual long FX_SetVStream(int nID, const void* pB, uint32 nOffs, uint32 nStride, uint32 nFreq = 1) = 0;

    // Draw primitives
    virtual void FX_DrawPrimitive(const eRenderPrimitiveType eType, const int nStartVertex, const int nVerticesCount, const int nInstanceVertices = 0) = 0;

    // Clear texture
    virtual void FX_ClearTarget(CTexture* pTex) = 0;

    // Clear depth
    virtual void FX_ClearTarget(SDepthTexture* pTex) = 0;

    // Set render target
    virtual bool FX_SetRenderTarget(int nTarget, void* pTargetSurf, SDepthTexture* pDepthTarget, uint32 nTileCount = 1) = 0;

    // Pushes render target
    virtual bool FX_PushRenderTarget(int nTarget, void* pTargetSurf, SDepthTexture* pDepthTarget, uint32 nTileCount = 1) = 0;

    // Sets up the render target
    virtual bool FX_SetRenderTarget(int nTarget, CTexture* pTarget, SDepthTexture* pDepthTarget, bool bPush = false, int nCMSide = -1, bool bScreenVP = false, uint32 nTileCount = 1) = 0;

    // Push render target
    virtual bool FX_PushRenderTarget(int nTarget, CTexture* pTarget, SDepthTexture* pDepthTarget, int nCMSide = -1, bool bScreenVP = false, uint32 nTileCount = 1) = 0;

    // Restore render target
    virtual bool FX_RestoreRenderTarget(int nTarget) = 0;

    // Pop render target
    virtual bool FX_PopRenderTarget(int nTarget) = 0;

    // Start an effect / shader / etc..
    virtual void FX_Start(CShader* ef, int nTech, CShaderResources* Res, CRendElementBase* re) = 0;

    // Pop render target on render thread
    virtual void RT_PopRenderTarget(int nTarget) = 0;

    // Sets viewport dimensions on render thread
    virtual void RT_SetViewport(int x, int y, int width, int height, int id = -1) = 0;

    // Push render target on render thread
    virtual void RT_PushRenderTarget(int nTarget, CTexture* pTex, SDepthTexture* pDS, int nS) = 0;

    // Setup scissors rect
    virtual void EF_Scissor(bool bEnable, int sX, int sY, int sWdt, int sHgt) = 0;

#ifdef SUPPORT_HW_MOUSE_CURSOR
    virtual IHWMouseCursor* GetIHWMouseCursor() = 0;
#endif

    virtual int GetRecursionLevel() = 0;

    virtual int GetIntegerConfigurationValue(const char* varName, int defaultValue) = 0;
    virtual float GetFloatConfigurationValue(const char* varName, float defaultValue) = 0;
    virtual bool GetBooleanConfigurationValue(const char* varName, bool defaultValue) = 0;

private:
    // use private for EF_Query to prevent client code to submit arbitrary combinations of output data/size
    virtual void EF_QueryImpl(ERenderQueryTypes eQuery, void* pInOut0, uint32 nInOutSize0, void* pInOut1, uint32 nInOutSize1) = 0;
};

// util class to change wireframe mode
class CScopedWireFrameMode
{
public:
    CScopedWireFrameMode(IRenderer* pRenderer, int nMode)
        : m_pRenderer(pRenderer)
        , m_nMode(nMode)
    {
        (void) m_nMode; // removes not used warning
        pRenderer->PushWireframeMode(nMode);
    }
    ~CScopedWireFrameMode()
    {
        m_pRenderer->PopWireframeMode();
    }
private:
    IRenderer* m_pRenderer;
    int m_nMode;
};

struct SShaderCacheStatistics
{
    size_t m_nTotalLevelShaderCacheMisses;
    size_t m_nGlobalShaderCacheMisses;
    size_t m_nNumShaderAsyncCompiles;
    bool m_bShaderCompileActive;

    SShaderCacheStatistics()
        : m_nTotalLevelShaderCacheMisses(0)
        , m_nGlobalShaderCacheMisses(0)
        , m_nNumShaderAsyncCompiles(0)
        , m_bShaderCompileActive(false)
    {}
};

// The statistics about the pool for render mesh data
// Note:
struct SMeshPoolStatistics
{
    // The size of the mesh data size in bytes
    size_t nPoolSize;

    // The amount of memory currently in use in the pool
    size_t nPoolInUse;

    // The highest amount of memory allocated within the mesh data pool
    size_t nPoolInUsePeak;

    // The size of the mesh data size in bytes
    size_t nInstancePoolSize;

    // The amount of memory currently in use in the pool
    size_t nInstancePoolInUse;

    // The highest amount of memory allocated within the mesh data pool
    size_t nInstancePoolInUsePeak;

    size_t nFallbacks;
    size_t nInstanceFallbacks;
    size_t nFlushes;

    SMeshPoolStatistics()
        : nPoolSize()
        , nPoolInUse()
        , nInstancePoolSize()
        , nInstancePoolInUse()
        , nInstancePoolInUsePeak()
        , nFallbacks()
        , nInstanceFallbacks()
        , nFlushes()
    {}
};

struct SRendererQueryGetAllTexturesParam
{
    SRendererQueryGetAllTexturesParam()
        : pTextures(NULL)
        , numTextures(0)
    {
    }

    _smart_ptr<ITexture>* pTextures;
    uint32 numTextures;
};


//////////////////////////////////////////////////////////////////////

#define STRIPTYPE_NONE           0
#define STRIPTYPE_ONLYLISTS      1
#define STRIPTYPE_SINGLESTRIP    2
#define STRIPTYPE_MULTIPLESTRIPS 3
#define STRIPTYPE_DEFAULT        4

/////////////////////////////////////////////////////////////////////

struct IRenderMesh;

//DOC-IGNORE-BEGIN
#include "VertexFormats.h"
//DOC-IGNORE-END

struct SRestLightingInfo
{
    SRestLightingInfo()
    {
        averDir.zero();
        averCol = Col_Black;
        refPoint.zero();
    }
    Vec3 averDir;
    ColorF averCol;
    Vec3 refPoint;
};

class CLodValue
{
public:
    CLodValue()
    {
        m_nLodA = -1;
        m_nLodB = -1;
        m_nDissolveRef = 0;
    }

    CLodValue(int nLodA)
    {
        m_nLodA = aznumeric_caster(nLodA);
        m_nLodB = -1;
        m_nDissolveRef = 0;
    }

    CLodValue(int nLodA, uint8 nDissolveRef, int nLodB)
    {
        m_nLodA = aznumeric_caster(nLodA);
        m_nLodB = aznumeric_caster(nLodB);
        m_nDissolveRef = nDissolveRef;
    }

    int LodA() const { return m_nLodA; }
    int LodB() const { return m_nLodB; }

    uint8 DissolveRefA() const { return m_nDissolveRef; }
    uint8 DissolveRefB() const { return 255 - m_nDissolveRef; }

private:
    int16 m_nLodA;
    int16 m_nLodB;
    uint8 m_nDissolveRef;
};

// Description:
//   Structure used to pass render parameters to Render() functions of IStatObj and ICharInstance.
struct SRendParams
{
    SRendParams()
    {
        memset(this, 0, sizeof(SRendParams));
        fAlpha = 1.f;
        fRenderQuality = 1.f;
        nRenderList = EFSLIST_GENERAL;
        nAfterWater = 1;
        mRenderFirstContainer = false;
    }

    // Summary:
    //  object transformations.
    Matrix34* pMatrix;
    struct SInstancingInfo* pInstInfo;
    // Summary:
    //  object previous transformations - motion blur specific.
    Matrix34* pPrevMatrix;
    // Summary:
    //  List of shadow map casters.
    uint64 m_ShadowMapCasters;
    //  VisArea that contains this object, used for RAM-ambient cube query
    IVisArea*       m_pVisArea;
    // Summary:
    //  Override material.
    _smart_ptr<IMaterial> pMaterial;
    // Summary:
    //   Skeleton implementation for bendable foliage.
    IFoliage* pFoliage;
    // Summary:
    //   Weights stream for deform morphs.
    IRenderMesh* pWeights;
    // Summary:
    //  Object Id for objects identification in renderer.
    struct IRenderNode* pRenderNode;
    // Summary:
    //  Unique object Id for objects identification in renderer.
    void* pInstance;
    // Summary:
    //   TerrainTexInfo for grass.
    struct SSectorTextureSet* pTerrainTexInfo;
    // Summary:
    //   storage for LOD transition states.
    struct CRNTmpData** ppRNTmpData;
    // Summary:
    //  dynamic render data object which can be set by the game
    DynArray<SShaderParam>* pShaderParams;
    // Summary:
    //  Ambient color for the object.
    ColorF AmbientColor;
    // Summary:
    //  Custom sorting offset.
    float       fCustomSortOffset;
    // Summary:
    //  Object alpha.
    float     fAlpha;
    // Summary:
    //  Distance from camera.
    float     fDistance;
    // Summary:
    //   Quality of shaders rendering.
    float fRenderQuality;
    // Summary:
    //  Light mask to specify which light to use on the object.
    uint32 nDLightMask;
    // Summary:
    //  Approximate information about the lights not included into nDLightMask.
    //  SRestLightingInfo restLightInfo;
    // Summary:
    //  CRenderObject flags.
    int32       dwFObjFlags;
    // Summary:
    //   Material layers blending amount
    uint32 nMaterialLayersBlend;
    // Summary:
    //  Vision modes params
    uint32 nVisionParams;
    // Summary:
    //  Vision modes params
    uint32 nHUDSilhouettesParams;
    // Summary:
    //  Defines what pieces of pre-broken geometry has to be rendered
    uint64 nSubObjHideMask;

    //   Defines per object float custom data
    float fCustomData[4];

    //   Custom TextureID
    int16 nTextureID;

    //   Defines per object custom flags
    uint16 nCustomFlags;

    // The LOD value compute for rendering
    CLodValue lodValue;

    //   Defines per object custom data
    uint8 nCustomData;

    // Summary:
    //   Defines per object DissolveRef value if used by shader.
    uint8 nDissolveRef;
    // Summary:
    //   per-instance vis area stencil ref id
    uint8   nClipVolumeStencilRef;
    // Summary:
    //   Custom offset for sorting by distance.
    uint8  nAfterWater;

    // Summary:
    //   Material layers bitmask -> which material layers are active.
    uint8 nMaterialLayers;

    // Summary:
    //  Force a sort value for render elements.
    uint8 nRenderList;
    // Summary:
    //  Special sorter to ensure correct ordering even if parts of the 3DEngine are run in parallel
    uint32 rendItemSorter;
    // Summary:
    // Render the first particle container only, instead of all the containers
    bool mRenderFirstContainer;

    // Summary:
    // Check if the preview would Show Wireframe - Vera,Confetti
    bool bIsShowWireframe;

    //Summary:
    // Force drawing static instead of deformable meshes
    bool bForceDrawStatic;
};