382 lines
15 KiB
C++
382 lines
15 KiB
C++
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions
|
|
// are met:
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above copyright
|
|
// notice, this list of conditions and the following disclaimer in the
|
|
// documentation and/or other materials provided with the distribution.
|
|
// * Neither the name of NVIDIA CORPORATION nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// Copyright (c) 2008-2021 NVIDIA Corporation. All rights reserved.
|
|
|
|
#ifndef RENDERER_H
|
|
#define RENDERER_H
|
|
|
|
#include <RendererConfig.h>
|
|
|
|
#include <RendererMaterial.h>
|
|
#include <RendererWindow.h>
|
|
#include <RendererColor.h>
|
|
#include <RendererUtils.h>
|
|
#include <SampleUserInput.h>
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
#include <queue>
|
|
|
|
#if PX_VC
|
|
#pragma warning(push)
|
|
#pragma warning(disable:4702)
|
|
#include <map>
|
|
#pragma warning(pop)
|
|
#else
|
|
#include <map>
|
|
#endif
|
|
|
|
#include "foundation/PxVec2.h"
|
|
#include "foundation/PxProfiler.h"
|
|
|
|
namespace SampleRenderer
|
|
{
|
|
|
|
class RendererDesc;
|
|
class RendererWindow;
|
|
class RendererVertexBuffer;
|
|
class RendererVertexBufferDesc;
|
|
class RendererIndexBuffer;
|
|
class RendererIndexBufferDesc;
|
|
class RendererSurfaceBuffer;
|
|
class RendererSurfaceBufferDesc;
|
|
class RendererInstanceBuffer;
|
|
class RendererInstanceBufferDesc;
|
|
class RendererTexture;
|
|
class RendererTextureDesc;
|
|
class RendererTarget;
|
|
class RendererTargetDesc;
|
|
class RendererMaterial;
|
|
class RendererMaterialDesc;
|
|
class RendererMesh;
|
|
class RendererMeshDesc;
|
|
class RendererMeshContext;
|
|
class RendererLight;
|
|
class RendererLightDesc;
|
|
|
|
class RendererColor;
|
|
class RendererProjection;
|
|
|
|
class ScreenQuad
|
|
{
|
|
public:
|
|
ScreenQuad();
|
|
|
|
RendererColor mLeftUpColor; //!< Color for left-up vertex
|
|
RendererColor mLeftDownColor; //!< Color for left-down vertex
|
|
RendererColor mRightUpColor; //!< Color for right-up vertex
|
|
RendererColor mRightDownColor; //!< Color for right-down vertex
|
|
PxReal mAlpha; //!< Alpha value
|
|
PxReal mX0, mY0; //!< Up-left coordinates
|
|
PxReal mX1, mY1; //!< Bottom-right coordinates
|
|
};
|
|
|
|
class Renderer
|
|
{
|
|
public:
|
|
struct TextVertex
|
|
{
|
|
PxVec3 p;
|
|
PxReal rhw;
|
|
PxU32 color;
|
|
PxReal u,v;
|
|
};
|
|
|
|
struct TessellationParams
|
|
{
|
|
TessellationParams();
|
|
|
|
void setDefault();
|
|
std::string toString();
|
|
|
|
PxVec4 tessFactor;
|
|
PxReal tessMinMaxDistance[2];
|
|
PxReal tessHeightScaleAndBias[2];
|
|
PxReal tessUVScale[2];
|
|
};
|
|
|
|
typedef enum DriverType
|
|
{
|
|
DRIVER_OPENGL = 0, // Supports Windows, Linux, MacOSX.
|
|
DRIVER_DIRECT3D9, // Supports Windows.
|
|
DRIVER_DIRECT3D11, // Supports Windows 7/Vista.
|
|
DRIVER_NULL,
|
|
} DriverType;
|
|
|
|
public:
|
|
// assetDir should point to the directory where shaders can be found in the assetDir/shaders/ subdirectory and textures are in assetDir/textures
|
|
// enableMaterialCaching will try to compile as few shaders as possible
|
|
static Renderer *createRenderer(const RendererDesc &desc, const char* assetDir, bool enableMaterialCaching = true);
|
|
|
|
static const char *getDriverTypeName(DriverType type);
|
|
|
|
protected:
|
|
Renderer(DriverType driver, PxErrorCallback* errorCallback, const char* shaderDir);
|
|
virtual ~Renderer(void);
|
|
|
|
public:
|
|
void release(void);
|
|
|
|
// get the driver type for this renderer.
|
|
DriverType getDriverType(void) const;
|
|
|
|
// get the offset to the center of a pixel relative to the size of a pixel (so either 0 or 0.5).
|
|
PxF32 getPixelCenterOffset(void) const;
|
|
|
|
// get the name of the hardware device.
|
|
const char *getDeviceName(void) const;
|
|
|
|
// adds a mesh to the render queue.
|
|
void queueMeshForRender(RendererMeshContext &mesh);
|
|
void removeMeshFromRenderQueue(RendererMesh& mesh);
|
|
|
|
// adds a light to the render queue.
|
|
void queueLightForRender(RendererLight &light);
|
|
void removeLightFromRenderQueue(RendererLight &light);
|
|
|
|
// renders the current scene to the offscreen buffers. empties the render queue when done.
|
|
void render(const physx::PxMat44 &eye, const RendererProjection &proj, RendererTarget *target=0, bool depthOnly=false);
|
|
|
|
// sets fog
|
|
void setFog(const RendererColor &fogColor, float fogDistance);
|
|
|
|
// sets the ambient lighting color.
|
|
void setAmbientColor(const RendererColor &ambientColor);
|
|
// get the ambient lighting color.
|
|
RendererColor getAmbientColor();
|
|
|
|
// sets the clear color.
|
|
void setClearColor(const RendererColor &clearColor);
|
|
RendererColor& getClearColor() { return m_clearColor; }
|
|
|
|
// sets whether tessellation is enabled. must be supported by the underlying renderer implementation
|
|
void setEnableTessellation(bool enable) { m_enableTessellation = enable && isTessellationSupported(); }
|
|
bool getEnableTessellation() const { return m_enableTessellation; }
|
|
virtual bool isTessellationSupported(void) const { return false; }
|
|
|
|
// sets appropriate tessellation parameters
|
|
void setTessellationParams(const TessellationParams&);
|
|
TessellationParams& getTessellationParams() { return m_tessellationParams; }
|
|
|
|
// sets whether wireframe mode is enabled
|
|
void toggleWireframe() { m_enableWireframe = !m_enableWireframe; }
|
|
bool wireframeEnabled() const { return m_enableWireframe; }
|
|
|
|
// sets whether to override the blending of individual meshes
|
|
void setEnableBlendingOverride(bool enable) { m_enableBlendingOverride = enable; }
|
|
bool blendingOverrideEnabled() const { return m_enableBlendingOverride; }
|
|
|
|
// sets whether to use culling on meshes with blending
|
|
void setEnableBlendingCull(bool enable) { m_enableBlendingCull = enable; }
|
|
bool blendingCull() const { return m_enableBlendingCull; }
|
|
|
|
// get and set the output message stream
|
|
void setErrorCallback(PxErrorCallback* errc) { m_errorCallback = errc; }
|
|
PxErrorCallback* getErrorCallback() { return m_errorCallback; }
|
|
|
|
// sprite renderer is not available on dx11 feature level dx9
|
|
virtual bool isSpriteRenderingSupported(void) const { return true; }
|
|
|
|
// clears the offscreen buffers.
|
|
virtual void clearBuffers(void) = 0;
|
|
|
|
// presents the current color buffer to the screen.
|
|
// returns true on device reset and if buffers need to be rewritten.
|
|
virtual bool swapBuffers(void) = 0;
|
|
|
|
// get the device pointer (void * abstraction)
|
|
virtual void *getDevice() = 0;
|
|
|
|
// save the screen data to disk
|
|
virtual bool captureScreen(const char* filename);
|
|
|
|
// gets a handle to the current frame's data, in bitmap format
|
|
// note: subsequent calls will invalidate any previously returned data
|
|
virtual bool captureScreen(PxU32 &width, PxU32& height, PxU32& sizeInBytes, const void*& screenshotData) = 0;
|
|
|
|
virtual void getWindowSize(PxU32 &width, PxU32 &height) const = 0;
|
|
|
|
virtual PxU32 convertColor(const RendererColor& color) const = 0;
|
|
virtual void finishRendering() {}
|
|
|
|
virtual RendererVertexBuffer *createVertexBuffer( const RendererVertexBufferDesc &desc) = 0;
|
|
virtual RendererIndexBuffer *createIndexBuffer( const RendererIndexBufferDesc &desc) = 0;
|
|
// virtual RendererSurfaceBuffer *createSurfaceBuffer( const RendererSurfaceBufferDesc &desc) = 0;
|
|
virtual RendererInstanceBuffer *createInstanceBuffer(const RendererInstanceBufferDesc &desc) = 0;
|
|
virtual RendererTexture *createTexture( const RendererTextureDesc &desc);
|
|
virtual RendererTexture2D *createTexture2D( const RendererTexture2DDesc &desc) = 0;
|
|
virtual RendererTexture3D *createTexture3D( const RendererTexture3DDesc &desc) = 0;
|
|
virtual RendererTarget *createTarget( const RendererTargetDesc &desc) = 0;
|
|
virtual RendererMaterial *createMaterial( const RendererMaterialDesc &desc) = 0;
|
|
virtual RendererMesh *createMesh( const RendererMeshDesc &desc) = 0;
|
|
virtual RendererLight *createLight( const RendererLightDesc &desc) = 0;
|
|
|
|
virtual void disableDepthTest() {}
|
|
virtual void enableDepthTest() {}
|
|
|
|
// These two methods are only necessary for internal caching of compiled materials
|
|
bool getEnableMaterialCaching() { return mEnableMaterialCaching; }
|
|
|
|
virtual void setVsync(bool on) = 0;
|
|
protected:
|
|
void setEnableMaterialCaching(bool enable) { mEnableMaterialCaching = enable; }
|
|
RendererMaterial *hasMaterialAlready( const RendererMaterialDesc& desc);
|
|
void registerMaterial( const RendererMaterialDesc& desc, RendererMaterial* mat);
|
|
void releaseAllMaterials();
|
|
|
|
void formatScreenshot(PxU32 width, PxU32 height, PxU32 sizeInBytes, int rPosition, int gPosition, int bPosition, bool bFlipY, void* screenshotData);
|
|
public:
|
|
|
|
// Text rendering
|
|
virtual bool initTexter();
|
|
virtual void closeTexter();
|
|
void print(PxU32 x, PxU32 y, const char* text, PxReal scale=0.5f, PxReal shadowOffset=6.0f, RendererColor textColor = RendererColor(255, 255, 255, 255), bool forceFixWidthNumbers = false);
|
|
void print(PxU32* x, PxU32* y, const char** text, PxU32 textCount, PxReal scale=0.5f, PxReal shadowOffset=6.0f, RendererColor* textColors = NULL, bool forceFixWidthNumbers = false);
|
|
const char* getAssetDir();
|
|
|
|
// assetDir should point to the directory where shaders can be found in the assetDir/shaders/ subdirectory and textures are in assetDir/textures
|
|
void setAssetDir( const char * assetDir );
|
|
|
|
void setCacheShaderDir( const char * cacheDir ) { m_cacheDir = cacheDir; }
|
|
const char* getCacheShaderDir() { return m_cacheDir; }
|
|
|
|
// Screenquad
|
|
virtual bool initScreenquad();
|
|
virtual void closeScreenquad();
|
|
bool drawScreenQuad(const ScreenQuad& screenQuad);
|
|
bool drawTouchControls();
|
|
bool drawLines2D(PxU32 nbVerts, const PxReal* vertices, const RendererColor& color);
|
|
bool drawLines2D(PxU32 nbVerts, const PxReal* vertices, const RendererColor* colors);
|
|
|
|
private:
|
|
void renderMeshes(std::vector<RendererMeshContext>& meshes, RendererMaterial::Pass pass);
|
|
void renderDeferredLights(void);
|
|
void sortMeshes(const physx::PxMat44& eye);
|
|
|
|
private:
|
|
RendererMesh* initControl(PxReal* vertices, PxReal* texcoords, PxU32 verticesCount);
|
|
friend class ScopedRender;
|
|
virtual bool beginRender(void) { return true;}
|
|
virtual void endRender(void) {}
|
|
virtual void bindViewProj(const physx::PxMat44 &eye, const RendererProjection &proj) = 0;
|
|
virtual void bindFogState(const RendererColor &fogColor, float fogDistance) = 0;
|
|
virtual void bindAmbientState(const RendererColor &ambientColor) = 0;
|
|
virtual void bindDeferredState(void) = 0;
|
|
virtual void bindMeshContext(const RendererMeshContext &context) = 0;
|
|
virtual void beginMultiPass(void) = 0;
|
|
virtual void endMultiPass(void) = 0;
|
|
virtual void beginTransparentMultiPass(void) = 0;
|
|
virtual void endTransparentMultiPass(void) = 0;
|
|
virtual void renderDeferredLight(const RendererLight &light) = 0;
|
|
|
|
virtual bool isOk(void) const = 0;
|
|
|
|
public:
|
|
virtual void setupTextRenderStates() = 0;
|
|
virtual void resetTextRenderStates() = 0;
|
|
virtual void renderTextBuffer(const void* vertices, PxU32 nbVerts, const PxU16* indices, PxU32 nbIndices, RendererMaterial* material) = 0;
|
|
virtual void renderLines2D(const void* vertices, PxU32 nbVerts) = 0;
|
|
|
|
virtual void setupScreenquadRenderStates() = 0;
|
|
virtual void resetScreenquadRenderStates() = 0;
|
|
|
|
private:
|
|
Renderer &operator=(const Renderer&) { return *this; }
|
|
|
|
|
|
const DriverType m_driver;
|
|
|
|
protected:
|
|
PxErrorCallback* m_errorCallback;
|
|
// Texter data
|
|
RendererMaterial* m_textMaterial;
|
|
RendererMaterialInstance* m_textMaterialInstance;
|
|
|
|
private:
|
|
typedef std::vector<RendererMeshContext> MeshVector;
|
|
MeshVector m_visibleLitMeshes;
|
|
MeshVector m_visibleUnlitMeshes;
|
|
MeshVector m_screenSpaceMeshes;
|
|
MeshVector m_visibleLitTransparentMeshes;
|
|
|
|
//std::priority_queue<RendererMeshContext, MeshVector, CompareMeshCameraDistance> m_visibleLitTransparentMeshes;
|
|
std::vector<RendererLight*> m_visibleLights;
|
|
|
|
RendererColor m_fogColor;
|
|
float m_fogDistance;
|
|
|
|
RendererColor m_ambientColor;
|
|
RendererColor m_clearColor;
|
|
|
|
// Screenquad data
|
|
RendererMaterial* m_screenquadOpaqueMaterial;
|
|
RendererMaterialInstance* m_screenquadOpaqueMaterialInstance;
|
|
RendererMaterial* m_screenquadAlphaMaterial;
|
|
RendererMaterialInstance* m_screenquadAlphaMaterialInstance;
|
|
|
|
protected:
|
|
PxF32 m_pixelCenterOffset;
|
|
char m_deviceName[256];
|
|
bool m_useShadersForTextRendering;
|
|
std::string m_assetDir;
|
|
const char* m_cacheDir;
|
|
|
|
// Tessellation data
|
|
TessellationParams m_tessellationParams;
|
|
bool m_enableTessellation;
|
|
|
|
bool m_enableWireframe;
|
|
bool m_enableBlendingOverride;
|
|
bool m_enableBlendingCull;
|
|
|
|
bool mEnableMaterialCaching;
|
|
struct CompareRenderMaterialDesc
|
|
{
|
|
bool operator()(const RendererMaterialDesc& desc1, const RendererMaterialDesc& desc2) const;
|
|
};
|
|
typedef std::map<RendererMaterialDesc, RendererMaterial*, CompareRenderMaterialDesc> tMaterialCache;
|
|
tMaterialCache m_materialCache;
|
|
};
|
|
|
|
// Ensure that endRender() is called after each successful beginRender()
|
|
class ScopedRender : public safe_bool<>
|
|
{
|
|
public:
|
|
ScopedRender(Renderer& renderer) : mRenderer(renderer), mBeginRenderSuccessful(mRenderer.beginRender()) { }
|
|
~ScopedRender() { if (boolean_test()) mRenderer.endRender(); }
|
|
ScopedRender& operator=(const ScopedRender&) {return *this;}
|
|
|
|
bool boolean_test() const { return mBeginRenderSuccessful; }
|
|
|
|
protected:
|
|
Renderer& mRenderer;
|
|
bool mBeginRenderSuccessful;
|
|
};
|
|
|
|
} // namespace SampleRenderer
|
|
|
|
#endif
|