Initial commit with PS4 and XBone stuff trimmed.

1 files changed, 487 insertions, 0 deletions

diff --git a/src/Simulation_impl.h b/src/Simulation_impl.h
new file mode 100644
index 0000000..0a80e71
--- /dev/null
+++ b/src/Simulation_impl.h
@@ -0,0 +1,487 @@
+// This code contains NVIDIA Confidential Information and is disclosed 
+// under the Mutual Non-Disclosure Agreement. 
+// 
+// Notice 
+// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES 
+// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO 
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT, 
+// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. 
+// 
+// NVIDIA Corporation assumes no responsibility for the consequences of use of such 
+// information or for any infringement of patents or other rights of third parties that may 
+// result from its use. No license is granted by implication or otherwise under any patent 
+// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless 
+// expressly authorized by NVIDIA.  Details are subject to change without notice. 
+// This code supersedes and replaces all information previously supplied. 
+// NVIDIA Corporation products are not authorized for use as critical 
+// components in life support devices or systems without express written approval of 
+// NVIDIA Corporation. 
+// 
+// Copyright � 2008- 2013 NVIDIA Corporation. All rights reserved.
+//
+// NVIDIA Corporation and its licensors retain all intellectual property and proprietary
+// rights in and to this software and related documentation and any modifications thereto.
+// Any use, reproduction, disclosure or distribution of this software and related
+// documentation without an express license agreement from NVIDIA Corporation is
+// strictly prohibited.
+//
+
+#ifndef _NVWAVEWORKS_SIMULATION_IMPL_H
+#define _NVWAVEWORKS_SIMULATION_IMPL_H
+
+#if WAVEWORKS_ENABLE_GNM
+namespace sce
+{
+	namespace Gnmx
+	{
+		class VsShader;
+		class PsShader;
+		class CsShader;
+
+		namespace Toolkit
+		{
+			class IAllocator;
+		}
+
+	}
+}
+namespace GFSDK_WaveWorks_GNM_Util
+{
+	class RenderTargetClearer;
+}
+#include <gnm\buffer.h>
+#include <gnm\sampler.h>
+#include <gnm\regs.h>
+#include <gnm\texture.h>
+#include <gnm\rendertarget.h>
+#endif
+
+class NVWaveWorks_Mesh;
+class NVWaveWorks_FFT_Simulation;
+class NVWaveWorks_FFT_Simulation_Manager;
+class NVWaveWorks_GFX_Timer_Impl;
+struct GFSDK_WaveWorks_CPU_Scheduler_Interface;
+struct ID3D11DeviceContext;
+
+struct GFSDK_WaveWorks_Simulation
+{
+public:
+    GFSDK_WaveWorks_Simulation();
+    ~GFSDK_WaveWorks_Simulation();
+
+    HRESULT initD3D9(const GFSDK_WaveWorks_Detailed_Simulation_Params& params, IDirect3DDevice9* pD3DDevice);
+    HRESULT initD3D10(const GFSDK_WaveWorks_Detailed_Simulation_Params& params, ID3D10Device* pD3DDevice);
+    HRESULT initD3D11(const GFSDK_WaveWorks_Detailed_Simulation_Params& params, GFSDK_WaveWorks_CPU_Scheduler_Interface* pOptionalScheduler, ID3D11Device* pD3DDevice);
+	HRESULT initGnm(const GFSDK_WaveWorks_Detailed_Simulation_Params& params, GFSDK_WaveWorks_CPU_Scheduler_Interface* pOptionalScheduler);
+	HRESULT initGL2(const GFSDK_WaveWorks_Detailed_Simulation_Params& params, void* pGLContext);
+	HRESULT initNoGraphics(const GFSDK_WaveWorks_Detailed_Simulation_Params& params);
+    HRESULT reinit(const GFSDK_WaveWorks_Detailed_Simulation_Params& params);
+
+    void setSimulationTime(double dAppTime);
+	float getConservativeMaxDisplacementEstimate();
+	void updateRMS(const GFSDK_WaveWorks_Detailed_Simulation_Params& params);
+
+    HRESULT kick(gfsdk_U64* pKickID, Graphics_Context* pGC, GFSDK_WaveWorks_Savestate* pSavestateImpl);
+	HRESULT getStats(GFSDK_WaveWorks_Simulation_Stats& stats);
+
+	bool getStagingCursor(gfsdk_U64* pKickID);
+	HRESULT advanceStagingCursor(Graphics_Context* pGC, bool block, bool& wouldBlock, GFSDK_WaveWorks_Savestate* pSavestateImpl);
+	HRESULT waitStagingCursor();
+	bool getReadbackCursor(gfsdk_U64* pKickID);
+	HRESULT advanceReadbackCursor(bool block, bool& wouldBlock);
+
+	HRESULT archiveDisplacements();
+
+    HRESULT setRenderState(	Graphics_Context* pGC,
+							const gfsdk_float4x4& matView,
+							const UINT* pShaderInputRegisterMappings ,
+							GFSDK_WaveWorks_Savestate* pSavestateImpl,
+							const GFSDK_WaveWorks_Simulation_GL_Pool* pGlPool
+							);
+
+    HRESULT getDisplacements(	const gfsdk_float2* inSamplePoints,
+                                gfsdk_float4* outDisplacements,
+                                UINT numSamples
+                                );
+
+	HRESULT getArchivedDisplacements(	float coord,
+										const gfsdk_float2* inSamplePoints,
+										gfsdk_float4* outDisplacements,
+										UINT numSamples
+										);
+
+    static HRESULT getShaderInputCountD3D9();
+    static HRESULT getShaderInputDescD3D9(UINT inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc);
+    static HRESULT getShaderInputCountD3D10();
+    static HRESULT getShaderInputDescD3D10(UINT inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc);
+    static HRESULT getShaderInputCountD3D11();
+    static HRESULT getShaderInputDescD3D11(UINT inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc);
+    static HRESULT getShaderInputCountGnm();
+    static HRESULT getShaderInputDescGnm(UINT inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc);
+    static HRESULT getShaderInputCountGL2();
+	static HRESULT getTextureUnitCountGL2(gfsdk_bool useTextureArrays);
+    static HRESULT getShaderInputDescGL2(UINT inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc);
+
+private:
+
+    GFSDK_WaveWorks_Detailed_Simulation_Params m_params;
+
+    HRESULT updateGradientMaps(Graphics_Context* pGC, GFSDK_WaveWorks_Savestate* pSavestateImpl);
+    HRESULT updateGradientMapsD3D9(GFSDK_WaveWorks_Savestate* pSavestateImpl);
+    HRESULT updateGradientMapsD3D10(GFSDK_WaveWorks_Savestate* pSavestateImpl);
+	HRESULT updateGradientMapsD3D11(Graphics_Context* pGC, GFSDK_WaveWorks_Savestate* pSavestateImpl);
+	HRESULT updateGradientMapsGnm(Graphics_Context* pGC, GFSDK_WaveWorks_Savestate* pSavestateImpl);
+	HRESULT updateGradientMapsGL2(Graphics_Context* pGC);
+
+    HRESULT setRenderStateD3D9(	const gfsdk_float4x4& matView,
+								const UINT* pShaderInputRegisterMappings,
+								GFSDK_WaveWorks_Savestate* pSavestateImpl
+								);
+    HRESULT setRenderStateD3D10(	const gfsdk_float4x4& matView,
+									const UINT* pShaderInputRegisterMappings,
+									GFSDK_WaveWorks_Savestate* pSavestateImpl
+									);
+    HRESULT setRenderStateD3D11(	ID3D11DeviceContext* pDC,
+									const gfsdk_float4x4& matView,
+									const UINT* pShaderInputRegisterMappings,
+									GFSDK_WaveWorks_Savestate* pSavestateImpl
+									);
+	HRESULT setRenderStateGnm(		sce::Gnmx::LightweightGfxContext* gfxContext,
+									const gfsdk_float4x4& matView,
+									const UINT* pShaderInputRegisterMappings,
+									GFSDK_WaveWorks_Savestate* pSavestateImpl
+									);
+    HRESULT setRenderStateGL2(		const gfsdk_float4x4& matView,
+									const UINT* pShaderInputRegisterMappings,
+									const GFSDK_WaveWorks_Simulation_GL_Pool& glPool
+									);
+
+
+    // ---------------------------------- GPU simulation data --------------------------------
+
+    struct CascadeState
+    {
+		NVWaveWorks_Mesh* m_pQuadMesh;
+        NVWaveWorks_FFT_Simulation* m_pFFTSimulation;
+
+        // The kickID that originated the last update to this displacement map, allowing us to track when
+		// the map is out of date and needs another update...
+        gfsdk_U64 m_gradient_map_version;
+
+		// Set when the gradient map is newly created and therefore in need of an intitial clear
+		bool m_gradient_map_needs_clear[MaxNumGPUs];
+
+#if WAVEWORKS_ENABLE_D3D9
+        struct D3D9Objects
+        {
+            LPDIRECT3DTEXTURE9 m_pd3d9GradientMap[MaxNumGPUs];			// (ABGR16F) - round-robin, to avoid SLI-inteframe dependencies
+			LPDIRECT3DTEXTURE9 m_pd3d9FoamEnergyMap;					// (R16F)
+        };
+#endif
+
+#if WAVEWORKS_ENABLE_D3D10
+        struct D3D10Objects
+        {
+            ID3D10ShaderResourceView* m_pd3d10GradientMap[MaxNumGPUs];			// (ABGR16F) - round-robin, to avoid SLI-inteframe dependencies
+            ID3D10RenderTargetView*   m_pd3d10GradientRenderTarget[MaxNumGPUs];	// (ditto)
+            ID3D10ShaderResourceView* m_pd3d10FoamEnergyMap;		// (R16F)
+            ID3D10RenderTargetView*   m_pd3d10FoamEnergyRenderTarget;// (ditto)
+        };
+#endif
+
+#if WAVEWORKS_ENABLE_D3D11
+        struct D3D11Objects
+        {
+            ID3D11ShaderResourceView* m_pd3d11GradientMap[MaxNumGPUs];			// (ABGR16F) - round-robin, to avoid SLI-inteframe dependencies
+            ID3D11RenderTargetView*   m_pd3d11GradientRenderTarget[MaxNumGPUs];	// (ditto)
+            ID3D11ShaderResourceView* m_pd3d11FoamEnergyMap;		// (R16F)
+            ID3D11RenderTargetView*   m_pd3d11FoamEnergyRenderTarget;// (ditto)
+        };
+#endif
+
+#if WAVEWORKS_ENABLE_GNM
+		struct GnmObjects
+		{
+			sce::Gnm::Texture         m_gnmGradientMap[MaxNumGPUs];			// (ABGR16F) - round-robin, to avoid SLI-inteframe dependencies
+			sce::Gnm::RenderTarget    m_gnmGradientRenderTarget[MaxNumGPUs];	// (ditto)
+			sce::Gnm::Texture         m_gnmFoamEnergyMap;		// (R16F)
+			sce::Gnm::RenderTarget    m_gnmFoamEnergyRenderTarget;// (ditto)
+		};
+#endif
+#if WAVEWORKS_ENABLE_GL
+        struct GL2Objects
+        {
+            GLuint m_GL2GradientMap[MaxNumGPUs];			// (ABGR16F) - round-robin, to avoid SLI-inteframe dependencies
+            GLuint m_GL2GradientFBO[MaxNumGPUs];			// (ditto)
+            GLuint m_GL2FoamEnergyMap;					// (R16F)
+            GLuint m_GL2FoamEnergyFBO;					// (ditto)
+        };
+#endif
+		union
+        {
+#if WAVEWORKS_ENABLE_D3D9
+            D3D9Objects _9;
+#endif
+#if WAVEWORKS_ENABLE_D3D10
+            D3D10Objects _10;
+#endif
+#if WAVEWORKS_ENABLE_D3D11
+			D3D11Objects _11;
+#endif
+#if WAVEWORKS_ENABLE_GNM
+			GnmObjects _gnm;
+#endif
+#if WAVEWORKS_ENABLE_GL
+			GL2Objects _GL2;
+#endif
+		} m_d3d;
+
+    };
+
+    CascadeState cascade_states[GFSDK_WaveWorks_Detailed_Simulation_Params::MaxNumCascades];
+
+	// To preserve SLI scaling, we operate some resources that have inter-frame dependencies on a round-robin basis...
+    int m_num_GPU_slots;		// the number of GPU slots allocated for per-GPU resources (e.g. gradient maps)
+	int m_active_GPU_slot;		// the index of the active GPU within m_num_GPU_slots
+	void consumeGPUSlot();
+
+	float m_total_rms;
+
+    double m_dSimTime;
+	double m_dSimTimeFIFO[MaxNumGPUs+1];
+	int m_numValidEntriesInSimTimeFIFO;
+	double m_dFoamSimDeltaTime;
+
+	// Some kinds of simulation require a manager to hook simulation-level events
+	NVWaveWorks_FFT_Simulation_Manager* m_pSimulationManager;
+
+	// Scheduler to use for CPU work (optional)
+	GFSDK_WaveWorks_CPU_Scheduler_Interface* m_pOptionalScheduler;
+
+	// GFX timing services
+	NVWaveWorks_GFX_Timer_Impl* m_pGFXTimer;
+
+    // ---------------------------------- Rendering ------------------------------------
+
+    HRESULT initShaders();
+    HRESULT initGradMapSamplers();
+	HRESULT initTextureArrays();
+	HRESULT initQuadMesh(int mode);
+
+    // D3D API handling
+    nv_water_d3d_api m_d3dAPI;
+
+#if WAVEWORKS_ENABLE_D3D9
+    struct D3D9Objects
+    {
+        IDirect3DDevice9* m_pd3d9Device;
+
+        // Shaders for grad calc
+        IDirect3DVertexShader9* m_pd3d9GradCalcVS;
+        IDirect3DPixelShader9* m_pd3d9GradCalcPS;
+		// Shaders for foam generation
+        IDirect3DVertexShader9* m_pd3d9FoamGenVS;
+        IDirect3DPixelShader9* m_pd3d9FoamGenPS;
+    };
+#endif
+
+#if WAVEWORKS_ENABLE_D3D10
+    struct D3D10Objects
+    {
+        ID3D10Device* m_pd3d10Device;
+
+        // Shaders for grad calc
+        ID3D10VertexShader* m_pd3d10GradCalcVS;
+        ID3D10PixelShader* m_pd3d10GradCalcPS;
+        ID3D10Buffer* m_pd3d10GradCalcPixelShaderCB;
+        ID3D10SamplerState* m_pd3d10PointSampler;
+        ID3D10DepthStencilState* m_pd3d10NoDepthStencil;
+        ID3D10RasterizerState* m_pd3d10AlwaysSolidRasterizer;
+        ID3D10BlendState* m_pd3d10CalcGradBlendState;
+		ID3D10BlendState* m_pd3d10AccumulateFoamBlendState;
+		ID3D10BlendState* m_pd3d10WriteAccumulatedFoamBlendState;
+
+        // State for main rendering
+        ID3D10SamplerState* m_pd3d10LinearNoMipSampler;
+        ID3D10SamplerState* m_pd3d10GradMapSampler;
+        ID3D10Buffer*		m_pd3d10PixelShaderCB;
+        ID3D10Buffer*		m_pd3d10VertexShaderCB;
+
+		// Shaders for foam generation
+        ID3D10VertexShader* m_pd3d10FoamGenVS;
+        ID3D10PixelShader* m_pd3d10FoamGenPS;
+        ID3D10Buffer* m_pd3d10FoamGenPixelShaderCB;
+	};
+#endif
+
+#if WAVEWORKS_ENABLE_D3D11
+    struct D3D11Objects
+    {
+        ID3D11Device* m_pd3d11Device;
+
+        // Shaders for grad calc
+        ID3D11VertexShader* m_pd3d11GradCalcVS;
+        ID3D11PixelShader* m_pd3d11GradCalcPS;
+        ID3D11Buffer* m_pd3d11GradCalcPixelShaderCB;
+        ID3D11SamplerState* m_pd3d11PointSampler;
+        ID3D11DepthStencilState* m_pd3d11NoDepthStencil;
+        ID3D11RasterizerState* m_pd3d11AlwaysSolidRasterizer;
+        ID3D11BlendState* m_pd3d11CalcGradBlendState;
+		ID3D11BlendState* m_pd3d11AccumulateFoamBlendState;
+		ID3D11BlendState* m_pd3d11WriteAccumulatedFoamBlendState;
+
+        // State for main rendering
+        ID3D11SamplerState* m_pd3d11LinearNoMipSampler;
+        ID3D11SamplerState* m_pd3d11GradMapSampler;
+        ID3D11Buffer*		m_pd3d11PixelShaderCB;
+        ID3D11Buffer*		m_pd3d11VertexDomainShaderCB;
+
+        // Shaders for foam generation
+        ID3D11VertexShader* m_pd3d11FoamGenVS;
+        ID3D11PixelShader* m_pd3d11FoamGenPS;
+        ID3D11Buffer* m_pd3d11FoamGenPixelShaderCB;
+    };
+#endif
+
+#if WAVEWORKS_ENABLE_GNM
+	struct GnmObjects
+	{
+		// Shaders for grad calc
+		sce::Gnmx::VsShader* m_pGnmGradCalcVS;
+		sce::Gnmx::InputResourceOffsets* m_pGnmGradCalcVSResourceOffsets;
+		void* m_pGnmGradCalcFS;
+		sce::Gnmx::PsShader* m_pGnmGradCalcPS;
+		sce::Gnmx::InputResourceOffsets* m_pGnmGradCalcPSResourceOffsets;
+		sce::Gnm::Sampler m_pGnmPointSampler;
+		sce::Gnm::DepthStencilControl m_pGnmNoDepthStencil;
+		sce::Gnm::PrimitiveSetup m_pGnmAlwaysSolidRasterizer;
+		sce::Gnm::BlendControl m_pGnmCalcGradBlendState;
+		sce::Gnm::BlendControl m_pGnmAccumulateFoamBlendState;
+		sce::Gnm::BlendControl m_pGnmWriteAccumulatedFoamBlendState;
+
+		// State for main rendering
+		sce::Gnm::Sampler m_pGnmLinearNoMipSampler;
+		sce::Gnm::Sampler m_pGnmGradMapSampler;
+		sce::Gnm::Buffer m_pGnmPixelShaderCB;
+		sce::Gnm::Buffer m_pGnmVertexDomainShaderCB;
+
+		// Shaders for foam generation
+		sce::Gnmx::VsShader* m_pGnmFoamGenVS;
+		sce::Gnmx::InputResourceOffsets* m_pGnmFoamGenVSResourceOffsets;
+		void* m_pGnmFoamGenFS;
+		sce::Gnmx::PsShader* m_pGnmFoamGenPS;
+		sce::Gnmx::InputResourceOffsets* m_pGnmFoamGenPSResourceOffsets;
+
+		sce::Gnmx::CsShader* m_pGnmMipMapGenCS;
+		sce::Gnmx::InputResourceOffsets* m_pGnmMipMapGenCSResourceOffsets;
+		GFSDK_WaveWorks_GNM_Util::RenderTargetClearer* m_pGnmRenderTargetClearer;
+	};
+#endif
+#if WAVEWORKS_ENABLE_GL
+    struct GL2Objects
+    {
+        void* m_pGLContext;
+
+        // Shaders for grad calc
+		GLuint m_GradCalcProgram;
+		// Uniform binding points for grad calc shader
+		GLuint m_GradCalcUniformLocation_Scales;
+		GLuint m_GradCalcUniformLocation_OneLeft;
+		GLuint m_GradCalcUniformLocation_OneRight;
+		GLuint m_GradCalcUniformLocation_OneBack;
+		GLuint m_GradCalcUniformLocation_OneFront;
+		GLuint m_GradCalcTextureBindLocation_DisplacementMap;
+		GLuint m_GradCalcTextureUnit_DisplacementMap;
+		// Vertex attribute locations
+		GLuint m_GradCalcAttributeLocation_Pos;
+		GLuint m_GradCalcAttributeLocation_TexCoord;
+
+        // Shaders for foam generation
+		GLuint m_FoamGenProgram;
+		// Uniform binding points for foam generation shader
+		GLuint m_FoamGenUniformLocation_DissipationFactors;
+		GLuint m_FoamGenUniformLocation_SourceComponents;
+		GLuint m_FoamGenUniformLocation_UVOffsets;
+		GLuint m_FoamGenTextureBindLocation_EnergyMap;
+		GLuint m_FoamGenTextureUnit_EnergyMap;
+		// Vertex attribute locations
+		GLuint m_FoamGenAttributeLocation_Pos;
+		GLuint m_FoamGenAttributeLocation_TexCoord;
+
+		// Texture arrays & FBO needed to blit to those
+		GLuint m_DisplacementsTextureArray;
+		GLuint m_GradientsTextureArray;
+		GLuint m_TextureArraysBlittingReadFBO;
+		GLuint m_TextureArraysBlittingDrawFBO;
+    };
+#endif
+	union
+    {
+#if WAVEWORKS_ENABLE_D3D9
+        D3D9Objects _9;
+#endif
+#if WAVEWORKS_ENABLE_D3D10
+        D3D10Objects _10;
+#endif
+#if WAVEWORKS_ENABLE_D3D11
+		D3D11Objects _11;
+#endif
+#if WAVEWORKS_ENABLE_GNM
+		GnmObjects _gnm;
+#endif
+#if WAVEWORKS_ENABLE_GL
+		GL2Objects _GL2;
+#endif
+    } m_d3d;
+
+    HRESULT allocateAll();
+    void releaseAll();
+
+    void releaseRenderingResources(int mode);
+    HRESULT allocateRenderingResources(int mode);
+
+    void releaseSimulation(int mode);
+    HRESULT allocateSimulation(int mode);
+
+	void releaseSimulationManager();
+	HRESULT allocateSimulationManager();
+
+	void releaseGFXTimer();
+	HRESULT allocateGFXTimer();
+
+	// Timer query ring-buffer
+	struct TimerSlot
+	{
+		int m_DisjointQueryIndex;
+		int m_StartQueryIndex;
+		int m_StopQueryIndex;
+		int m_StartGFXQueryIndex;
+		int m_StopGFXQueryIndex;
+		float m_elapsed_time;			// in milli-seconds, as per house style
+		float m_elapsed_gfx_time;		// in milli-seconds, as per house style
+	};
+
+	struct TimerPool
+	{
+		enum { NumTimerSlots = 4 };			// 2 in-flight, one usable, one active
+		int m_active_timer_slot;			// i.e. not in-flight
+		int m_end_inflight_timer_slots;		// the first in-flight slot is always the one after active
+		TimerSlot m_timer_slots[NumTimerSlots];
+
+		void reset();
+	};
+
+	TimerPool m_gpu_kick_timers;
+	TimerPool m_gpu_wait_timers;
+
+	bool m_has_consumed_wait_timer_slot_since_last_kick;
+
+	HRESULT consumeAvailableTimerSlot(Graphics_Context* pGC, NVWaveWorks_GFX_Timer_Impl* pGFXTimer, TimerPool& pool, TimerSlot** ppSlot);
+	HRESULT queryTimers(Graphics_Context* pGC, NVWaveWorks_GFX_Timer_Impl* pGFXTimer, TimerPool& pool);
+	HRESULT queryAllGfxTimers(Graphics_Context* pGC, NVWaveWorks_GFX_Timer_Impl* pGFXTimer);
+
+	GLuint compileGLShader(const char *text, GLenum type);
+	GLuint loadGLProgram(const char* vstext, const char* tetext, const char* tctext,  const char* gstext, const char* fstext);
+};
+
+#endif	// _NVWAVEWORKS_SIMULATION_IMPL_H