Excised D3D9 and 10 support from library.

23 files changed, 8 insertions, 5027 deletions

diff --git a/include/GFSDK_WaveWorks.h b/include/GFSDK_WaveWorks.h
index eaf26ab..935c2e6 100644
--- a/include/GFSDK_WaveWorks.h
+++ b/include/GFSDK_WaveWorks.h
@@ -94,10 +94,6 @@ GFSDK_WAVEWORKS_DECL(gfsdk_cstr) GFSDK_WaveWorks_GetBuildString();
 // Use these calls to globally initialize/release on D3D device create/destroy.
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_InitNoGraphics(const GFSDK_WaveWorks_Malloc_Hooks* pOptionalMallocHooks, const GFSDK_WaveWorks_API_GUID& apiGUID);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_ReleaseNoGraphics();
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_InitD3D9(IDirect3DDevice9* pD3DDevice, const GFSDK_WaveWorks_Malloc_Hooks* pOptionalMallocHooks, const GFSDK_WaveWorks_API_GUID& apiGUID);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_ReleaseD3D9(IDirect3DDevice9* pD3DDevice);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_InitD3D10(ID3D10Device* pD3DDevice, const GFSDK_WaveWorks_Malloc_Hooks* pOptionalMallocHooks, const GFSDK_WaveWorks_API_GUID& apiGUID);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_ReleaseD3D10(ID3D10Device* pD3DDevice);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_InitD3D11(ID3D11Device* pD3DDevice, const GFSDK_WaveWorks_Malloc_Hooks* pOptionalMallocHooks, const GFSDK_WaveWorks_API_GUID& apiGUID);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_ReleaseD3D11(ID3D11Device* pD3DDevice);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_InitGL2(const GFSDK_WAVEWORKS_GLFunctions* pGLFuncs, const GFSDK_WaveWorks_Malloc_Hooks* pOptionalMallocHooks, const GFSDK_WaveWorks_API_GUID& apiGUID);
@@ -113,11 +109,7 @@ GFSDK_WAVEWORKS_DECL(gfsdk_bool) GFSDK_WaveWorks_GLAttribIsShaderInput(gfsdk_cst
 
 // In order to preserve D3D state across certain calls, create a save-state object, pass it to the call
 // and then once the call is done, use it to restore the previous D3D state
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_Savestate_CreateD3D9(GFSDK_WaveWorks_StatePreserveFlags PreserveFlags, IDirect3DDevice9* pD3DDevice, GFSDK_WaveWorks_SavestateHandle* pResult);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_Savestate_CreateD3D10(GFSDK_WaveWorks_StatePreserveFlags PreserveFlags, ID3D10Device* pD3DDevice, GFSDK_WaveWorks_SavestateHandle* pResult);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_Savestate_CreateD3D11(GFSDK_WaveWorks_StatePreserveFlags PreserveFlags, ID3D11Device* pD3DDevice, GFSDK_WaveWorks_SavestateHandle* pResult);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_Savestate_RestoreD3D9(GFSDK_WaveWorks_SavestateHandle hSavestate);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_Savestate_RestoreD3D10(GFSDK_WaveWorks_SavestateHandle hSavestate);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_Savestate_RestoreD3D11(GFSDK_WaveWorks_SavestateHandle hSavestate, ID3D11DeviceContext* pDC);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result) GFSDK_WaveWorks_Savestate_Destroy(GFSDK_WaveWorks_SavestateHandle hSavestate);
 
@@ -239,15 +231,11 @@ struct GFSDK_WaveWorks_Simulation_GL_Pool
 // These functions can be used to check whether a particular graphics device supports a particular detail level,
 // *before* initialising the graphics device
 GFSDK_WAVEWORKS_DECL(gfsdk_bool) GFSDK_WaveWorks_Simulation_DetailLevelIsSupported_NoGraphics(GFSDK_WaveWorks_Simulation_DetailLevel detailLevel);
-GFSDK_WAVEWORKS_DECL(gfsdk_bool) GFSDK_WaveWorks_Simulation_DetailLevelIsSupported_D3D9(IDirect3D9* pD3D9, const _D3DADAPTER_IDENTIFIER9& adapterIdentifier, GFSDK_WaveWorks_Simulation_DetailLevel detailLevel);
-GFSDK_WAVEWORKS_DECL(gfsdk_bool) GFSDK_WaveWorks_Simulation_DetailLevelIsSupported_D3D10(IDXGIAdapter* adapter, GFSDK_WaveWorks_Simulation_DetailLevel detailLevel);
 GFSDK_WAVEWORKS_DECL(gfsdk_bool) GFSDK_WaveWorks_Simulation_DetailLevelIsSupported_D3D11(IDXGIAdapter* adapter, GFSDK_WaveWorks_Simulation_DetailLevel detailLevel);
 GFSDK_WAVEWORKS_DECL(gfsdk_bool) GFSDK_WaveWorks_Simulation_DetailLevelIsSupported_GL2(GFSDK_WaveWorks_Simulation_DetailLevel detailLevel);
 
 // Simulation lifetime management
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_CreateNoGraphics(const GFSDK_WaveWorks_Simulation_Settings& settings, const GFSDK_WaveWorks_Simulation_Params& params, GFSDK_WaveWorks_SimulationHandle* pResult);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_CreateD3D9(const GFSDK_WaveWorks_Simulation_Settings& settings, const GFSDK_WaveWorks_Simulation_Params& params, IDirect3DDevice9* pD3DDevice, GFSDK_WaveWorks_SimulationHandle* pResult);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_CreateD3D10(const GFSDK_WaveWorks_Simulation_Settings& settings, const GFSDK_WaveWorks_Simulation_Params& params, ID3D10Device* pD3DDevice, GFSDK_WaveWorks_SimulationHandle* pResult);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_CreateD3D11(const GFSDK_WaveWorks_Simulation_Settings& settings, const GFSDK_WaveWorks_Simulation_Params& params, ID3D11Device* pD3DDevice, GFSDK_WaveWorks_SimulationHandle* pResult);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_CreateGL2(const GFSDK_WaveWorks_Simulation_Settings& settings, const GFSDK_WaveWorks_Simulation_Params& params, void *pGLContext, GFSDK_WaveWorks_SimulationHandle* pResult);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_Destroy(GFSDK_WaveWorks_SimulationHandle hSim);
@@ -266,10 +254,6 @@ GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_SetT
 // Retrieve information about the WaveWorks shader inputs for a given platform. This information can be used to
 // query compiled shaders via a reflection interface to obtain register or constant buffer indices for subsequent
 // calls to SetRenderState
-GFSDK_WAVEWORKS_DECL(gfsdk_U32                 ) GFSDK_WaveWorks_Simulation_GetShaderInputCountD3D9();
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_GetShaderInputDescD3D9(gfsdk_U32 inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc);
-GFSDK_WAVEWORKS_DECL(gfsdk_U32                 ) GFSDK_WaveWorks_Simulation_GetShaderInputCountD3D10();
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_GetShaderInputDescD3D10(gfsdk_U32 inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc);
 GFSDK_WAVEWORKS_DECL(gfsdk_U32                 ) GFSDK_WaveWorks_Simulation_GetShaderInputCountD3D11();
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_GetShaderInputDescD3D11(gfsdk_U32 inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc);
 GFSDK_WAVEWORKS_DECL(gfsdk_U32                 ) GFSDK_WaveWorks_Simulation_GetShaderInputCountGL2();
@@ -280,8 +264,6 @@ GFSDK_WAVEWORKS_DECL(gfsdk_U32                 ) GFSDK_WaveWorks_Simulation_GetT
 
 // Set WaveWorks shader inputs ready for rendering - use GetStagingCursor() to identify the kick which produced the simulation
 // results that are about to be set
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_SetRenderStateD3D9(GFSDK_WaveWorks_SimulationHandle hSim, const gfsdk_float4x4& matView, const gfsdk_U32 * pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_SetRenderStateD3D10(GFSDK_WaveWorks_SimulationHandle hSim, const gfsdk_float4x4& matView, const gfsdk_U32 * pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_SetRenderStateD3D11(GFSDK_WaveWorks_SimulationHandle hSim, ID3D11DeviceContext* pDC, const gfsdk_float4x4& matView, const gfsdk_U32 * pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_SetRenderStateGL2(GFSDK_WaveWorks_SimulationHandle hSim, const gfsdk_float4x4& matView, const gfsdk_U32 * pShaderInputRegisterMappings, const GFSDK_WaveWorks_Simulation_GL_Pool& glPool);
 
@@ -302,8 +284,6 @@ GFSDK_WAVEWORKS_DECL(gfsdk_F32                 ) GFSDK_WaveWorks_Simulation_GetC
 // If necessary, this call will block until the CPU part of the pipeline is able to accept further in-flight work. If the CPU part of the pipeline
 // is already completely full, this means waiting for an in-flight kick to exit the CPU pipeline (kicks are processed in FIFO order)
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_KickNoGraphics(GFSDK_WaveWorks_SimulationHandle hSim, gfsdk_U64* pKickID);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_KickD3D9(GFSDK_WaveWorks_SimulationHandle hSim, gfsdk_U64* pKickID, GFSDK_WaveWorks_SavestateHandle hSavestate);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_KickD3D10(GFSDK_WaveWorks_SimulationHandle hSim, gfsdk_U64* pKickID, GFSDK_WaveWorks_SavestateHandle hSavestate);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_KickD3D11(GFSDK_WaveWorks_SimulationHandle hSim, gfsdk_U64* pKickID, ID3D11DeviceContext* pDC, GFSDK_WaveWorks_SavestateHandle hSavestate);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_KickGL2(GFSDK_WaveWorks_SimulationHandle hSim, gfsdk_U64* pKickID);
 
@@ -318,8 +298,6 @@ GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_GetS
 // Returns gfsdk_waveworks_result_NONE if there are no in-flight kicks in the CPU part of the simulation pipeline
 // Returns gfsdk_waveworks_result_WOULD_BLOCK if there are in-flight kicks in the CPU part of the pipeline, but they're not ready for staging
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_AdvanceStagingCursorNoGraphics(GFSDK_WaveWorks_SimulationHandle hSim, bool block);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_AdvanceStagingCursorD3D9(GFSDK_WaveWorks_SimulationHandle hSim, bool block, GFSDK_WaveWorks_SavestateHandle hSavestate);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_AdvanceStagingCursorD3D10(GFSDK_WaveWorks_SimulationHandle hSim, bool block, GFSDK_WaveWorks_SavestateHandle hSavestate);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_AdvanceStagingCursorD3D11(GFSDK_WaveWorks_SimulationHandle hSim, bool block, ID3D11DeviceContext* pDC, GFSDK_WaveWorks_SavestateHandle hSavestate);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result    ) GFSDK_WaveWorks_Simulation_AdvanceStagingCursorGL2(GFSDK_WaveWorks_SimulationHandle hSim, bool block);
 
@@ -391,8 +369,6 @@ struct GFSDK_WaveWorks_Quadtree_Stats
 };
 
 // Quadtree lifetime management
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_CreateD3D9(const GFSDK_WaveWorks_Quadtree_Params& params, IDirect3DDevice9* pD3DDevice, GFSDK_WaveWorks_QuadtreeHandle* pResult);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_CreateD3D10(const GFSDK_WaveWorks_Quadtree_Params& params, ID3D10Device* pD3DDevice, GFSDK_WaveWorks_QuadtreeHandle* pResult);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_CreateD3D11(const GFSDK_WaveWorks_Quadtree_Params& params, ID3D11Device* pD3DDevice, GFSDK_WaveWorks_QuadtreeHandle* pResult);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_CreateGL2(const GFSDK_WaveWorks_Quadtree_Params& params, unsigned int Program, GFSDK_WaveWorks_QuadtreeHandle* pResult);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_Destroy(GFSDK_WaveWorks_QuadtreeHandle hQuadtree);
@@ -403,10 +379,6 @@ GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_UpdateP
 // Retrieve information about the WaveWorks shader inputs for a given platform. This information can be used to
 // query compiled shaders via a reflection interface to obtain register or constant buffer indices for subsequent
 // calls to Draw
-GFSDK_WAVEWORKS_DECL(gfsdk_U32                ) GFSDK_WaveWorks_Quadtree_GetShaderInputCountD3D9();
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_GetShaderInputDescD3D9(gfsdk_U32 inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc);
-GFSDK_WAVEWORKS_DECL(gfsdk_U32                ) GFSDK_WaveWorks_Quadtree_GetShaderInputCountD3D10();
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_GetShaderInputDescD3D10(gfsdk_U32 inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc);
 GFSDK_WAVEWORKS_DECL(gfsdk_U32                ) GFSDK_WaveWorks_Quadtree_GetShaderInputCountD3D11();
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_GetShaderInputDescD3D11(gfsdk_U32 inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc);
 GFSDK_WAVEWORKS_DECL(gfsdk_U32                ) GFSDK_WaveWorks_Quadtree_GetShaderInputCountGL2();
@@ -420,8 +392,6 @@ GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_AllocPa
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_FreePatch(GFSDK_WaveWorks_QuadtreeHandle hQuadtree, gfsdk_S32 x, gfsdk_S32 y, gfsdk_U32 lod);
 
 // Draw the water surface using the specified quadtree with the specified view and projection matrices
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_DrawD3D9(GFSDK_WaveWorks_QuadtreeHandle hQuadtree, const gfsdk_float4x4& matView, const gfsdk_float4x4& matProj, const gfsdk_U32 * pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate);
-GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_DrawD3D10(GFSDK_WaveWorks_QuadtreeHandle hQuadtree, const gfsdk_float4x4& matView, const gfsdk_float4x4& matProj, const gfsdk_U32 * pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_DrawD3D11(GFSDK_WaveWorks_QuadtreeHandle hQuadtree, ID3D11DeviceContext* pDC, const gfsdk_float4x4& matView, const gfsdk_float4x4& matProj, const gfsdk_U32 * pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate);
 GFSDK_WAVEWORKS_DECL(gfsdk_waveworks_result   ) GFSDK_WaveWorks_Quadtree_DrawGL2(GFSDK_WaveWorks_QuadtreeHandle hQuadtree, const gfsdk_float4x4& matView, const gfsdk_float4x4& matProj, const gfsdk_U32 * pShaderInputRegisterMappings);
 
diff --git a/src/Entrypoints.cpp b/src/Entrypoints.cpp
index 996fe55..cfd1d10 100644
--- a/src/Entrypoints.cpp
+++ b/src/Entrypoints.cpp
@@ -463,96 +463,6 @@ gfsdk_bool GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_GLAttribIsShaderInput(gfsdk
 	CUSTOM_ENTRYPOINT_END(false)
 }
 
-gfsdk_bool GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_DetailLevelIsSupported_D3D9(IDirect3D9* D3D9_ONLY(pD3D9), const _D3DADAPTER_IDENTIFIER9& D3D9_ONLY(adapterIdentifier), GFSDK_WaveWorks_Simulation_DetailLevel D3D9_ONLY(detailLevel))
-{
-#if WAVEWORKS_ENABLE_D3D9
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-
-	const nv_water_simulation_api simulationAPI = ToAPI(detailLevel);
-	switch(simulationAPI) {
-		case nv_water_simulation_api_cuda:
-			{
-			#ifdef SUPPORT_CUDA
-
-				// Only support CUDA on D3D9Ex. 2 reasons -
-				//  - SLI interop is super-flakey on plain old D3D9
-				//  - CUDA/D3D9 interop is deprecated (but CUDA/D3D9Ex is not), so we should prepare...
-				IDirect3D9Ex* pD3D9Ex = NULL;
-				HRESULT hr = pD3D9->QueryInterface(IID_IDirect3D9Ex, (void**)&pD3D9Ex);
-				if(FAILED(hr))
-				{
-					// Not D3D9Ex, so deny CUDA
-					return false;
-				}
-				SAFE_RELEASE(pD3D9Ex);
-
-				// Now check for double-precision support
-				int device;
-				cudaD3D9GetDevice(&device, adapterIdentifier.DeviceName);
-				if (cudaGetLastError() != cudaSuccess)
-					return false;
-				else
-					return cudaDeviceSupportsDoublePrecision(device);
-			#else
-				return false;
-			#endif
-			}
-		case nv_water_simulation_api_cpu:
-			{
-			#ifdef SUPPORT_FFTCPU
-				return true;
-			#else
-				return false;
-			#endif
-			}
-		default:
-			return false;
-	}
-
-	CUSTOM_ENTRYPOINT_END(false)
-#else
-	return false;
-#endif
-}
-
-gfsdk_bool GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_DetailLevelIsSupported_D3D10(IDXGIAdapter* D3D10_ONLY(adapter), GFSDK_WaveWorks_Simulation_DetailLevel D3D10_ONLY(detailLevel))
-{
-#if WAVEWORKS_ENABLE_D3D10
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-
-	const nv_water_simulation_api simulationAPI = ToAPI(detailLevel);
-	switch(simulationAPI) {
-		case nv_water_simulation_api_cuda:
-			{
-			#ifdef SUPPORT_CUDA
-				int device;
-				cudaD3D10GetDevice(&device, adapter);
-				if (cudaGetLastError() != cudaSuccess)
-					return false;
-				else
-					return cudaDeviceSupportsDoublePrecision(device);
-			#else
-				return false;
-			#endif
-			}
-		case nv_water_simulation_api_cpu:
-			{
-			#ifdef SUPPORT_FFTCPU
-				return true;
-			#else
-				return false;
-			#endif
-			}
-		default:
-			return false;
-	}
-
-	CUSTOM_ENTRYPOINT_END(false)
-#else
-	return false;
-#endif
-}
-
 gfsdk_bool GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_DetailLevelIsSupported_D3D11(IDXGIAdapter* WIN_ONLY(D3D11_ONLY(adapter)), GFSDK_WaveWorks_Simulation_DetailLevel D3D11_ONLY(detailLevel))
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -702,142 +612,6 @@ gfsdk_bool GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_DetailLevelIsSup
 #endif
 }
 
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_InitD3D9(IDirect3DDevice9* D3D9_ONLY(pD3DDevice), const GFSDK_WaveWorks_Malloc_Hooks* D3D9_ONLY(pRequiredMallocHooks), const GFSDK_WaveWorks_API_GUID& D3D9_ONLY(apiGUID)){
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-
-#if WAVEWORKS_ENABLE_D3D9
-	if(g_InitialisedAPI != nv_water_d3d_api_undefined) {
-		WaveWorks_Internal::diagnostic_message(TEXT("ERROR: ") __DEF_FUNCTION__ TEXT(" was called with the library already in an initialised state\n"));
-		return gfsdk_waveworks_result_FAIL;
-	}
-
-	if(!equal(apiGUID,GFSDK_WAVEWORKS_API_GUID)) {
-		WaveWorks_Internal::diagnostic_message(TEXT("ERROR: ") __DEF_FUNCTION__ TEXT(" was called with an invalid API GUID\n"));
-		return gfsdk_waveworks_result_FAIL;
-	}
-
-	if(pRequiredMallocHooks) {
-		const gfsdk_waveworks_result smmcResult = SetMemoryManagementCallbacks(*pRequiredMallocHooks);
-		if(smmcResult != gfsdk_waveworks_result_OK)
-			return smmcResult;
-	}
-
-#if defined(SUPPORT_CUDA)
-	// Only support CUDA on D3D9Ex device. 2 reasons -
-	//  - SLI interop is super-flakey on plain old D3D9
-	//  - CUDA/D3D9 interop is deprecated (but CUDA/D3D9Ex is not), so we should prepare...
-	IDirect3DDevice9Ex* pD3D9ExDevice = NULL;
-	HRESULT hr = pD3DDevice->QueryInterface(IID_IDirect3DDevice9Ex, (void**)&pD3D9ExDevice);
-	if(FAILED(hr))
-	{
-		g_InitialisedAPI = nv_water_d3d_api_d3d9;
-		g_CanUseCUDA = false;
-		return gfsdk_waveworks_result_OK;	// This is legit, it just means we can't support CUDA
-	}
-	SAFE_RELEASE(pD3D9ExDevice);
-
-	// Associate all Cuda devices with the D3D9 device
-	unsigned int numCudaDevices = 0;
-	cudaError cu_err = cudaD3D9GetDevices(&numCudaDevices, NULL, 0, pD3DDevice, cudaD3D9DeviceListAll);
-	if(cudaSuccess != cu_err)
-	{
-		// This is our first meaningful call to CUDA, so treat CUDA as unavailable if it fails for any reason
-		g_InitialisedAPI = nv_water_d3d_api_d3d9;
-		g_CanUseCUDA = false;
-		return gfsdk_waveworks_result_OK;
-	}
-
-	int* pCudaDevices = (int*)_alloca(numCudaDevices * sizeof(int));
-	CUDA_API_RETURN(cudaD3D9GetDevices(&numCudaDevices, pCudaDevices, numCudaDevices, pD3DDevice, cudaD3D9DeviceListAll));
-	g_CanUseCUDA = numCudaDevices > 0;
-	for(unsigned int cuda_dev_index = 0; cuda_dev_index != numCudaDevices; ++cuda_dev_index)
-	{
-		if(!cudaDeviceSupportsDoublePrecision(pCudaDevices[cuda_dev_index])) {
-			// We can't use a CUDA device that does not have double-precision support
-			g_CanUseCUDA = false;
-		}
-		CUDA_API_RETURN(cudaD3D9SetDirect3DDevice(pD3DDevice, pCudaDevices[cuda_dev_index]));
-	}
-
-	int currentFrameCudaDevice = 0;
-	CUDA_API_RETURN(cudaD3D9GetDevices(&numCudaDevices, &currentFrameCudaDevice, 1, pD3DDevice, cudaD3D9DeviceListCurrentFrame));
-	CUDA_API_RETURN(cudaSetDevice(currentFrameCudaDevice));
-
-#else
-	g_CanUseCUDA = false;
-#endif
-	g_InitialisedAPI = nv_water_d3d_api_d3d9;
-	return gfsdk_waveworks_result_OK;
-
-#else
-	return gfsdk_waveworks_result_FAIL;
-#endif
-
-	ENTRYPOINT_END
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_InitD3D10(ID3D10Device* D3D10_ONLY(pD3DDevice), const GFSDK_WaveWorks_Malloc_Hooks* D3D10_ONLY(pRequiredMallocHooks), const GFSDK_WaveWorks_API_GUID& D3D10_ONLY(apiGUID))
-{
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-
-#if WAVEWORKS_ENABLE_D3D10
-	if(g_InitialisedAPI != nv_water_d3d_api_undefined) {
-		WaveWorks_Internal::diagnostic_message(TEXT("ERROR: ") __DEF_FUNCTION__ TEXT(" was called with the library already in an initialised state\n"));
-		return gfsdk_waveworks_result_FAIL;
-	}
-
-	if(!equal(apiGUID,GFSDK_WAVEWORKS_API_GUID)) {
-		WaveWorks_Internal::diagnostic_message(TEXT("ERROR: ") __DEF_FUNCTION__ TEXT(" was called with an invalid API GUID\n"));
-		return gfsdk_waveworks_result_FAIL;
-	}
-
-	if(pRequiredMallocHooks) {
-		const gfsdk_waveworks_result smmcResult = SetMemoryManagementCallbacks(*pRequiredMallocHooks);
-		if(smmcResult != gfsdk_waveworks_result_OK)
-			return smmcResult;
-	}
-
-#if defined(SUPPORT_CUDA)
-	// Associate all Cuda devices with the D3D10 device
-	unsigned int numCudaDevices = 0;
-	cudaError cu_err = cudaD3D10GetDevices(&numCudaDevices, NULL, 0, pD3DDevice, cudaD3D10DeviceListAll);
-	if(cudaSuccess != cu_err)
-	{
-		// This is our first meaningful call to CUDA, so treat CUDA as unavailable if it fails for any reason
-		g_InitialisedAPI = nv_water_d3d_api_d3d10;
-		g_CanUseCUDA = false;
-		return gfsdk_waveworks_result_OK;
-	}
-
-	int* pCudaDevices = (int*)_alloca(numCudaDevices * sizeof(int));
-	CUDA_API_RETURN(cudaD3D10GetDevices(&numCudaDevices, pCudaDevices, numCudaDevices, pD3DDevice, cudaD3D10DeviceListAll));
-	g_CanUseCUDA = numCudaDevices > 0;
-	for(unsigned int cuda_dev_index = 0; cuda_dev_index != numCudaDevices; ++cuda_dev_index)
-	{
-		if(!cudaDeviceSupportsDoublePrecision(pCudaDevices[cuda_dev_index])) {
-			// We can't use a CUDA device that does not have double-precision support
-			g_CanUseCUDA = false;
-		}
-		CUDA_API_RETURN(cudaD3D10SetDirect3DDevice(pD3DDevice, pCudaDevices[cuda_dev_index]));
-	}
-
-	int currentFrameCudaDevice = 0;
-	CUDA_API_RETURN(cudaD3D10GetDevices(&numCudaDevices, &currentFrameCudaDevice, 1, pD3DDevice, cudaD3D10DeviceListCurrentFrame));
-	CUDA_API_RETURN(cudaSetDevice(currentFrameCudaDevice));
-
-#else
-	g_CanUseCUDA = false;
-#endif
-	g_InitialisedAPI = nv_water_d3d_api_d3d10;
-	return gfsdk_waveworks_result_OK;
-
-#else
-	return gfsdk_waveworks_result_FAIL;
-#endif
-
-	ENTRYPOINT_END
-}
-
 gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_InitD3D11(ID3D11Device* CUDA_ONLY(pD3DDevice), const GFSDK_WaveWorks_Malloc_Hooks* pRequiredMallocHooks, const GFSDK_WaveWorks_API_GUID& apiGUID)
 {
 	ENTRYPOINT_BEGIN_NO_INIT_CHECK
@@ -1001,74 +775,6 @@ gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_InitGL2(const G
 	ENTRYPOINT_END
 }
 
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_ReleaseD3D9(IDirect3DDevice9* D3D9_ONLY(pD3DDevice))
-{
-	ENTRYPOINT_BEGIN_API(d3d9)
-
-	resetMemoryManagementCallbacksToDefaults();
-
-	g_CanUseCUDA = false;
-
-#if defined(SUPPORT_CUDA) && WAVEWORKS_ENABLE_D3D9
-	unsigned int numCudaDevices = 0;
-	cudaError cu_err = cudaD3D9GetDevices(&numCudaDevices, NULL, 0, pD3DDevice, cudaD3D9DeviceListAll);
-	if(cudaErrorNoDevice == cu_err)
-	{
-		g_InitialisedAPI = nv_water_d3d_api_undefined;
-		return gfsdk_waveworks_result_OK;	// Legit on systems that do not support CUDA - nothing to do here
-	}
-	else
-		CUDA_API_RETURN(cu_err);
-
-	int* pCudaDevices = (int*)_alloca(numCudaDevices * sizeof(int));
-	CUDA_API_RETURN(cudaD3D9GetDevices(&numCudaDevices, pCudaDevices, numCudaDevices, pD3DDevice, cudaD3D9DeviceListAll));
-	for(unsigned int cuda_dev_index = 0; cuda_dev_index != numCudaDevices; ++cuda_dev_index)
-	{
-		CUDA_API_RETURN(cudaSetDevice(pCudaDevices[cuda_dev_index]));
-		cudaDeviceReset();
-	}
-#endif
-
-	g_InitialisedAPI = nv_water_d3d_api_undefined;
-	return gfsdk_waveworks_result_OK;
-
-	ENTRYPOINT_END
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_ReleaseD3D10(ID3D10Device* D3D10_ONLY(pD3DDevice))
-{
-	ENTRYPOINT_BEGIN_API(d3d10)
-
-	resetMemoryManagementCallbacksToDefaults();
-
-	g_CanUseCUDA = false;
-
-#if defined(SUPPORT_CUDA) && WAVEWORKS_ENABLE_D3D10
-	unsigned int numCudaDevices = 0;
-	cudaError cu_err = cudaD3D10GetDevices(&numCudaDevices, NULL, 0, pD3DDevice, cudaD3D10DeviceListAll);
-	if(cudaErrorNoDevice == cu_err)
-	{
-		g_InitialisedAPI = nv_water_d3d_api_undefined;
-		return gfsdk_waveworks_result_OK;	// Legit on systems that do not support CUDA - nothing to do here
-	}
-	else
-		CUDA_API_RETURN(cu_err);
-
-	int* pCudaDevices = (int*)_alloca(numCudaDevices * sizeof(int));
-	CUDA_API_RETURN(cudaD3D10GetDevices(&numCudaDevices, pCudaDevices, numCudaDevices, pD3DDevice, cudaD3D10DeviceListAll));
-	for(unsigned int cuda_dev_index = 0; cuda_dev_index != numCudaDevices; ++cuda_dev_index)
-	{
-		CUDA_API_RETURN(cudaSetDevice(pCudaDevices[cuda_dev_index]));
-		cudaDeviceReset();
-	}
-#endif
-
-	g_InitialisedAPI = nv_water_d3d_api_undefined;
-	return gfsdk_waveworks_result_OK;
-
-	ENTRYPOINT_END
-}
-
 gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_ReleaseD3D11(ID3D11Device* CUDA_ONLY(pD3DDevice))
 {
 	ENTRYPOINT_BEGIN_API(d3d11)
@@ -1256,23 +962,6 @@ namespace
     }
 }
 
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Savestate_CreateD3D9(GFSDK_WaveWorks_StatePreserveFlags PreserveFlags, IDirect3DDevice9* pD3DDevice, GFSDK_WaveWorks_SavestateHandle* pResult)
-{
-	ENTRYPOINT_BEGIN_API(d3d9)
-    GFSDK_WaveWorks_Savestate* pImpl = new GFSDK_WaveWorks_Savestate(pD3DDevice, PreserveFlags);
-    *pResult = ToHandle(pImpl);
-    return gfsdk_waveworks_result_OK;
-	ENTRYPOINT_END
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Savestate_CreateD3D10(GFSDK_WaveWorks_StatePreserveFlags PreserveFlags, ID3D10Device* pD3DDevice, GFSDK_WaveWorks_SavestateHandle* pResult)
-{
-	ENTRYPOINT_BEGIN_API(d3d10)
-    GFSDK_WaveWorks_Savestate* pImpl = new GFSDK_WaveWorks_Savestate(pD3DDevice, PreserveFlags);
-    *pResult = ToHandle(pImpl);
-    return gfsdk_waveworks_result_OK;
-	ENTRYPOINT_END
-}
 
 gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Savestate_CreateD3D11(GFSDK_WaveWorks_StatePreserveFlags PreserveFlags, ID3D11Device* pD3DDevice, GFSDK_WaveWorks_SavestateHandle* pResult)
 {
@@ -1283,20 +972,6 @@ gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Savestate_Creat
 	ENTRYPOINT_END
 }
 
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Savestate_RestoreD3D9(GFSDK_WaveWorks_SavestateHandle hSavestate)
-{
-	ENTRYPOINT_BEGIN_API(d3d9)
-	return ToAPIResult(FromHandle(hSavestate)->Restore(NULL));
-	ENTRYPOINT_END
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Savestate_RestoreD3D10(GFSDK_WaveWorks_SavestateHandle hSavestate)
-{
-	ENTRYPOINT_BEGIN_API(d3d10)
-	return ToAPIResult(FromHandle(hSavestate)->Restore(NULL));
-	ENTRYPOINT_END
-}
-
 gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Savestate_RestoreD3D11(GFSDK_WaveWorks_SavestateHandle hSavestate, ID3D11DeviceContext* pDC)
 {
 	ENTRYPOINT_BEGIN_API(d3d11)
@@ -1315,64 +990,6 @@ gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Savestate_Destr
 	ENTRYPOINT_END
 }
 
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_CreateD3D9(const GFSDK_WaveWorks_Simulation_Settings& D3D9_ONLY(global_settings), const GFSDK_WaveWorks_Simulation_Params& D3D9_ONLY(global_params), IDirect3DDevice9* D3D9_ONLY(pD3DDevice), GFSDK_WaveWorks_SimulationHandle* D3D9_ONLY(pResult))
-{
-	ENTRYPOINT_BEGIN_API(d3d9)
-
-#if WAVEWORKS_ENABLE_D3D9
-	// Don't assume the user checked GFSDK_WaveWorks_Simulation_DetailLevelIsSupported_XXXX()...
-	if(gfsdk_waveworks_result_OK != CheckDetailLevelSupport(global_settings.detail_level,__DEF_FUNCTION__))
-	{
-		return gfsdk_waveworks_result_FAIL;
-	}
-
-    GFSDK_WaveWorks_Simulation* pImpl = new GFSDK_WaveWorks_Simulation();
-	GFSDK_WaveWorks_Detailed_Simulation_Params detailed_params;
-	Init_Detailed_Water_Simulation_Params(global_settings, global_params, &detailed_params);
-    HRESULT hr = pImpl->initD3D9(detailed_params, pD3DDevice);
-    if(FAILED(hr))
-    {
-        delete pImpl;
-        return ToAPIResult(hr);
-    }
-    *pResult = ToHandle(pImpl);
-    return gfsdk_waveworks_result_OK;
-#else // WAVEWORKS_ENABLE_D3D9
-	return gfsdk_waveworks_result_FAIL;
-#endif // WAVEWORKS_ENABLE_D3D9
-
-	ENTRYPOINT_END
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_CreateD3D10(const GFSDK_WaveWorks_Simulation_Settings& D3D10_ONLY(global_settings), const GFSDK_WaveWorks_Simulation_Params& D3D10_ONLY(global_params), ID3D10Device* D3D10_ONLY(pD3DDevice), GFSDK_WaveWorks_SimulationHandle* D3D10_ONLY(pResult))
-{
-	ENTRYPOINT_BEGIN_API(d3d10)
-
-#if WAVEWORKS_ENABLE_D3D10
-	// Don't assume the user checked GFSDK_WaveWorks_Simulation_DetailLevelIsSupported_XXXX()...
-	if(gfsdk_waveworks_result_OK != CheckDetailLevelSupport(global_settings.detail_level,__DEF_FUNCTION__))
-	{
-		return gfsdk_waveworks_result_FAIL;
-	}
-
-    GFSDK_WaveWorks_Simulation* pImpl = new GFSDK_WaveWorks_Simulation();
-	GFSDK_WaveWorks_Detailed_Simulation_Params detailed_params;
-	Init_Detailed_Water_Simulation_Params(global_settings, global_params, &detailed_params);
-	HRESULT hr = pImpl->initD3D10(detailed_params, pD3DDevice);
-    if(FAILED(hr))
-    {
-        delete pImpl;
-        return ToAPIResult(hr);
-    }
-    *pResult = ToHandle(pImpl);
-    return gfsdk_waveworks_result_OK;
-#else // WAVEWORKS_ENABLE_D3D10
-	return gfsdk_waveworks_result_FAIL;
-#endif // WAVEWORKS_ENABLE_D3D10
-
-	ENTRYPOINT_END
-}
-
 namespace
 {
 	gfsdk_waveworks_result Simulation_CreateD3D11_Generic(  const GFSDK_WaveWorks_Simulation_Settings& global_settings,
@@ -1578,20 +1195,6 @@ gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_Kick
 	ENTRYPOINT_END
 }
 
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_KickD3D9(GFSDK_WaveWorks_SimulationHandle hSim, gfsdk_U64* pKickID, GFSDK_WaveWorks_SavestateHandle hSavestate)
-{
-	ENTRYPOINT_BEGIN_API(d3d9)
-	return Simulation_Kick_Generic(hSim, pKickID, NULL, hSavestate);
-	ENTRYPOINT_END
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_KickD3D10(GFSDK_WaveWorks_SimulationHandle hSim, gfsdk_U64* pKickID, GFSDK_WaveWorks_SavestateHandle hSavestate)
-{
-	ENTRYPOINT_BEGIN_API(d3d10)
-	return Simulation_Kick_Generic(hSim, pKickID, NULL, hSavestate);
-	ENTRYPOINT_END
-}
-
 gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_KickD3D11(GFSDK_WaveWorks_SimulationHandle hSim, gfsdk_U64* pKickID, ID3D11DeviceContext* pDC, GFSDK_WaveWorks_SavestateHandle hSavestate)
 {
 	ENTRYPOINT_BEGIN_API(d3d11)
@@ -1623,34 +1226,6 @@ gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_GetS
 	ENTRYPOINT_END
 }
 
-gfsdk_U32 GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_GetShaderInputCountD3D9()
-{
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-    return GFSDK_WaveWorks_Simulation::getShaderInputCountD3D9();
-	CUSTOM_ENTRYPOINT_END((gfsdk_U32)-1)
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_GetShaderInputDescD3D9(gfsdk_U32 inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc)
-{
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-    return ToAPIResult(GFSDK_WaveWorks_Simulation::getShaderInputDescD3D9(inputIndex, pDesc));
-	ENTRYPOINT_END
-}
-
-gfsdk_U32 GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_GetShaderInputCountD3D10()
-{
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-    return GFSDK_WaveWorks_Simulation::getShaderInputCountD3D10();
-	CUSTOM_ENTRYPOINT_END((gfsdk_U32)-1)
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_GetShaderInputDescD3D10(gfsdk_U32 inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc)
-{
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-    return ToAPIResult(GFSDK_WaveWorks_Simulation::getShaderInputDescD3D10(inputIndex, pDesc));
-	ENTRYPOINT_END
-}
-
 gfsdk_U32 GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_GetShaderInputCountD3D11()
 {
 	ENTRYPOINT_BEGIN_NO_INIT_CHECK
@@ -1778,20 +1353,6 @@ gfsdk_waveworks_result GFSDK_WaveWorks_Simulation_AdvanceStagingCursorNoGraphics
 	ENTRYPOINT_END
 }
 
-gfsdk_waveworks_result GFSDK_WaveWorks_Simulation_AdvanceStagingCursorD3D9(GFSDK_WaveWorks_SimulationHandle hSim, bool block, GFSDK_WaveWorks_SavestateHandle hSavestate)
-{
-	ENTRYPOINT_BEGIN_API(d3d9)
-	return Simulation_AdvanceStagingCursor_Generic(hSim,block,NULL,hSavestate);
-	ENTRYPOINT_END
-}
-
-gfsdk_waveworks_result GFSDK_WaveWorks_Simulation_AdvanceStagingCursorD3D10(GFSDK_WaveWorks_SimulationHandle hSim, bool block, GFSDK_WaveWorks_SavestateHandle hSavestate)
-{
-	ENTRYPOINT_BEGIN_API(d3d10)
-	return Simulation_AdvanceStagingCursor_Generic(hSim,block,NULL,hSavestate);
-	ENTRYPOINT_END
-}
-
 gfsdk_waveworks_result GFSDK_WaveWorks_Simulation_AdvanceStagingCursorD3D11(GFSDK_WaveWorks_SimulationHandle hSim, bool block, ID3D11DeviceContext* pDC, GFSDK_WaveWorks_SavestateHandle hSavestate)
 {
 	ENTRYPOINT_BEGIN_API(d3d11)
@@ -1906,20 +1467,6 @@ namespace
 	}
 }
 
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_SetRenderStateD3D9(GFSDK_WaveWorks_SimulationHandle hSim, const gfsdk_float4x4& matView, const gfsdk_U32* pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate)
-{
-	ENTRYPOINT_BEGIN_API(d3d9)
-	return Simulation_SetRenderState_Generic(hSim,NULL,matView,pShaderInputRegisterMappings,hSavestate,NULL);
-	ENTRYPOINT_END
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_SetRenderStateD3D10(GFSDK_WaveWorks_SimulationHandle hSim, const gfsdk_float4x4& matView, const gfsdk_U32* pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate)
-{
-	ENTRYPOINT_BEGIN_API(d3d10)
-	return Simulation_SetRenderState_Generic(hSim,NULL,matView,pShaderInputRegisterMappings,hSavestate,NULL);
-	ENTRYPOINT_END
-}
-
 gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_SetRenderStateD3D11(GFSDK_WaveWorks_SimulationHandle hSim, ID3D11DeviceContext* pDC, const gfsdk_float4x4& matView, const gfsdk_U32* pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate)
 {
 	ENTRYPOINT_BEGIN_API(d3d11)
@@ -1959,42 +1506,6 @@ gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Simulation_GetA
 	ENTRYPOINT_END
 }
 
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_CreateD3D9(const GFSDK_WaveWorks_Quadtree_Params& params, IDirect3DDevice9* pD3DDevice, GFSDK_WaveWorks_QuadtreeHandle* pResult)
-{
-	ENTRYPOINT_BEGIN_API(d3d9)
-
-    GFSDK_WaveWorks_Quadtree* pImpl = new GFSDK_WaveWorks_Quadtree();
-    HRESULT hr = pImpl->initD3D9(params, pD3DDevice);
-    if(FAILED(hr))
-    {
-        delete pImpl;
-        return ToAPIResult(hr);
-    }
-
-    *pResult = ToHandle(pImpl);
-    return gfsdk_waveworks_result_OK;
-
-	ENTRYPOINT_END
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_CreateD3D10(const GFSDK_WaveWorks_Quadtree_Params& params, ID3D10Device* pD3DDevice, GFSDK_WaveWorks_QuadtreeHandle* pResult)
-{
-	ENTRYPOINT_BEGIN_API(d3d10)
-
-    GFSDK_WaveWorks_Quadtree* pImpl = new GFSDK_WaveWorks_Quadtree();
-    HRESULT hr = pImpl->initD3D10(params, pD3DDevice);
-    if(FAILED(hr))
-    {
-        delete pImpl;
-        return ToAPIResult(hr);
-    }
-
-    *pResult = ToHandle(pImpl);
-    return gfsdk_waveworks_result_OK;
-
-	ENTRYPOINT_END
-}
-
 gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_CreateD3D11(const GFSDK_WaveWorks_Quadtree_Params& params, ID3D11Device* pD3DDevice, GFSDK_WaveWorks_QuadtreeHandle* pResult)
 {
 	ENTRYPOINT_BEGIN_API(d3d11)
@@ -2066,34 +1577,6 @@ gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_Update
 	ENTRYPOINT_END
 }
 
-gfsdk_U32 GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_GetShaderInputCountD3D9()
-{
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-    return GFSDK_WaveWorks_Quadtree::getShaderInputCountD3D9();
-	CUSTOM_ENTRYPOINT_END((gfsdk_U32)-1)
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_GetShaderInputDescD3D9(gfsdk_U32 inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc)
-{
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-	return ToAPIResult(GFSDK_WaveWorks_Quadtree::getShaderInputDescD3D9(inputIndex, pDesc));
-	ENTRYPOINT_END
-}
-
-gfsdk_U32 GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_GetShaderInputCountD3D10()
-{
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-	return GFSDK_WaveWorks_Quadtree::getShaderInputCountD3D10();
-	CUSTOM_ENTRYPOINT_END((gfsdk_U32)-1)
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_GetShaderInputDescD3D10(gfsdk_U32 inputIndex, GFSDK_WaveWorks_ShaderInput_Desc* pDesc)
-{
-	ENTRYPOINT_BEGIN_NO_INIT_CHECK
-	return ToAPIResult(GFSDK_WaveWorks_Quadtree::getShaderInputDescD3D10(inputIndex, pDesc));
-	ENTRYPOINT_END
-}
-
 gfsdk_U32 GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_GetShaderInputCountD3D11()
 {
 	ENTRYPOINT_BEGIN_NO_INIT_CHECK
@@ -2155,20 +1638,6 @@ namespace
 	}
 }
 
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_DrawD3D9(GFSDK_WaveWorks_QuadtreeHandle hQuadtree, const gfsdk_float4x4& matView, const gfsdk_float4x4& matProj, const gfsdk_U32* pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate)
-{
-	ENTRYPOINT_BEGIN_API(d3d9)
-	return Quadtree_Draw_Generic(hQuadtree,NULL,matView,matProj,NULL,pShaderInputRegisterMappings,hSavestate);
-	ENTRYPOINT_END
-}
-
-gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_DrawD3D10(GFSDK_WaveWorks_QuadtreeHandle hQuadtree, const gfsdk_float4x4& matView, const gfsdk_float4x4& matProj, const gfsdk_U32* pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate)
-{
-	ENTRYPOINT_BEGIN_API(d3d10)
-	return Quadtree_Draw_Generic(hQuadtree,NULL,matView,matProj,NULL,pShaderInputRegisterMappings,hSavestate);
-	ENTRYPOINT_END
-}
-
 gfsdk_waveworks_result GFSDK_WAVEWORKS_CALL_CONV GFSDK_WaveWorks_Quadtree_DrawD3D11(GFSDK_WaveWorks_QuadtreeHandle hQuadtree, ID3D11DeviceContext* pDC, const gfsdk_float4x4& matView, const gfsdk_float4x4& matProj, const gfsdk_U32* pShaderInputRegisterMappings, GFSDK_WaveWorks_SavestateHandle hSavestate)
 {
 	ENTRYPOINT_BEGIN_API(d3d11)
diff --git a/src/FFT_Simulation.h b/src/FFT_Simulation.h
index b06b206..c006706 100644
--- a/src/FFT_Simulation.h
+++ b/src/FFT_Simulation.h
@@ -53,8 +53,6 @@ public:
 
 	virtual ~NVWaveWorks_FFT_Simulation() {};
 
-    virtual HRESULT initD3D9(IDirect3DDevice9* pD3DDevice) = 0;
-    virtual HRESULT initD3D10(ID3D10Device* pD3DDevice) = 0;
     virtual HRESULT initD3D11(ID3D11Device* pD3DDevice) = 0;
 	virtual HRESULT initGnm() { return S_FALSE; };
 	virtual HRESULT initGL2(void* /*pGLContext*/) { return S_FALSE; };
@@ -78,8 +76,6 @@ public:
 	virtual gfsdk_U64 getDisplacementMapVersion() const = 0;	// Returns the kickID of the last time the displacement map was updated
 
 	// NB: None of these AddRef's the underlying D3D resource
-	virtual LPDIRECT3DTEXTURE9 GetDisplacementMapD3D9() = 0;
-	virtual ID3D10ShaderResourceView** GetDisplacementMapD3D10() = 0;
 	virtual ID3D11ShaderResourceView** GetDisplacementMapD3D11() = 0;
 	virtual sce::Gnm::Texture* GetDisplacementMapGnm() { return NULL; }
 	virtual GLuint					   GetDisplacementMapGL2() = 0;
diff --git a/src/FFT_Simulation_CPU.cpp b/src/FFT_Simulation_CPU.cpp
index d412030..9c5a3b5 100644
--- a/src/FFT_Simulation_CPU.cpp
+++ b/src/FFT_Simulation_CPU.cpp
@@ -779,62 +779,6 @@ NVWaveWorks_FFT_Simulation_CPU_Impl::~NVWaveWorks_FFT_Simulation_CPU_Impl()
     releaseAll();
 }
 
-HRESULT NVWaveWorks_FFT_Simulation_CPU_Impl::initD3D9(IDirect3DDevice9* D3D9_ONLY(pD3DDevice))
-{
-#if WAVEWORKS_ENABLE_D3D9
-    HRESULT hr;
-
-    if(nv_water_d3d_api_d3d9 != m_d3dAPI)
-    {
-        releaseAll();
-    }
-    else if(m_d3d._9.m_pd3d9Device != pD3DDevice)
-    {
-        releaseAll();
-    }
-
-    if(nv_water_d3d_api_undefined == m_d3dAPI)
-    {
-        m_d3dAPI = nv_water_d3d_api_d3d9;
-        m_d3d._9.m_pd3d9Device = pD3DDevice;
-        m_d3d._9.m_pd3d9Device->AddRef();
-        V_RETURN(allocateAllResources());
-    }
-    return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-
-HRESULT NVWaveWorks_FFT_Simulation_CPU_Impl::initD3D10(ID3D10Device* D3D10_ONLY(pD3DDevice))
-{
-#if WAVEWORKS_ENABLE_D3D10
-    HRESULT hr;
-
-    if(nv_water_d3d_api_d3d10 != m_d3dAPI)
-    {
-        releaseAll();
-    }
-    else if(m_d3d._10.m_pd3d10Device != pD3DDevice)
-    {
-        releaseAll();
-    }
-
-    if(nv_water_d3d_api_undefined == m_d3dAPI)
-    {
-        m_d3dAPI = nv_water_d3d_api_d3d10;
-        m_d3d._10.m_pd3d10Device = pD3DDevice;
-        m_d3d._10.m_pd3d10Device->AddRef();
-        V_RETURN(allocateAllResources());
-    }
-    return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-
 HRESULT NVWaveWorks_FFT_Simulation_CPU_Impl::initD3D11(ID3D11Device* D3D11_ONLY(pD3DDevice))
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -1106,50 +1050,6 @@ HRESULT NVWaveWorks_FFT_Simulation_CPU_Impl::allocateAllResources()
 
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			SAFE_RELEASE(m_d3d._9.m_pd3d9DisplacementMapTexture[1]);
-			SAFE_RELEASE(m_d3d._9.m_pd3d9DisplacementMapTexture[0]);
-			for(int i=0; i<2; i++)
-			{
-				// Create 2D texture
-				V_RETURN(m_d3d._9.m_pd3d9Device->CreateTexture(N,N,1,D3DUSAGE_DYNAMIC,D3DFMT_A16B16G16R16F,D3DPOOL_DEFAULT,&m_d3d._9.m_pd3d9DisplacementMapTexture[i],NULL));
-			}
-			break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			SAFE_RELEASE(m_d3d._10.m_pd3d10DisplacementMapTexture[1]);
-			SAFE_RELEASE(m_d3d._10.m_pd3d10DisplacementMapTexture[0]);
-			SAFE_RELEASE(m_d3d._10.m_pd3d10DisplacementMapTextureSRV[0]);
-			SAFE_RELEASE(m_d3d._10.m_pd3d10DisplacementMapTextureSRV[1]);
-			for(int i=0; i<2; i++)
-			{
-				// Create 2D texture
-				D3D10_TEXTURE2D_DESC tex_desc;
-				tex_desc.Width = N;
-				tex_desc.Height = N;
-				tex_desc.MipLevels = 1;
-				tex_desc.ArraySize = 1;
-				tex_desc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
-				tex_desc.SampleDesc.Count = 1;
-				tex_desc.SampleDesc.Quality = 0;
-				tex_desc.Usage = D3D10_USAGE_DYNAMIC;
-				tex_desc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
-				tex_desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
-				tex_desc.MiscFlags = 0;
-				V_RETURN(m_d3d._10.m_pd3d10Device->CreateTexture2D(&tex_desc, NULL, &m_d3d._10.m_pd3d10DisplacementMapTexture[i]));
-
-				// Create shader resource view
-				D3D10_SHADER_RESOURCE_VIEW_DESC srv_desc;
-				srv_desc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
-				srv_desc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
-				srv_desc.Texture2D.MipLevels = tex_desc.MipLevels;
-				srv_desc.Texture2D.MostDetailedMip = 0;
-				V_RETURN(m_d3d._10.m_pd3d10Device->CreateShaderResourceView(m_d3d._10.m_pd3d10DisplacementMapTexture[i], &srv_desc, &m_d3d._10.m_pd3d10DisplacementMapTextureSRV[i]));
-			}
-			break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			SAFE_RELEASE(m_d3d._11.m_pDC);//release previous context
@@ -1259,16 +1159,6 @@ void NVWaveWorks_FFT_Simulation_CPU_Impl::releaseAll()
 #if WAVEWORKS_ENABLE_GRAPHICS
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			SAFE_RELEASE(m_d3d._9.m_pd3d9Device);
-	        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			SAFE_RELEASE(m_d3d._10.m_pd3d10Device);
-	        break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			SAFE_RELEASE(m_d3d._11.m_pd3d11Device);
@@ -1313,20 +1203,6 @@ void NVWaveWorks_FFT_Simulation_CPU_Impl::releaseAllResources()
 
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-	    case nv_water_d3d_api_d3d9:
-			SAFE_RELEASE(m_d3d._9.m_pd3d9DisplacementMapTexture[0]);
-			SAFE_RELEASE(m_d3d._9.m_pd3d9DisplacementMapTexture[1]);
-	        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	    case nv_water_d3d_api_d3d10:
-			SAFE_RELEASE(m_d3d._10.m_pd3d10DisplacementMapTexture[0]);
-			SAFE_RELEASE(m_d3d._10.m_pd3d10DisplacementMapTexture[1]);
-			SAFE_RELEASE(m_d3d._10.m_pd3d10DisplacementMapTextureSRV[0]);
-			SAFE_RELEASE(m_d3d._10.m_pd3d10DisplacementMapTextureSRV[1]);
-	        break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 	    case nv_water_d3d_api_d3d11:
 			assert(NULL == m_d3d._11.m_pDC); // should be done by OnCompleteSimulationStep()
@@ -1446,28 +1322,6 @@ HRESULT NVWaveWorks_FFT_Simulation_CPU_Impl::getTimings(NVWaveWorks_FFT_Simulati
 	return S_OK;
 }
 
-LPDIRECT3DTEXTURE9 NVWaveWorks_FFT_Simulation_CPU_Impl::GetDisplacementMapD3D9()
-{
-#if WAVEWORKS_ENABLE_D3D9
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-	int ti = (m_mapped_texture_index+1)&1;
-	return m_d3d._9.m_pd3d9DisplacementMapTexture[ti];
-#else
-	return NULL;
-#endif
-}
-
-ID3D10ShaderResourceView** NVWaveWorks_FFT_Simulation_CPU_Impl::GetDisplacementMapD3D10()
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-	int ti = (m_mapped_texture_index+1)&1;
-	return &m_d3d._10.m_pd3d10DisplacementMapTextureSRV[ti];
-#else
-	return NULL;
-#endif
-}
-
 ID3D11ShaderResourceView** NVWaveWorks_FFT_Simulation_CPU_Impl::GetDisplacementMapD3D11()
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -1505,16 +1359,6 @@ void NVWaveWorks_FFT_Simulation_CPU_Impl::OnCompleteSimulationStep(gfsdk_U64 kic
 {
 	if(m_mapped_texture_ptr) {
 		switch(m_d3dAPI) {
-#if WAVEWORKS_ENABLE_D3D9
-			case nv_water_d3d_api_d3d9:
-				m_d3d._9.m_pd3d9DisplacementMapTexture[m_mapped_texture_index]->UnlockRect(0);
-				break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-			case nv_water_d3d_api_d3d10:
-				m_d3d._10.m_pd3d10DisplacementMapTexture[m_mapped_texture_index]->Unmap(0);
-				break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 			case nv_water_d3d_api_d3d11:
 				assert(NULL != m_d3d._11.m_pDC);
@@ -1580,26 +1424,6 @@ HRESULT NVWaveWorks_FFT_Simulation_CPU_Impl::OnInitiateSimulationStep(Graphics_C
 
 	UINT N = m_params.fft_resolution;
 	switch(m_d3dAPI) {
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9: {
-				HRESULT hr;
-				D3DLOCKED_RECT lockrect;
-				V_RETURN(m_d3d._9.m_pd3d9DisplacementMapTexture[m_mapped_texture_index]->LockRect(0,&lockrect,NULL,D3DLOCK_DISCARD));
-				m_mapped_texture_ptr = static_cast<BYTE*>(lockrect.pBits);
-				m_mapped_texture_row_pitch = lockrect.Pitch;
-			}
-			break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10: {
-				HRESULT hr;
-				D3D10_MAPPED_TEXTURE2D mt_d3d10;
-				V_RETURN(m_d3d._10.m_pd3d10DisplacementMapTexture[m_mapped_texture_index]->Map(0,D3D10_MAP_WRITE_DISCARD,0,&mt_d3d10));
-				m_mapped_texture_ptr = static_cast<BYTE*>(mt_d3d10.pData);
-				m_mapped_texture_row_pitch = mt_d3d10.RowPitch;
-			}
-			break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11: {
 				HRESULT hr;
diff --git a/src/FFT_Simulation_CPU_impl.h b/src/FFT_Simulation_CPU_impl.h
index a72a34b..2a0a725 100644
--- a/src/FFT_Simulation_CPU_impl.h
+++ b/src/FFT_Simulation_CPU_impl.h
@@ -62,8 +62,6 @@ public:
 	void OnCompleteSimulationStep(gfsdk_U64 kickID);
 
 	// Mandatory NVWaveWorks_FFT_Simulation interface
-    HRESULT initD3D9(IDirect3DDevice9* pD3DDevice);
-    HRESULT initD3D10(ID3D10Device* pD3DDevice);
     HRESULT initD3D11(ID3D11Device* pD3DDevice);
 	HRESULT initGnm();
 	HRESULT initGL2(void* pGLContext);
@@ -73,8 +71,6 @@ public:
 	HRESULT addArchivedDisplacements(float coord, const gfsdk_float2* inSamplePoints, gfsdk_float4* outDisplacements, UINT numSamples);
 	HRESULT getTimings(NVWaveWorks_FFT_Simulation_Timings&) const;
 	gfsdk_U64 getDisplacementMapVersion() const { return m_DisplacementMapVersion; }
-	LPDIRECT3DTEXTURE9 GetDisplacementMapD3D9();
-	ID3D10ShaderResourceView** GetDisplacementMapD3D10();
 	ID3D11ShaderResourceView** GetDisplacementMapD3D11();
 	sce::Gnm::Texture* GetDisplacementMapGnm();
 	GLuint					   GetDisplacementMapGL2();
@@ -105,23 +101,6 @@ private:
 	// D3D API handling
 	nv_water_d3d_api m_d3dAPI;
 
-#if WAVEWORKS_ENABLE_D3D9
-    struct D3D9Objects
-    {
-		IDirect3DDevice9* m_pd3d9Device;
-        LPDIRECT3DTEXTURE9 m_pd3d9DisplacementMapTexture[2];			// (ABGR32F)
-    };
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-    struct D3D10Objects
-    {
-		ID3D10Device* m_pd3d10Device;
-        ID3D10Texture2D* m_pd3d10DisplacementMapTexture[2];
-        ID3D10ShaderResourceView* m_pd3d10DisplacementMapTextureSRV[2];	// (ABGR32F)
-    };
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
     struct D3D11Objects
     {
@@ -155,12 +134,6 @@ private:
 
     union
     {
-#if WAVEWORKS_ENABLE_D3D9
-        D3D9Objects _9;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-        D3D10Objects _10;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		D3D11Objects _11;
 #endif
diff --git a/src/FFT_Simulation_CUDA.cpp b/src/FFT_Simulation_CUDA.cpp
index c661d2c..812d994 100644
--- a/src/FFT_Simulation_CUDA.cpp
+++ b/src/FFT_Simulation_CUDA.cpp
@@ -124,87 +124,6 @@ NVWaveWorks_FFT_Simulation_CUDA_Impl::~NVWaveWorks_FFT_Simulation_CUDA_Impl()
     releaseAll();
 }
 
-HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::initD3D9(IDirect3DDevice9* pD3DDevice)
-{
-#if WAVEWORKS_ENABLE_D3D9
-    HRESULT hr;
-
-    if(nv_water_d3d_api_d3d9 != m_d3dAPI)
-    {
-        releaseAll();
-    }
-    else if(m_d3d._9.m_pd3d9Device != pD3DDevice)
-    {
-        releaseAll();
-    }
-
-    if(nv_water_d3d_api_undefined == m_d3dAPI)
-    {
-        m_d3dAPI = nv_water_d3d_api_d3d9;
-        m_d3d._9.m_pd3d9Device = pD3DDevice;
-        m_d3d._9.m_pd3d9Device->AddRef();
-
-		// Use 4x32F for D3D9
-		m_readback_element_size = sizeof(float4);
-
-		m_numCudaDevices = m_pManager->GetNumCudaDevices();
-		m_pCudaDeviceStates = new CudaDeviceState[m_numCudaDevices];
-		memset(m_pCudaDeviceStates, 0, m_numCudaDevices * sizeof(CudaDeviceState));
-		for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-		{
-			m_pCudaDeviceStates[cuda_dev_index].m_cudaDevice = m_pManager->GetCudaDeviceInfo(cuda_dev_index).m_cudaDevice;
-			m_pCudaDeviceStates[cuda_dev_index].m_constantsIndex = -1;
-		}
-
-        V_RETURN(allocateAllResources());
-    }
-
-    return S_OK;
-#else
-    return E_FAIL;
-#endif
-}
-
-HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::initD3D10(ID3D10Device* pD3DDevice)
-{
-#if WAVEWORKS_ENABLE_D3D10
-    HRESULT hr;
-
-    if(nv_water_d3d_api_d3d10 != m_d3dAPI)
-    {
-        releaseAll();
-    }
-    else if(m_d3d._10.m_pd3d10Device != pD3DDevice)
-    {
-        releaseAll();
-    }
-
-    if(nv_water_d3d_api_undefined == m_d3dAPI)
-    {
-        m_d3dAPI = nv_water_d3d_api_d3d10;
-        m_d3d._10.m_pd3d10Device = pD3DDevice;
-        m_d3d._10.m_pd3d10Device->AddRef();
-
-		// Use 4x32F for D3D10
-		m_readback_element_size = sizeof(float4);
-
-		m_numCudaDevices = m_pManager->GetNumCudaDevices();
-		m_pCudaDeviceStates = new CudaDeviceState[m_numCudaDevices];
-		memset(m_pCudaDeviceStates, 0, m_numCudaDevices * sizeof(CudaDeviceState));
-		for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-		{
-			m_pCudaDeviceStates[cuda_dev_index].m_cudaDevice = m_pManager->GetCudaDeviceInfo(cuda_dev_index).m_cudaDevice;
-		}
-
-        V_RETURN(allocateAllResources());
-    }
-
-    return S_OK;
-#else
-    return E_FAIL;
-#endif
-}
-
 HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::initD3D11(ID3D11Device* pD3DDevice)
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -625,90 +544,6 @@ HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::kickPreInterop(double dSimTime, gf
 	return S_OK;
 }
 
-HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::kickWithinInteropD3D9(gfsdk_U64 kickID)
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	assert(nv_water_d3d_api_d3d9 == m_d3dAPI);
-
-	// Be sure to use the correct cuda device for the current frame (important in SLI)
-	const int activeCudaDeviceIndex = m_pManager->GetActiveCudaDeviceIndex();
-	CudaDeviceState& dev_state = m_pCudaDeviceStates[activeCudaDeviceIndex];
-	const CudaDeviceInfo& dev_info = m_pManager->GetCudaDeviceInfo(activeCudaDeviceIndex);
-
-	int output_size = m_resolution * m_resolution;
-
-    float4* tex_data = NULL;
-	IDirect3DResource9* mapped_resource = m_d3d._9.m_pd3d9PerCudaDeviceResources[activeCudaDeviceIndex].m_pd3d9DisplacementMap;
-    CUDA_V_RETURN(cudaD3D9ResourceGetMappedPointer((void**)&tex_data, mapped_resource, 0, 0));
-
-    // Fill displacement texture
-    CUDA_V_RETURN(cuda_ComputeColumns(tex_data, m_resolution, dev_state.m_constantsIndex, dev_info.m_kernel_stream));
-
-    // Optionally, get data staged for readback
-	m_working_readback_slot = NULL;
-	if(m_ReadbackInitialised) {
-		V_RETURN(consumeAvailableReadbackSlot(dev_state, kickID, &m_working_readback_slot));
-		CUDA_V_RETURN(cudaMemcpyAsync(m_working_readback_slot->m_device_Dxyz, tex_data, output_size * sizeof(float4), cudaMemcpyDeviceToDevice, dev_info.m_kernel_stream));
-
-		// The copy out of staging is done on a separate stream with the goal of allowing the copy to occur
-		// in parallel with other GPU workloads, so we need to do some inter-stream sync here
-		CUDA_V_RETURN(cudaEventRecord(m_working_readback_slot->m_staging_evt,dev_info.m_kernel_stream));
-	}
-
-	// CUDA workload is done, stop the clock and unmap as soon as we can so as not to block the graphics pipe
-	if(m_working_timer_slot)
-	{
-		CUDA_V_RETURN(cudaEventRecord(m_working_timer_slot->m_stop_timer_evt,dev_info.m_kernel_stream));
-	}
-#endif
-
-	return S_OK;
-}
-
-HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::kickWithinInteropD3D10(gfsdk_U64 kickID)
-{
-#if WAVEWORKS_ENABLE_D3D10
-	HRESULT hr;
-
-	assert(nv_water_d3d_api_d3d10 == m_d3dAPI);
-
-	// Be sure to use the correct cuda device for the current frame (important in SLI)
-	const int activeCudaDeviceIndex = m_pManager->GetActiveCudaDeviceIndex();
-	CudaDeviceState& dev_state = m_pCudaDeviceStates[activeCudaDeviceIndex];
-	const CudaDeviceInfo& dev_info = m_pManager->GetCudaDeviceInfo(activeCudaDeviceIndex);
-
-	int output_size = m_resolution * m_resolution;
-
-    float4* tex_data = NULL;
-	ID3D10Resource* mapped_resource = m_d3d._10.m_pd3d10PerCudaDeviceResources[activeCudaDeviceIndex].m_pd3d10DisplacementMapResource;
-    CUDA_V_RETURN(cudaD3D10ResourceGetMappedPointer((void**)&tex_data, mapped_resource, 0));
-
-    // Fill displacement texture
-	CUDA_V_RETURN(cuda_ComputeColumns(tex_data, m_resolution, dev_state.m_constantsIndex, dev_info.m_kernel_stream));
-
-    // Optionally, get data staged for readback
-	m_working_readback_slot = NULL;
-	if(m_ReadbackInitialised) {
-		V_RETURN(consumeAvailableReadbackSlot(dev_state, kickID, &m_working_readback_slot));
-		CUDA_V_RETURN(cudaMemcpyAsync(m_working_readback_slot->m_device_Dxyz, tex_data, output_size * sizeof(float4), cudaMemcpyDeviceToDevice, dev_info.m_kernel_stream));
-
-		// The copy out of staging is done on a separate stream with the goal of allowing the copy to occur
-		// in parallel with other GPU workloads, so we need to do some inter-stream sync here
-		CUDA_V_RETURN(cudaEventRecord(m_working_readback_slot->m_staging_evt,dev_info.m_kernel_stream));
-	}
-
-	// CUDA workload is done, stop the clock and unmap as soon as we can so as not to block the graphics pipe
-	if(m_working_timer_slot)
-	{
-		CUDA_V_RETURN(cudaEventRecord(m_working_timer_slot->m_stop_timer_evt,dev_info.m_kernel_stream));
-	}
-#endif
-
-	return S_OK;
-}
-
 HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::kickWithinInteropD3D11(gfsdk_U64 kickID)
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -845,20 +680,6 @@ HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::kickWithinInterop(gfsdk_U64 kickID
 
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			V_RETURN(kickWithinInteropD3D9(kickID));
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			V_RETURN(kickWithinInteropD3D10(kickID));
-        }
-		break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -919,50 +740,6 @@ HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::allocateAllResources()
 
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			m_d3d._9.m_pd3d9PerCudaDeviceResources = new D3D9Objects::PerCudaDeviceResources[m_numCudaDevices];
-
-			for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-			{
-				D3D9Objects::PerCudaDeviceResources& pcdr = m_d3d._9.m_pd3d9PerCudaDeviceResources[cuda_dev_index];
-				V_RETURN(m_d3d._9.m_pd3d9Device->CreateTexture(m_resolution, m_resolution, 1, 0, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &pcdr.m_pd3d9DisplacementMap, NULL));
-				pcdr.m_d3d9DisplacementmapIsRegistered = false;
-			}
-        }
-        break;
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			m_d3d._10.m_pd3d10PerCudaDeviceResources = new D3D10Objects::PerCudaDeviceResources[m_numCudaDevices];
-
-            // Create displacement map
-            D3D10_TEXTURE2D_DESC displacementMapTD;
-            displacementMapTD.Width = m_resolution;
-            displacementMapTD.Height = m_resolution;
-            displacementMapTD.MipLevels = 1;
-            displacementMapTD.ArraySize = 1;
-            displacementMapTD.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
-            displacementMapTD.SampleDesc = kNoSample;
-            displacementMapTD.Usage = D3D10_USAGE_DEFAULT;
-            displacementMapTD.BindFlags = D3D10_BIND_SHADER_RESOURCE;
-            displacementMapTD.CPUAccessFlags = 0;
-            displacementMapTD.MiscFlags = 0;
-
-			for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-			{
-				D3D10Objects::PerCudaDeviceResources& pcdr = m_d3d._10.m_pd3d10PerCudaDeviceResources[cuda_dev_index];
-				V_RETURN(m_d3d._10.m_pd3d10Device->CreateTexture2D(&displacementMapTD, NULL, &pcdr.m_pd3d10DisplacementMapResource));
-				V_RETURN(m_d3d._10.m_pd3d10Device->CreateShaderResourceView(pcdr.m_pd3d10DisplacementMapResource, NULL, &pcdr.m_pd3d10DisplacementMap));
-				pcdr.m_d3d10DisplacementmapIsRegistered = false;
-			}
-        }
-		break;
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -1050,20 +827,6 @@ void NVWaveWorks_FFT_Simulation_CUDA_Impl::releaseAll()
 #if WAVEWORKS_ENABLE_GRAPHICS
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			SAFE_RELEASE(m_d3d._9.m_pd3d9Device);
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			SAFE_RELEASE(m_d3d._10.m_pd3d10Device);
-        }
-		break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -1101,33 +864,6 @@ void NVWaveWorks_FFT_Simulation_CUDA_Impl::releaseAllResources()
 
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-			{
-				D3D9Objects::PerCudaDeviceResources& pcdr = m_d3d._9.m_pd3d9PerCudaDeviceResources[cuda_dev_index];
-				SAFE_RELEASE(pcdr.m_pd3d9DisplacementMap);
-			}
-
-			SAFE_DELETE_ARRAY(m_d3d._9.m_pd3d9PerCudaDeviceResources);
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-			{
-				D3D10Objects::PerCudaDeviceResources& pcdr = m_d3d._10.m_pd3d10PerCudaDeviceResources[cuda_dev_index];
-				SAFE_RELEASE(pcdr.m_pd3d10DisplacementMapResource);
-				SAFE_RELEASE(pcdr.m_pd3d10DisplacementMap);
-			}
-
-			SAFE_DELETE_ARRAY(m_d3d._10.m_pd3d10PerCudaDeviceResources);
-        }
-		break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -1166,58 +902,6 @@ HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::registerDisplacementMapWithCUDA()
 {
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			bool all_registered = true;
-			for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-			{
-				D3D9Objects::PerCudaDeviceResources& pcdr = m_d3d._9.m_pd3d9PerCudaDeviceResources[cuda_dev_index];
-				if(pcdr.m_pd3d9DisplacementMap)
-				{
-					if(!pcdr.m_d3d9DisplacementmapIsRegistered)
-					{
-						CUDA_V_RETURN(cudaSetDevice(m_pCudaDeviceStates[cuda_dev_index].m_cudaDevice));
-						CUDA_V_RETURN(cudaD3D9RegisterResource(pcdr.m_pd3d9DisplacementMap, cudaD3D9RegisterFlagsNone));
-						CUDA_V_RETURN(cudaD3D9ResourceSetMapFlags(pcdr.m_pd3d9DisplacementMap,cudaD3D9MapFlagsWriteDiscard));
-						pcdr.m_d3d9DisplacementmapIsRegistered = true;
-					}
-				}
-				else
-				{
-					all_registered = false;
-				}
-			}
-			m_DisplacementMapIsCUDARegistered = all_registered;
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			bool all_registered = true;
-			for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-			{
-				D3D10Objects::PerCudaDeviceResources& pcdr = m_d3d._10.m_pd3d10PerCudaDeviceResources[cuda_dev_index];
-				if(pcdr.m_pd3d10DisplacementMapResource)
-				{
-					if(!pcdr.m_d3d10DisplacementmapIsRegistered)
-					{
-						CUDA_V_RETURN(cudaSetDevice(m_pCudaDeviceStates[cuda_dev_index].m_cudaDevice));
-						CUDA_V_RETURN(cudaD3D10RegisterResource(pcdr.m_pd3d10DisplacementMapResource, cudaD3D10RegisterFlagsNone));
-						CUDA_V_RETURN(cudaD3D10ResourceSetMapFlags(pcdr.m_pd3d10DisplacementMapResource,cudaD3D10MapFlagsWriteDiscard));
-						pcdr.m_d3d10DisplacementmapIsRegistered = true;
-					}
-				}
-				else
-				{
-					all_registered = false;
-				}
-			}
-			m_DisplacementMapIsCUDARegistered = all_registered;
-        }
-        break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -1293,40 +977,6 @@ HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::unregisterDisplacementMapWithCUDA(
 {
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-			{
-				D3D9Objects::PerCudaDeviceResources& pcdr = m_d3d._9.m_pd3d9PerCudaDeviceResources[cuda_dev_index];
-				if(pcdr.m_pd3d9DisplacementMap)
-				{
-					CUDA_V_RETURN(cudaSetDevice(m_pCudaDeviceStates[cuda_dev_index].m_cudaDevice));
-					CUDA_V_RETURN(cudaD3D9UnregisterResource(pcdr.m_pd3d9DisplacementMap));
-					pcdr.m_d3d9DisplacementmapIsRegistered = false;
-				}
-			}
-            m_DisplacementMapIsCUDARegistered = false;
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-			{
-				D3D10Objects::PerCudaDeviceResources& pcdr = m_d3d._10.m_pd3d10PerCudaDeviceResources[cuda_dev_index];
-				if(pcdr.m_pd3d10DisplacementMapResource)
-				{
-					CUDA_V_RETURN(cudaSetDevice(m_pCudaDeviceStates[cuda_dev_index].m_cudaDevice));
-					CUDA_V_RETURN(cudaD3D10UnregisterResource(pcdr.m_pd3d10DisplacementMapResource));
-					pcdr.m_d3d10DisplacementmapIsRegistered = false;
-				}
-			}
-            m_DisplacementMapIsCUDARegistered = false;
-        }
-        break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -1784,29 +1434,6 @@ HRESULT NVWaveWorks_FFT_Simulation_CUDA_Impl::getTimings(NVWaveWorks_FFT_Simulat
 	return S_OK;
 }
 
-
-LPDIRECT3DTEXTURE9 NVWaveWorks_FFT_Simulation_CUDA_Impl::GetDisplacementMapD3D9()
-{
-#if WAVEWORKS_ENABLE_D3D9
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-	const int activeCudaDeviceIndex = m_pManager->GetActiveCudaDeviceIndex();
-	return m_d3d._9.m_pd3d9PerCudaDeviceResources ? m_d3d._9.m_pd3d9PerCudaDeviceResources[activeCudaDeviceIndex].m_pd3d9DisplacementMap : NULL;
-#else
-    return NULL;
-#endif
-}
-
-ID3D10ShaderResourceView** NVWaveWorks_FFT_Simulation_CUDA_Impl::GetDisplacementMapD3D10()
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-	const int activeCudaDeviceIndex = m_pManager->GetActiveCudaDeviceIndex();
-	return m_d3d._10.m_pd3d10PerCudaDeviceResources ? &m_d3d._10.m_pd3d10PerCudaDeviceResources[activeCudaDeviceIndex].m_pd3d10DisplacementMap : NULL;
-#else
-    return NULL;
-#endif
-}
-
 ID3D11ShaderResourceView** NVWaveWorks_FFT_Simulation_CUDA_Impl::GetDisplacementMapD3D11()
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -1829,26 +1456,6 @@ GLuint NVWaveWorks_FFT_Simulation_CUDA_Impl::GetDisplacementMapGL2()
 #endif
 }
 
-IDirect3DResource9* NVWaveWorks_FFT_Simulation_CUDA_Impl::getD3D9InteropResource(unsigned int deviceIndex)
-{
-#if WAVEWORKS_ENABLE_D3D9
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-	return m_d3d._9.m_pd3d9PerCudaDeviceResources[deviceIndex].m_pd3d9DisplacementMap;
-#else
-	return NULL;
-#endif
-}
-
-ID3D10Resource* NVWaveWorks_FFT_Simulation_CUDA_Impl::getD3D10InteropResource(unsigned int deviceIndex)
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-	return m_d3d._10.m_pd3d10PerCudaDeviceResources[deviceIndex].m_pd3d10DisplacementMapResource;
-#else
-	return NULL;
-#endif
-}
-
 cudaGraphicsResource* NVWaveWorks_FFT_Simulation_CUDA_Impl::getInteropResource(unsigned int deviceIndex)
 {
 	switch(m_d3dAPI)
diff --git a/src/FFT_Simulation_CUDA_impl.h b/src/FFT_Simulation_CUDA_impl.h
index d2a7ef9..904967b 100644
--- a/src/FFT_Simulation_CUDA_impl.h
+++ b/src/FFT_Simulation_CUDA_impl.h
@@ -46,8 +46,6 @@ public:
 	~NVWaveWorks_FFT_Simulation_CUDA_Impl();
 
 	// Mandatory NVWaveWorks_FFT_Simulation interface
-    HRESULT initD3D9(IDirect3DDevice9* pD3DDevice);
-    HRESULT initD3D10(ID3D10Device* pD3DDevice);
     HRESULT initD3D11(ID3D11Device* pD3DDevice);
 	HRESULT initGL2(void* pGLContext);
 	HRESULT initNoGraphics();
@@ -56,13 +54,9 @@ public:
 	HRESULT addArchivedDisplacements(float coord, const gfsdk_float2* inSamplePoints, gfsdk_float4* outDisplacements, UINT numSamples);
 	gfsdk_U64 getDisplacementMapVersion() const { return m_DisplacementMapVersion; }
 	HRESULT getTimings(NVWaveWorks_FFT_Simulation_Timings&) const;
-	LPDIRECT3DTEXTURE9 GetDisplacementMapD3D9();
-	ID3D10ShaderResourceView** GetDisplacementMapD3D10();
 	ID3D11ShaderResourceView** GetDisplacementMapD3D11();
 	GLuint					   GetDisplacementMapGL2();
 
-	IDirect3DResource9* getD3D9InteropResource(unsigned int deviceIndex);
-	ID3D10Resource* getD3D10InteropResource(unsigned int deviceIndex);
 	cudaGraphicsResource* getInteropResource(unsigned int deviceIndex);
 
 	HRESULT preKick(int constantsIndex);
@@ -81,8 +75,6 @@ public:
 private:
 
 	HRESULT kickWithinInteropD3D11(gfsdk_U64 kickID);
-	HRESULT kickWithinInteropD3D10(gfsdk_U64 kickID);
-	HRESULT kickWithinInteropD3D9(gfsdk_U64 kickID);
 	HRESULT kickWithinInteropGL2(gfsdk_U64 kickID);
 	HRESULT kickWithinInteropNoGfx(gfsdk_U64 kickID);
 
@@ -214,39 +206,6 @@ private:
 	// D3D API handling
 	nv_water_d3d_api m_d3dAPI;
 
-#if WAVEWORKS_ENABLE_D3D9
-    struct D3D9Objects
-    {
-		IDirect3DDevice9* m_pd3d9Device;
-
-		struct PerCudaDeviceResources
-		{
-			// Displacement/choppy field
-			LPDIRECT3DTEXTURE9 m_pd3d9DisplacementMap;			// (ABGR32F)
-			bool m_d3d9DisplacementmapIsRegistered;
-		};
-
-		PerCudaDeviceResources* m_pd3d9PerCudaDeviceResources;
-    };
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-    struct D3D10Objects
-    {
-		ID3D10Device* m_pd3d10Device;
-
-		struct PerCudaDeviceResources
-		{
-			// Displacement/choppy field
-			ID3D10Texture2D* m_pd3d10DisplacementMapResource;
-			ID3D10ShaderResourceView* m_pd3d10DisplacementMap;	// (ABGR32F)
-			bool m_d3d10DisplacementmapIsRegistered;
-		};
-
-		PerCudaDeviceResources* m_pd3d10PerCudaDeviceResources;
-    };
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
     struct D3D11Objects
     {
@@ -290,12 +249,6 @@ private:
 
     union
     {
-#if WAVEWORKS_ENABLE_D3D9
-        D3D9Objects _9;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-        D3D10Objects _10;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		D3D11Objects _11;
 #endif
diff --git a/src/FFT_Simulation_DirectCompute.cpp b/src/FFT_Simulation_DirectCompute.cpp
index 512d49d..9d32aad 100644
--- a/src/FFT_Simulation_DirectCompute.cpp
+++ b/src/FFT_Simulation_DirectCompute.cpp
@@ -74,16 +74,6 @@ NVWaveWorks_FFT_Simulation_DirectCompute_Impl::~NVWaveWorks_FFT_Simulation_Direc
     releaseAll();
 }
 
-HRESULT NVWaveWorks_FFT_Simulation_DirectCompute_Impl::initD3D9(IDirect3DDevice9* /*pD3DDevice*/)
-{
-	return S_FALSE;
-}
-
-HRESULT NVWaveWorks_FFT_Simulation_DirectCompute_Impl::initD3D10(ID3D10Device* /*pD3DDevice*/)
-{
-	return S_FALSE;
-}
-
 HRESULT NVWaveWorks_FFT_Simulation_DirectCompute_Impl::initD3D11(ID3D11Device* pD3DDevice)
 {
     HRESULT hr;
@@ -1054,16 +1044,6 @@ HRESULT NVWaveWorks_FFT_Simulation_DirectCompute_Impl::getTimings(NVWaveWorks_FF
 }
 
 
-LPDIRECT3DTEXTURE9 NVWaveWorks_FFT_Simulation_DirectCompute_Impl::GetDisplacementMapD3D9()
-{
-	return NULL;
-}
-
-ID3D10ShaderResourceView** NVWaveWorks_FFT_Simulation_DirectCompute_Impl::GetDisplacementMapD3D10()
-{
-	return NULL;
-}
-
 ID3D11ShaderResourceView** NVWaveWorks_FFT_Simulation_DirectCompute_Impl::GetDisplacementMapD3D11()
 {
 	assert(m_d3dAPI == nv_water_d3d_api_d3d11);
diff --git a/src/FFT_Simulation_DirectCompute_impl.h b/src/FFT_Simulation_DirectCompute_impl.h
index c01e62c..a6668c2 100644
--- a/src/FFT_Simulation_DirectCompute_impl.h
+++ b/src/FFT_Simulation_DirectCompute_impl.h
@@ -43,8 +43,6 @@ public:
 	~NVWaveWorks_FFT_Simulation_DirectCompute_Impl();
 
 	// Mandatory NVWaveWorks_FFT_Simulation interface
-    HRESULT initD3D9(IDirect3DDevice9* pD3DDevice);
-    HRESULT initD3D10(ID3D10Device* pD3DDevice);
     HRESULT initD3D11(ID3D11Device* pD3DDevice);
 	HRESULT initNoGraphics() { return S_OK; }
 	HRESULT reinit(const GFSDK_WaveWorks_Detailed_Simulation_Params::Cascade& params);
@@ -52,8 +50,6 @@ public:
 	HRESULT addArchivedDisplacements(float coord, const gfsdk_float2* inSamplePoints, gfsdk_float4* outDisplacements, UINT numSamples);
 	HRESULT getTimings(NVWaveWorks_FFT_Simulation_Timings&) const;
 	gfsdk_U64 getDisplacementMapVersion() const { return m_DisplacementMapVersion; }
-	LPDIRECT3DTEXTURE9 GetDisplacementMapD3D9();
-	ID3D10ShaderResourceView** GetDisplacementMapD3D10();
 	ID3D11ShaderResourceView** GetDisplacementMapD3D11();
 	GLuint GetDisplacementMapGL2();
 
diff --git a/src/FFT_Simulation_Manager.h b/src/FFT_Simulation_Manager.h
index d010ea2..d865a65 100644
--- a/src/FFT_Simulation_Manager.h
+++ b/src/FFT_Simulation_Manager.h
@@ -47,8 +47,6 @@ public:
 
 	virtual ~NVWaveWorks_FFT_Simulation_Manager() {};
 
-	virtual HRESULT initD3D9(IDirect3DDevice9* /*pD3DDevice*/) { return S_OK; }
-    virtual HRESULT initD3D10(ID3D10Device* /*pD3DDevice*/)    { return S_OK; }
     virtual HRESULT initD3D11(ID3D11Device* /*pD3DDevice*/)    { return S_OK; }
     virtual HRESULT initGL2(void* /*pGLContext*/)			   { return S_OK; }
 	virtual HRESULT initNoGraphics()                           { return S_OK; }
diff --git a/src/FFT_Simulation_Manager_CUDA.cpp b/src/FFT_Simulation_Manager_CUDA.cpp
index c6aae8a..9cda0ed 100644
--- a/src/FFT_Simulation_Manager_CUDA.cpp
+++ b/src/FFT_Simulation_Manager_CUDA.cpp
@@ -69,20 +69,6 @@ void NVWaveWorks_FFT_Simulation_Manager_CUDA_Impl::releaseAll()
 
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			SAFE_RELEASE(m_d3d._9.m_pd3d9Device);
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			SAFE_RELEASE(m_d3d._10.m_pd3d10Device);
-        }
-		break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -101,76 +87,6 @@ void NVWaveWorks_FFT_Simulation_Manager_CUDA_Impl::releaseAll()
 	m_numCudaDevices = 0;
 }
 
-HRESULT NVWaveWorks_FFT_Simulation_Manager_CUDA_Impl::initD3D9(IDirect3DDevice9* pD3DDevice)
-{
-#if WAVEWORKS_ENABLE_D3D9
-    if(nv_water_d3d_api_d3d9 != m_d3dAPI)
-    {
-        releaseAll();
-    }
-    else if(m_d3d._9.m_pd3d9Device != pD3DDevice)
-    {
-        releaseAll();
-    }
-
-    if(nv_water_d3d_api_undefined == m_d3dAPI)
-    {
-        m_d3dAPI = nv_water_d3d_api_d3d9;
-        m_d3d._9.m_pd3d9Device = pD3DDevice;
-        m_d3d._9.m_pd3d9Device->AddRef();
-
-		CUDA_V_RETURN(cudaD3D9GetDevices(&m_numCudaDevices, NULL, 0, pD3DDevice, cudaD3D9DeviceListAll));
-		int* pCudaDevices = (int*)_alloca(m_numCudaDevices * sizeof(int));
-		CUDA_V_RETURN(cudaD3D9GetDevices(&m_numCudaDevices, pCudaDevices, m_numCudaDevices, pD3DDevice, cudaD3D9DeviceListAll));
-		m_pCudaDeviceInfos = new CudaDeviceInfo[m_numCudaDevices];
-		memset(m_pCudaDeviceInfos, 0, m_numCudaDevices * sizeof(CudaDeviceInfo));
-		for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-		{
-			m_pCudaDeviceInfos[cuda_dev_index].m_cudaDevice = pCudaDevices[cuda_dev_index];
-		}
-    }
-
-    return S_OK;
-#else
-    return E_FAIL;
-#endif
-}
-
-HRESULT NVWaveWorks_FFT_Simulation_Manager_CUDA_Impl::initD3D10(ID3D10Device* pD3DDevice)
-{
-#if WAVEWORKS_ENABLE_D3D10
-    if(nv_water_d3d_api_d3d10 != m_d3dAPI)
-    {
-        releaseAll();
-    }
-    else if(m_d3d._10.m_pd3d10Device != pD3DDevice)
-    {
-        releaseAll();
-    }
-
-    if(nv_water_d3d_api_undefined == m_d3dAPI)
-    {
-        m_d3dAPI = nv_water_d3d_api_d3d10;
-        m_d3d._10.m_pd3d10Device = pD3DDevice;
-        m_d3d._10.m_pd3d10Device->AddRef();
-
-		CUDA_V_RETURN(cudaD3D10GetDevices(&m_numCudaDevices, NULL, 0, pD3DDevice, cudaD3D10DeviceListAll));
-		int* pCudaDevices = (int*)_alloca(m_numCudaDevices * sizeof(int));
-		CUDA_V_RETURN(cudaD3D10GetDevices(&m_numCudaDevices, pCudaDevices, m_numCudaDevices, pD3DDevice, cudaD3D10DeviceListAll));
-		m_pCudaDeviceInfos = new CudaDeviceInfo[m_numCudaDevices];
-		memset(m_pCudaDeviceInfos, 0, m_numCudaDevices * sizeof(CudaDeviceInfo));
-		for(unsigned int cuda_dev_index = 0; cuda_dev_index != m_numCudaDevices; ++cuda_dev_index)
-		{
-			m_pCudaDeviceInfos[cuda_dev_index].m_cudaDevice = pCudaDevices[cuda_dev_index];
-		}
-    }
-
-    return S_OK;
-#else
-    return E_FAIL;
-#endif
-}
-
 HRESULT NVWaveWorks_FFT_Simulation_Manager_CUDA_Impl::initD3D11(ID3D11Device* pD3DDevice)
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -392,24 +308,6 @@ HRESULT NVWaveWorks_FFT_Simulation_Manager_CUDA_Impl::kick(Graphics_Context* /*p
 		// Multiple devices, we will have to do it the 'long' way
 		switch(m_d3dAPI)
 		{
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			{
-				unsigned int cuda_device_count = 0;
-				CUDA_V_RETURN(cudaD3D9GetDevices(&cuda_device_count, &cuda_device, 1, m_d3d._9.m_pd3d9Device, cudaD3D9DeviceListCurrentFrame));
-				CUDA_V_RETURN(cudaSetDevice(cuda_device));
-				break;
-			}
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			{
-				unsigned int cuda_device_count = 0;
-				CUDA_V_RETURN(cudaD3D10GetDevices(&cuda_device_count, &cuda_device, 1, m_d3d._10.m_pd3d10Device, cudaD3D10DeviceListCurrentFrame));
-				CUDA_V_RETURN(cudaSetDevice(cuda_device));
-				break;
-			}
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			{
@@ -494,34 +392,6 @@ HRESULT NVWaveWorks_FFT_Simulation_Manager_CUDA_Impl::mapInteropResources(const
 {
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		{
-			const int num_resources = m_Simulations.size();
-			IDirect3DResource9** pInteropResources = (IDirect3DResource9**)alloca(sizeof(IDirect3DResource9*)*num_resources);
-			int i = 0;
-			for(NVWaveWorks_FFT_Simulation_CUDA_Impl** pSim = m_Simulations.begin(); pSim != m_Simulations.end(); ++pSim, ++i)
-			{
-				pInteropResources[i] = (*pSim)->getD3D9InteropResource(m_activeCudaDeviceIndex);
-			}
-			CUDA_V_RETURN(cudaD3D9MapResources(num_resources, pInteropResources));	// @TODO: why no cu_stream?
-			break;
-		}
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		{
-			const int num_resources = m_Simulations.size();
-			ID3D10Resource** pInteropResources = (ID3D10Resource**)alloca(sizeof(ID3D10Resource*)*num_resources);
-			int i = 0;
-			for(NVWaveWorks_FFT_Simulation_CUDA_Impl** pSim = m_Simulations.begin(); pSim != m_Simulations.end(); ++pSim, ++i)
-			{
-				pInteropResources[i] = (*pSim)->getD3D10InteropResource(m_activeCudaDeviceIndex);
-			}
-			CUDA_V_RETURN(cudaD3D10MapResources(num_resources, pInteropResources));	// @TODO: why no cu_stream?
-			break;
-		}
-#endif
 #if WAVEWORKS_ENABLE_D3D11 || WAVEWORKS_ENABLE_GL
 	case nv_water_d3d_api_d3d11:
 	case nv_water_d3d_api_gl2:
@@ -553,34 +423,6 @@ HRESULT NVWaveWorks_FFT_Simulation_Manager_CUDA_Impl::unmapInteropResources(cons
 {
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		{
-			const int num_resources = m_Simulations.size();
-			IDirect3DResource9** pInteropResources = (IDirect3DResource9**)alloca(sizeof(IDirect3DResource9*)*num_resources);
-			int i = 0;
-			for(NVWaveWorks_FFT_Simulation_CUDA_Impl** pSim = m_Simulations.begin(); pSim != m_Simulations.end(); ++pSim, ++i)
-			{
-				pInteropResources[i] = (*pSim)->getD3D9InteropResource(m_activeCudaDeviceIndex);
-			}
-			CUDA_V_RETURN(cudaD3D9UnmapResources(num_resources, pInteropResources));	// @TODO: why no cu_stream?
-			break;
-		}
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		{
-			const int num_resources = m_Simulations.size();
-			ID3D10Resource** pInteropResources = (ID3D10Resource**)alloca(sizeof(ID3D10Resource*)*num_resources);
-			int i = 0;
-			for(NVWaveWorks_FFT_Simulation_CUDA_Impl** pSim = m_Simulations.begin(); pSim != m_Simulations.end(); ++pSim, ++i)
-			{
-				pInteropResources[i] = (*pSim)->getD3D10InteropResource(m_activeCudaDeviceIndex);
-			}
-			CUDA_V_RETURN(cudaD3D10UnmapResources(num_resources, pInteropResources));	// @TODO: why no cu_stream?
-			break;
-		}
-#endif
 #if WAVEWORKS_ENABLE_D3D11 || WAVEWORKS_ENABLE_GL
 	case nv_water_d3d_api_d3d11:
 	case nv_water_d3d_api_gl2:
diff --git a/src/FFT_Simulation_Manager_CUDA_impl.h b/src/FFT_Simulation_Manager_CUDA_impl.h
index 11ca0f4..9afe0b0 100644
--- a/src/FFT_Simulation_Manager_CUDA_impl.h
+++ b/src/FFT_Simulation_Manager_CUDA_impl.h
@@ -41,8 +41,6 @@ public:
 	NVWaveWorks_FFT_Simulation_Manager_CUDA_Impl();
 	~NVWaveWorks_FFT_Simulation_Manager_CUDA_Impl();
 
-    virtual HRESULT initD3D9(IDirect3DDevice9* pD3DDevice);
-    virtual HRESULT initD3D10(ID3D10Device* pD3DDevice);
     virtual HRESULT initD3D11(ID3D11Device* pD3DDevice);
 	virtual HRESULT initGL2(void* pGLContext);
 	virtual HRESULT initNoGraphics();
@@ -112,20 +110,6 @@ private:
 	// D3D API handling
 	nv_water_d3d_api m_d3dAPI;
 
-#if WAVEWORKS_ENABLE_D3D9
-    struct D3D9Objects
-    {
-		IDirect3DDevice9* m_pd3d9Device;
-    };
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-    struct D3D10Objects
-    {
-		ID3D10Device* m_pd3d10Device;
-    };
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
     struct D3D11Objects
     {
@@ -140,14 +124,6 @@ private:
 #endif
     union
     {
-#if WAVEWORKS_ENABLE_D3D9
-        D3D9Objects _9;
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-        D3D10Objects _10;
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
 		D3D11Objects _11;
 #endif
diff --git a/src/GFX_Timer.cpp b/src/GFX_Timer.cpp
index acc5ad9..e4566d3 100644
--- a/src/GFX_Timer.cpp
+++ b/src/GFX_Timer.cpp
@@ -182,20 +182,6 @@ namespace
 		UINT64 m_freqResult;
 		HRESULT m_status;
 
-#if WAVEWORKS_ENABLE_D3D9
-		struct D3D9Objects
-		{
-			IDirect3DQuery9* m_pDisjointTimerQuery;
-			IDirect3DQuery9* m_pTimerFreqQuery;
-		};
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-		struct D3D10Objects
-		{
-			ID3D10Query* m_pDisjointTimerQuery;
-		};
-#endif
 
 #if WAVEWORKS_ENABLE_D3D11
 		struct D3D11Objects
@@ -206,12 +192,6 @@ namespace
 
 		union
 		{
-#if WAVEWORKS_ENABLE_D3D9
-			D3D9Objects _9;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-			D3D10Objects _10;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 			D3D11Objects _11;
 #endif
@@ -224,20 +204,6 @@ namespace
 		UINT64 m_timestampResult;
 		HRESULT m_status;
 
-#if WAVEWORKS_ENABLE_D3D9
-		struct D3D9Objects
-		{
-			IDirect3DQuery9* m_pTimerQuery;
-		};
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-		struct D3D10Objects
-		{
-			ID3D10Query* m_pTimerQuery;
-		};
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
 		struct D3D11Objects
 		{
@@ -252,12 +218,6 @@ namespace
 #endif
 		union
 		{
-#if WAVEWORKS_ENABLE_D3D9
-			D3D9Objects _9;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-			D3D10Objects _10;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 			D3D11Objects _11;
 #endif
@@ -291,65 +251,6 @@ NVWaveWorks_GFX_Timer_Impl::~NVWaveWorks_GFX_Timer_Impl()
 	releaseAll();
 }
 
-HRESULT NVWaveWorks_GFX_Timer_Impl::initD3D9(IDirect3DDevice9* D3D9_ONLY(pD3DDevice))
-{
-#if WAVEWORKS_ENABLE_D3D9
-    HRESULT hr;
-
-    if(nv_water_d3d_api_d3d9 != m_d3dAPI)
-    {
-        releaseAll();
-    }
-    else if(m_d3d._9.m_pd3d9Device != pD3DDevice)
-    {
-        releaseAll();
-    }
-
-    if(nv_water_d3d_api_undefined == m_d3dAPI)
-    {
-        m_d3dAPI = nv_water_d3d_api_d3d9;
-        m_d3d._9.m_pd3d9Device = pD3DDevice;
-        m_d3d._9.m_pd3d9Device->AddRef();
-
-        V_RETURN(allocateAllResources());
-    }
-
-    return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-
-HRESULT NVWaveWorks_GFX_Timer_Impl::initD3D10(ID3D10Device* D3D10_ONLY(pD3DDevice))
-{
-#if WAVEWORKS_ENABLE_D3D10
-    HRESULT hr;
-
-    if(nv_water_d3d_api_d3d10 != m_d3dAPI)
-    {
-        releaseAll();
-    }
-    else if(m_d3d._10.m_pd3d10Device != pD3DDevice)
-    {
-        releaseAll();
-    }
-
-    if(nv_water_d3d_api_undefined == m_d3dAPI)
-    {
-        m_d3dAPI = nv_water_d3d_api_d3d10;
-        m_d3d._10.m_pd3d10Device = pD3DDevice;
-        m_d3d._10.m_pd3d10Device->AddRef();
-
-        V_RETURN(allocateAllResources());
-    }
-
-    return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
 HRESULT NVWaveWorks_GFX_Timer_Impl::initD3D11(ID3D11Device* D3D11_ONLY(pD3DDevice))
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -432,20 +333,6 @@ void NVWaveWorks_GFX_Timer_Impl::releaseAll()
 #if WAVEWORKS_ENABLE_GRAPHICS
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			SAFE_RELEASE(m_d3d._9.m_pd3d9Device);
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			SAFE_RELEASE(m_d3d._10.m_pd3d10Device);
-        }
-        break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -474,39 +361,7 @@ void NVWaveWorks_GFX_Timer_Impl::releaseAllResources()
 #if WAVEWORKS_ENABLE_GRAPHICS
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			for(int i = 0; i != m_pDisjointTimersPool->getNumQueries(); ++i)
-			{
-				DisjointQueryData& dqd = m_pDisjointTimersPool->getQueryData(i);
-				SAFE_RELEASE(dqd.m_d3d._9.m_pDisjointTimerQuery);
-				SAFE_RELEASE(dqd.m_d3d._9.m_pTimerFreqQuery);
-			}
-			for(int i = 0; i != m_pTimersPool->getNumQueries(); ++i)
-			{
-				TimerQueryData& tqd = m_pTimersPool->getQueryData(i);
-				SAFE_RELEASE(tqd.m_d3d._9.m_pTimerQuery);
-			}
-		}
-		break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			for(int i = 0; i != m_pDisjointTimersPool->getNumQueries(); ++i)
-			{
-				DisjointQueryData& dqd = m_pDisjointTimersPool->getQueryData(i);
-				SAFE_RELEASE(dqd.m_d3d._10.m_pDisjointTimerQuery);
-			}
-			for(int i = 0; i != m_pTimersPool->getNumQueries(); ++i)
-			{
-				TimerQueryData& tqd = m_pTimersPool->getQueryData(i);
-				SAFE_RELEASE(tqd.m_d3d._10.m_pTimerQuery);
-			}
-		}
-		break;
-#endif
+
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -559,28 +414,6 @@ HRESULT NVWaveWorks_GFX_Timer_Impl::issueTimerQuery(Graphics_Context* pGC, int&
 #if WAVEWORKS_ENABLE_GRAPHICS
 		switch(m_d3dAPI)
 		{
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			{
-				HRESULT hr;
-				TimerQueryData& tqd = m_pTimersPool->addInactiveQuery();
-				V_RETURN(m_d3d._9.m_pd3d9Device->CreateQuery(D3DQUERYTYPE_TIMESTAMP , &tqd.m_d3d._9.m_pTimerQuery));
-			}
-			break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			{
-				HRESULT hr;
-				TimerQueryData& tqd = m_pTimersPool->addInactiveQuery();
-
-				D3D10_QUERY_DESC query_desc;
-				query_desc.Query = D3D10_QUERY_TIMESTAMP;
-				query_desc.MiscFlags = 0;
-				V_RETURN(m_d3d._10.m_pd3d10Device->CreateQuery(&query_desc, &tqd.m_d3d._10.m_pTimerQuery));
-			}
-			break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			{
@@ -624,22 +457,7 @@ HRESULT NVWaveWorks_GFX_Timer_Impl::issueTimerQuery(Graphics_Context* pGC, int&
 #if WAVEWORKS_ENABLE_GRAPHICS
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		{
-			const TimerQueryData& tqd = m_pTimersPool->getQueryData(ix);
-			tqd.m_d3d._9.m_pTimerQuery->Issue(D3DISSUE_END);
-		}
-		break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		{
-			const TimerQueryData& tqd = m_pTimersPool->getQueryData(ix);
-			tqd.m_d3d._10.m_pTimerQuery->End();
-		}
-		break;
-#endif
+
 #if WAVEWORKS_ENABLE_D3D11
 	case nv_water_d3d_api_d3d11:
 		{
@@ -693,16 +511,6 @@ HRESULT NVWaveWorks_GFX_Timer_Impl::getTimerQuery(Graphics_Context* pGC, int ix,
 #if WAVEWORKS_ENABLE_GRAPHICS
 		switch(m_d3dAPI)
 		{
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			hr = tqd.m_d3d._9.m_pTimerQuery->GetData(&result, sizeof(result), 0);
-			break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			hr = tqd.m_d3d._10.m_pTimerQuery->GetData(&result, sizeof(result), 0);
-			break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			{
@@ -836,28 +644,7 @@ HRESULT NVWaveWorks_GFX_Timer_Impl::beginDisjoint(Graphics_Context* pGC)
 #if WAVEWORKS_ENABLE_GRAPHICS
 		switch(m_d3dAPI)
 		{
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			{
-				HRESULT hr;
-				DisjointQueryData& dqd = m_pDisjointTimersPool->addInactiveQuery();
-				V_RETURN(m_d3d._9.m_pd3d9Device->CreateQuery(D3DQUERYTYPE_TIMESTAMPDISJOINT , &dqd.m_d3d._9.m_pDisjointTimerQuery));
-				V_RETURN(m_d3d._9.m_pd3d9Device->CreateQuery(D3DQUERYTYPE_TIMESTAMPFREQ  , &dqd.m_d3d._9.m_pTimerFreqQuery));
-			}
-			break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			{
-				HRESULT hr;
-				DisjointQueryData& dqd = m_pDisjointTimersPool->addInactiveQuery();
-				D3D10_QUERY_DESC query_desc;
-				query_desc.Query = D3D10_QUERY_TIMESTAMP_DISJOINT;
-				query_desc.MiscFlags = 0;
-				V_RETURN(m_d3d._10.m_pd3d10Device->CreateQuery(&query_desc, &dqd.m_d3d._10.m_pDisjointTimerQuery));
-			}
-			break;
-#endif
+
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			{
@@ -902,22 +689,6 @@ HRESULT NVWaveWorks_GFX_Timer_Impl::beginDisjoint(Graphics_Context* pGC)
 #if WAVEWORKS_ENABLE_GRAPHICS
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		{
-			const DisjointQueryData& dqd = m_pDisjointTimersPool->getQueryData(m_CurrentDisjointTimerQuery);
-			dqd.m_d3d._9.m_pDisjointTimerQuery->Issue(D3DISSUE_BEGIN);
-		}
-		break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		{
-			const DisjointQueryData& dqd = m_pDisjointTimersPool->getQueryData(m_CurrentDisjointTimerQuery);
-			dqd.m_d3d._10.m_pDisjointTimerQuery->Begin();
-		}
-		break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 	case nv_water_d3d_api_d3d11:
 		{
@@ -959,23 +730,7 @@ HRESULT NVWaveWorks_GFX_Timer_Impl::endDisjoint(Graphics_Context* pGC)
 #if WAVEWORKS_ENABLE_GRAPHICS
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		{
-			const DisjointQueryData& dqd = m_pDisjointTimersPool->getQueryData(m_CurrentDisjointTimerQuery);
-			dqd.m_d3d._9.m_pTimerFreqQuery->Issue(D3DISSUE_END);
-			dqd.m_d3d._9.m_pDisjointTimerQuery->Issue(D3DISSUE_END);
-		}
-		break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		{
-			const DisjointQueryData& dqd = m_pDisjointTimersPool->getQueryData(m_CurrentDisjointTimerQuery);
-			dqd.m_d3d._10.m_pDisjointTimerQuery->End();
-		}
-		break;
-#endif
+
 #if WAVEWORKS_ENABLE_D3D11
 	case nv_water_d3d_api_d3d11:
 		{
@@ -1039,28 +794,6 @@ HRESULT NVWaveWorks_GFX_Timer_Impl::getDisjointQuery(Graphics_Context* pGC, int
 #if WAVEWORKS_ENABLE_GRAPHICS
 		switch(m_d3dAPI)
 		{
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			{
-				hr = dqd.m_d3d._9.m_pDisjointTimerQuery->GetData(&WasDisjoint, sizeof(WasDisjoint), 0);
-				if(S_OK == hr)
-				{
-					hr = dqd.m_d3d._9.m_pTimerFreqQuery->GetData(&RawF, sizeof(RawF), 0);
-				}
-			}
-			break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			{
-				D3D10_QUERY_DATA_TIMESTAMP_DISJOINT result;
-				hr = dqd.m_d3d._10.m_pDisjointTimerQuery->GetData(&result, sizeof(result), 0);
-
-				RawF = result.Frequency;
-				WasDisjoint = result.Disjoint;
-			}
-			break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			{
diff --git a/src/GFX_Timer_impl.h b/src/GFX_Timer_impl.h
index 0d33a5f..eeb0093 100644
--- a/src/GFX_Timer_impl.h
+++ b/src/GFX_Timer_impl.h
@@ -39,8 +39,6 @@ public:
 	NVWaveWorks_GFX_Timer_Impl();
 	~NVWaveWorks_GFX_Timer_Impl();
 
-    HRESULT initD3D9(IDirect3DDevice9* pD3DDevice);
-    HRESULT initD3D10(ID3D10Device* pD3DDevice);
 	HRESULT initD3D11(ID3D11Device* pD3DDevice);
 	HRESULT initGnm();
 	HRESULT initGL2(void* pGLContext);
@@ -79,20 +77,6 @@ private:
 	// D3D API handling
 	nv_water_d3d_api m_d3dAPI;
 
-#if WAVEWORKS_ENABLE_D3D9
-    struct D3D9Objects
-    {
-		IDirect3DDevice9* m_pd3d9Device;
-	};
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-    struct D3D10Objects
-    {
-		ID3D10Device* m_pd3d10Device;
-	};
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
     struct D3D11Objects
     {
@@ -113,12 +97,6 @@ private:
 #endif
 	union
     {
-#if WAVEWORKS_ENABLE_D3D9
-		D3D9Objects _9;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		D3D10Objects _10;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		D3D11Objects _11;
 #endif
diff --git a/src/Internal.h b/src/Internal.h
index a2746e8..a7a73e7 100644
--- a/src/Internal.h
+++ b/src/Internal.h
@@ -174,7 +174,6 @@
 #else // TARGET_PLATFORM_XBONE
 #include <dxgi.h>
 #include <d3d11.h>
-#include <d3d9.h>
 
 // Check we're building against a recent-enough WinSDK
 #include <winsdkver.h>
@@ -402,18 +401,6 @@ void handle_hr_error(HRESULT hr, const char_type* file, int line);
 #define WAVEWORKS_ALLOW_GFX 1
 #endif
 
-#if D3D_SDK_VERSION
-#define WAVEWORKS_ENABLE_D3D9 WAVEWORKS_ALLOW_GFX
-#else
-#define WAVEWORKS_ENABLE_D3D9 0
-#endif
-
-#ifdef D3D10_SDK_VERSION
-#define WAVEWORKS_ENABLE_D3D10 WAVEWORKS_ALLOW_GFX
-#else
-#define WAVEWORKS_ENABLE_D3D10 0
-#endif
-
 #ifdef D3D11_SDK_VERSION
 #define WAVEWORKS_ENABLE_D3D11 WAVEWORKS_ALLOW_GFX
 #else
@@ -440,7 +427,7 @@ void handle_hr_error(HRESULT hr, const char_type* file, int line);
 #endif
 #endif
 
-#define WAVEWORKS_ENABLE_GRAPHICS (WAVEWORKS_ENABLE_D3D9 || WAVEWORKS_ENABLE_D3D10 || WAVEWORKS_ENABLE_D3D11 || WAVEWORKS_ENABLE_GNM || WAVEWORKS_ENABLE_GL)
+#define WAVEWORKS_ENABLE_GRAPHICS (WAVEWORKS_ENABLE_D3D11 || WAVEWORKS_ENABLE_GNM || WAVEWORKS_ENABLE_GL)
 
 #ifndef SUPPORT_CUDA
 	typedef struct
@@ -467,14 +454,6 @@ void handle_hr_error(HRESULT hr, const char_type* file, int line);
 
 	#pragma warning( pop )
 
-	#if WAVEWORKS_ENABLE_D3D9
-	#include <cuda_d3d9_interop.h>
-	#endif
-
-	#if WAVEWORKS_ENABLE_D3D10
-	#include <cuda_d3d10_interop.h>
-	#endif
-
 	#if WAVEWORKS_ENABLE_D3D11
 	#include <cuda_d3d11_interop.h>
 	#endif
@@ -568,8 +547,6 @@ enum nv_water_d3d_api
 {
 	nv_water_d3d_api_undefined = 0,
 	nv_water_d3d_api_none,				// Meaning: initialise and run without graphics e.g. server-mode
-	nv_water_d3d_api_d3d9,
-	nv_water_d3d_api_d3d10,
 	nv_water_d3d_api_d3d11,
 	nv_water_d3d_api_gnm,
 	nv_water_d3d_api_gl2
@@ -779,18 +756,6 @@ extern GFSDK_WAVEWORKS_GLFunctions		  NVSDK_GLFunctions;
 #define GL_MAP_UNSYNCHRONIZED_BIT         0x0020
 
 
-#if WAVEWORKS_ENABLE_D3D9
-#define D3D9_ONLY(x) x
-#else
-#define D3D9_ONLY(x)
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-#define D3D10_ONLY(x) x
-#else
-#define D3D10_ONLY(x)
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
 #define D3D11_ONLY(x) x
 #else
diff --git a/src/Mesh.cpp b/src/Mesh.cpp
index 36480d5..1fc0da0 100644
--- a/src/Mesh.cpp
+++ b/src/Mesh.cpp
@@ -36,100 +36,6 @@
 #endif
 using namespace sce;
 
-#if WAVEWORKS_ENABLE_D3D9
-////////////////////////////////////////////////////////////////////////////////
-// D3D9 implementation
-////////////////////////////////////////////////////////////////////////////////
-class NVWaveWorks_MeshD3D9 : public NVWaveWorks_Mesh
-{
-public:
-
-	~NVWaveWorks_MeshD3D9();
-
-	HRESULT LockVertexBuffer(LPVOID* ppData);
-	HRESULT UnlockVertexBuffer();
-
-	HRESULT LockIndexBuffer(LPDWORD* ppData);
-	HRESULT UnlockIndexBuffer();
-
-	virtual HRESULT Draw(	Graphics_Context* pGC,
-							PrimitiveType PrimType,
-							INT BaseVertexIndex,
-							UINT MinIndex,
-							UINT NumVertices,
-							UINT StartIndex,
-							UINT PrimitiveCount,
-							const UINT* pShaderInputMappings
-							);
-
-	virtual HRESULT PreserveState(Graphics_Context* pGC, GFSDK_WaveWorks_Savestate* pSavestateImpl);
-
-private:
-
-	friend class NVWaveWorks_Mesh;	// For creation
-	NVWaveWorks_MeshD3D9(	LPDIRECT3DDEVICE9 pD3DDevice,
-							LPDIRECT3DVERTEXDECLARATION9 pDecl,
-							LPDIRECT3DVERTEXBUFFER9 pVertexBuffer,
-							LPDIRECT3DINDEXBUFFER9 pIndexBuffer,
-							UINT VertexStride
-							);
-
-	LPDIRECT3DDEVICE9 m_pd3dDevice;
-	LPDIRECT3DVERTEXDECLARATION9 m_pDecl;
-	LPDIRECT3DVERTEXBUFFER9 m_pVB;
-	LPDIRECT3DINDEXBUFFER9 m_pIB;
-	UINT m_VertexStride;
-
-	// Revoked copy/assign
-	NVWaveWorks_MeshD3D9(const NVWaveWorks_MeshD3D9&);
-	NVWaveWorks_MeshD3D9& operator=(const NVWaveWorks_MeshD3D9&);
-};
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-////////////////////////////////////////////////////////////////////////////////
-// D3D10 implementation
-////////////////////////////////////////////////////////////////////////////////
-class NVWaveWorks_MeshD3D10 : public NVWaveWorks_Mesh
-{
-public:
-
-	~NVWaveWorks_MeshD3D10();
-
-	virtual HRESULT Draw(	Graphics_Context* pGC,
-							PrimitiveType PrimType,
-							INT BaseVertexIndex,
-							UINT MinIndex,
-							UINT NumVertices,
-							UINT StartIndex,
-							UINT PrimitiveCount,
-							const UINT* pShaderInputMappings
-							);
-
-	virtual HRESULT PreserveState(Graphics_Context* pGC, GFSDK_WaveWorks_Savestate* pSavestateImpl);
-
-private:
-
-	friend class NVWaveWorks_Mesh;	// For creation
-	NVWaveWorks_MeshD3D10(	ID3D10Device* pD3DDevice,
-							ID3D10InputLayout* pLayout,
-							ID3D10Buffer* pVertexBuffer,
-							ID3D10Buffer* pIndexBuffer,
-							UINT VertexStride
-							);
-
-	ID3D10Device* m_pd3dDevice;
-	ID3D10InputLayout* m_pLayout;
-	ID3D10Buffer* m_pVB;
-	ID3D10Buffer* m_pIB;
-	UINT m_VertexStride;
-
-	// Revoked copy/assign
-	NVWaveWorks_MeshD3D10(const NVWaveWorks_MeshD3D10&);
-	NVWaveWorks_MeshD3D10& operator=(const NVWaveWorks_MeshD3D10&);
-};
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
 ////////////////////////////////////////////////////////////////////////////////
 // D3D11 implementation
@@ -258,112 +164,6 @@ private:
 	NVWaveWorks_MeshGL2& operator=(const NVWaveWorks_MeshGL2&);
 };
 #endif
-HRESULT NVWaveWorks_Mesh::CreateD3D9(	IDirect3DDevice9* D3D9_ONLY(pD3DDev),
-										const D3DVERTEXELEMENT9* D3D9_ONLY(pVertexElements),
-										UINT D3D9_ONLY(VertexStride),
-										const void* D3D9_ONLY(pVertData),
-										UINT D3D9_ONLY(NumVerts),
-										const DWORD* D3D9_ONLY(pIndexData),
-										UINT D3D9_ONLY(NumIndices),
-										NVWaveWorks_Mesh** D3D9_ONLY(ppMesh)
-										)
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	LPDIRECT3DVERTEXDECLARATION9 pDecl = NULL;
-	V_RETURN(pD3DDev->CreateVertexDeclaration(pVertexElements, &pDecl));
-
-	LPDIRECT3DVERTEXBUFFER9 pVB = NULL;
-	V_RETURN(pD3DDev->CreateVertexBuffer(NumVerts * VertexStride, D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &pVB, NULL));
-
-	LPDIRECT3DINDEXBUFFER9 pIB = NULL;
-	V_RETURN(pD3DDev->CreateIndexBuffer(NumIndices * sizeof(DWORD), D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT, &pIB, NULL));
-
-	NVWaveWorks_MeshD3D9* pMesh = new NVWaveWorks_MeshD3D9(pD3DDev, pDecl, pVB, pIB, VertexStride);
-
-	pDecl->Release();
-	pVB->Release();
-	pIB->Release();
-
-	void* pV = NULL;
-	V_RETURN(pMesh->LockVertexBuffer(&pV));
-	memcpy(pV, pVertData, VertexStride * NumVerts);
-	V_RETURN(pMesh->UnlockVertexBuffer());
-
-	DWORD* pI = NULL;
-	V_RETURN(pMesh->LockIndexBuffer(&pI));
-	memcpy(pI, pIndexData, sizeof(DWORD) * NumIndices);
-	V_RETURN(pMesh->UnlockIndexBuffer());
-
-	*ppMesh = pMesh;
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT NVWaveWorks_Mesh::CreateD3D10(	ID3D10Device* D3D10_ONLY(pD3DDev),
-										const D3D10_INPUT_ELEMENT_DESC * D3D10_ONLY(pInputElementDescs),
-										UINT D3D10_ONLY(NumElements),
-										const void * D3D10_ONLY(pShaderBytecodeWithInputSignature),
-										SIZE_T D3D10_ONLY(BytecodeLength),
-										UINT D3D10_ONLY(VertexStride),
-										const void* D3D10_ONLY(pVertData),
-										UINT D3D10_ONLY(NumVerts),
-										const DWORD* D3D10_ONLY(pIndexData),
-										UINT D3D10_ONLY(NumIndices),
-										NVWaveWorks_Mesh** D3D10_ONLY(ppMesh)
-										)
-{
-#if WAVEWORKS_ENABLE_D3D10
-	HRESULT hr;
-
-	ID3D10InputLayout* pLayout = NULL;
-	V_RETURN(pD3DDev->CreateInputLayout(pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, &pLayout));
-
-	ID3D10Buffer* pVB = NULL;
-	D3D10_BUFFER_DESC vbDesc;
-	vbDesc.ByteWidth = NumVerts * VertexStride;
-	vbDesc.Usage = D3D10_USAGE_IMMUTABLE;
-	vbDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
-	vbDesc.CPUAccessFlags = 0;
-	vbDesc.MiscFlags = 0;
-
-	D3D10_SUBRESOURCE_DATA vSrd;
-	vSrd.pSysMem = pVertData;
-	vSrd.SysMemPitch = 0;
-	vSrd.SysMemSlicePitch = 0;
-
-	V_RETURN(pD3DDev->CreateBuffer(&vbDesc, &vSrd, &pVB));
-
-	ID3D10Buffer* pIB = NULL;
-	D3D10_BUFFER_DESC ibDesc;
-	ibDesc.ByteWidth = NumIndices * sizeof(DWORD);
-	ibDesc.Usage = D3D10_USAGE_IMMUTABLE;
-	ibDesc.BindFlags = D3D10_BIND_INDEX_BUFFER;
-	ibDesc.CPUAccessFlags = 0;
-	ibDesc.MiscFlags = 0;
-
-	D3D10_SUBRESOURCE_DATA iSrd;
-	iSrd.pSysMem = pIndexData;
-	iSrd.SysMemPitch = 0;
-	iSrd.SysMemSlicePitch = 0;
-
-	V_RETURN(pD3DDev->CreateBuffer(&ibDesc, &iSrd, &pIB));
-
-	*ppMesh = new NVWaveWorks_MeshD3D10(pD3DDev, pLayout, pVB, pIB, VertexStride);
-
-	pLayout->Release();
-	pVB->Release();
-	pIB->Release();
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
 
 HRESULT NVWaveWorks_Mesh::CreateD3D11(	ID3D11Device* D3D11_ONLY(pD3DDev),
 										const D3D11_INPUT_ELEMENT_DESC * D3D11_ONLY(pInputElementDescs),
@@ -468,171 +268,6 @@ HRESULT NVWaveWorks_Mesh::CreateGnm(UINT GNM_ONLY(VertexStride),
 #endif
 }
 
-#if WAVEWORKS_ENABLE_D3D9
-NVWaveWorks_MeshD3D9::~NVWaveWorks_MeshD3D9()
-{
-	m_pd3dDevice->Release();
-	m_pDecl->Release();
-	m_pVB->Release();
-	m_pIB->Release();
-}
-
-HRESULT NVWaveWorks_MeshD3D9::LockVertexBuffer(LPVOID* ppData)
-{
-	return m_pVB->Lock(0,0,ppData,0);
-}
-
-HRESULT NVWaveWorks_MeshD3D9::UnlockVertexBuffer()
-{
-	return m_pVB->Unlock();
-}
-
-HRESULT NVWaveWorks_MeshD3D9::LockIndexBuffer(LPDWORD* ppData)
-{
-	return m_pIB->Lock(0,0,(VOID**)ppData,0);
-}
-
-HRESULT NVWaveWorks_MeshD3D9::UnlockIndexBuffer()
-{
-	return m_pIB->Unlock();
-}
-
-HRESULT NVWaveWorks_MeshD3D9::PreserveState(Graphics_Context* /*pGC not used*/, GFSDK_WaveWorks_Savestate* pSavestateImpl)
-{
-	HRESULT hr;
-
-	V_RETURN(pSavestateImpl->PreserveD3D9Streams());
-
-	return S_OK;
-}
-
-HRESULT NVWaveWorks_MeshD3D9::Draw(	Graphics_Context* /*pGC not used*/,
-									PrimitiveType PrimType,
-									INT BaseVertexIndex,
-									UINT MinIndex,
-									UINT NumVertices,
-									UINT StartIndex,
-									UINT PrimitiveCount,
-									const UINT* /* not used: pShaderInputMappings*/
-									)
-{
-	HRESULT hr;
-
-	V_RETURN(m_pd3dDevice->SetVertexDeclaration(m_pDecl));
-	V_RETURN(m_pd3dDevice->SetStreamSource(0, m_pVB, 0, m_VertexStride));
-	V_RETURN(m_pd3dDevice->SetIndices(m_pIB));
-
-	D3DPRIMITIVETYPE d3dPrimType = D3DPT_FORCE_DWORD;
-	switch(PrimType)
-	{
-	case PT_TriangleStrip:
-		d3dPrimType = D3DPT_TRIANGLESTRIP;
-		break;
-	case PT_TriangleList:
-		d3dPrimType = D3DPT_TRIANGLELIST;
-		break;
-	default:
-		return E_FAIL;
-	}
-
-	V_RETURN(m_pd3dDevice->DrawIndexedPrimitive(d3dPrimType, BaseVertexIndex, MinIndex, NumVertices, StartIndex, PrimitiveCount));
-
-	return S_OK;
-}
-
-NVWaveWorks_MeshD3D9::NVWaveWorks_MeshD3D9(	LPDIRECT3DDEVICE9 pD3DDevice,
-											LPDIRECT3DVERTEXDECLARATION9 pDecl,
-											LPDIRECT3DVERTEXBUFFER9 pVertexBuffer,
-											LPDIRECT3DINDEXBUFFER9 pIndexBuffer,
-											UINT VertexStride
-											) :
-	m_pd3dDevice(pD3DDevice),
-	m_pDecl(pDecl),
-	m_pVB(pVertexBuffer),
-	m_pIB(pIndexBuffer),
-	m_VertexStride(VertexStride)
-{
-	m_pd3dDevice->AddRef();
-	m_pDecl->AddRef();
-	m_pVB->AddRef();
-	m_pIB->AddRef();
-}
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-NVWaveWorks_MeshD3D10::~NVWaveWorks_MeshD3D10()
-{
-	m_pd3dDevice->Release();
-	m_pLayout->Release();
-	m_pVB->Release();
-	m_pIB->Release();
-}
-
-HRESULT NVWaveWorks_MeshD3D10::PreserveState(Graphics_Context* /*pGC not used*/, GFSDK_WaveWorks_Savestate* pSavestateImpl)
-{
-	HRESULT hr;
-
-	V_RETURN(pSavestateImpl->PreserveD3D10Streams());
-
-	return S_OK;
-}
-
-HRESULT NVWaveWorks_MeshD3D10::Draw(	Graphics_Context* /*pGC not used*/,
-										PrimitiveType PrimType,
-										INT BaseVertexIndex,
-										UINT /*MinIndex*/,
-										UINT /*NumVertices*/,
-										UINT StartIndex,
-										UINT PrimitiveCount,
-										const UINT* /* not used: pShaderInputMappings*/
-										)
-{
-	const UINT VBOffset = 0;
-    m_pd3dDevice->IASetVertexBuffers(0, 1, &m_pVB, &m_VertexStride, &VBOffset);
-    m_pd3dDevice->IASetIndexBuffer(m_pIB, DXGI_FORMAT_R32_UINT, 0);
-	m_pd3dDevice->IASetInputLayout(m_pLayout);
-
-	D3D10_PRIMITIVE_TOPOLOGY d3dPrimTopology = D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED;
-	UINT IndexCount = 0;
-	switch(PrimType)
-	{
-	case PT_TriangleStrip:
-		d3dPrimTopology = D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
-		IndexCount = 2 + PrimitiveCount;
-		break;
-	case PT_TriangleList:
-		d3dPrimTopology = D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
-		IndexCount = 3 * PrimitiveCount;
-		break;
-	default:
-		return E_FAIL;
-	}
-
-	m_pd3dDevice->IASetPrimitiveTopology(d3dPrimTopology);
-	m_pd3dDevice->DrawIndexed(IndexCount, StartIndex, BaseVertexIndex);
-
-	return S_OK;
-}
-
-NVWaveWorks_MeshD3D10::NVWaveWorks_MeshD3D10(	ID3D10Device* pD3DDevice,
-												ID3D10InputLayout* pLayout,
-												ID3D10Buffer* pVertexBuffer,
-												ID3D10Buffer* pIndexBuffer,
-												UINT VertexStride
-												) :
-	m_pd3dDevice(pD3DDevice),
-	m_pLayout(pLayout),
-	m_pVB(pVertexBuffer),
-	m_pIB(pIndexBuffer),
-	m_VertexStride(VertexStride)
-{
-	m_pd3dDevice->AddRef();
-	m_pLayout->AddRef();
-	m_pVB->AddRef();
-	m_pIB->AddRef();
-}
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
 NVWaveWorks_MeshD3D11::~NVWaveWorks_MeshD3D11()
 {
diff --git a/src/Mesh.h b/src/Mesh.h
index ebb67bb..f84580a 100644
--- a/src/Mesh.h
+++ b/src/Mesh.h
@@ -62,29 +62,6 @@ public:
 		GLint Offset;
 	} GL_VERTEX_ATTRIBUTE_DESC;
 
-	static HRESULT CreateD3D9(	IDirect3DDevice9* pD3DDev,
-								const D3DVERTEXELEMENT9* pVertexElements,
-								UINT VertexStride,
-								const void* pVertData,
-								UINT NumVerts,
-								const DWORD* pIndexData,
-								UINT NumIndices,
-								NVWaveWorks_Mesh** ppMesh
-								);
-
-	static HRESULT CreateD3D10(	ID3D10Device* pD3DDev,
-								const D3D10_INPUT_ELEMENT_DESC *pInputElementDescs,
-								UINT NumElements,
-								const void *pShaderBytecodeWithInputSignature,
-								SIZE_T BytecodeLength,
-								UINT VertexStride,
-								const void* pVertData,
-								UINT NumVerts,
-								const DWORD* pIndexData,
-								UINT NumIndices,
-								NVWaveWorks_Mesh** ppMesh
-								);
-
 	static HRESULT CreateD3D11(	ID3D11Device* pD3DDev,
 								const D3D11_INPUT_ELEMENT_DESC *pInputElementDescs,
 								UINT NumElements,
diff --git a/src/Quadtree.cpp b/src/Quadtree.cpp
index daa7d23..7f132db 100644
--- a/src/Quadtree.cpp
+++ b/src/Quadtree.cpp
@@ -71,20 +71,6 @@ namespace SM5 {
 
 }
 
-enum ShaderInputsD3D9
-{
-	ShaderInputD3D9_g_matLocalWorld = 0,
-	ShaderInputD3D9_g_vsEyePos,
-	ShaderInputD3D9_g_MorphParam,
-	NumShaderInputsD3D9
-};
-
-enum ShaderInputsD3D10
-{
-	ShaderInputD3D10_vs_buffer = 0,
-	NumShaderInputsD3D10
-};
-
 enum ShaderInputsD3D11
 {
 	ShaderInputD3D11_vs_buffer = 0,
@@ -108,21 +94,6 @@ enum ShaderInputsGL2
 	NumShaderInputsGL2
 };
 
-// NB: These should be kept synchronised with the shader source
-#if WAVEWORKS_ENABLE_D3D9
-const GFSDK_WaveWorks_ShaderInput_Desc ShaderInputD3D9Descs[NumShaderInputsD3D9] = {
-	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_FloatConstant, "nvsf_g_matLocalWorld", 0 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_FloatConstant, "nvsf_g_vsEyePos",      3 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_FloatConstant, "nvsf_g_MorphParam",    4 }
-};
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-const GFSDK_WaveWorks_ShaderInput_Desc ShaderInputD3D10Descs[NumShaderInputsD3D10] = {
-	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_ConstantBuffer, "nvsf_geom_buffer", 0 }
-};
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
 const GFSDK_WaveWorks_ShaderInput_Desc ShaderInputD3D11Descs[NumShaderInputsD3D11] = {
 	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_ConstantBuffer, "nvsf_geom_buffer", 0 },
@@ -235,23 +206,6 @@ void GFSDK_WaveWorks_Quadtree::releaseD3DObjects()
 #if WAVEWORKS_ENABLE_GRAPHICS
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		{
-			SAFE_RELEASE(m_d3d._9.m_pd3d9Device);
-			m_d3dAPI = nv_water_d3d_api_undefined;
-		}
-		break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		{
-			SAFE_RELEASE(m_d3d._10.m_pd3d10VertexShaderCB);
-			SAFE_RELEASE(m_d3d._10.m_pd3d10Device);
-			m_d3dAPI = nv_water_d3d_api_undefined;
-		}
-		break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 	case nv_water_d3d_api_d3d11:
 		{
@@ -288,28 +242,6 @@ HRESULT GFSDK_WaveWorks_Quadtree::allocateD3DObjects()
 #if WAVEWORKS_ENABLE_GRAPHICS
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		{
-		}
-		break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		{
-			HRESULT hr;
-			SAFE_RELEASE(m_d3d._10.m_pd3d10VertexShaderCB);
-
-			D3D10_BUFFER_DESC vscbDesc;
-			vscbDesc.ByteWidth = sizeof(vs_cbuffer);
-			vscbDesc.Usage = D3D10_USAGE_DEFAULT;
-			vscbDesc.BindFlags = D3D10_BIND_CONSTANT_BUFFER;
-			vscbDesc.CPUAccessFlags = 0;
-			vscbDesc.MiscFlags = 0;
-			V_RETURN(m_d3d._10.m_pd3d10Device->CreateBuffer(&vscbDesc, NULL, &m_d3d._10.m_pd3d10VertexShaderCB));
-		}
-		break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 	case nv_water_d3d_api_d3d11:
 		{
@@ -360,64 +292,6 @@ HRESULT GFSDK_WaveWorks_Quadtree::allocateD3DObjects()
 	return S_OK;
 }
 
-HRESULT GFSDK_WaveWorks_Quadtree::initD3D9(const GFSDK_WaveWorks_Quadtree_Params& D3D9_ONLY(params), IDirect3DDevice9* D3D9_ONLY(pD3DDevice))
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	if(nv_water_d3d_api_d3d9 != m_d3dAPI)
-	{
-		releaseD3DObjects();
-	}
-	else if(m_d3d._9.m_pd3d9Device != pD3DDevice)
-	{
-		releaseD3DObjects();
-	}
-
-	if(nv_water_d3d_api_undefined == m_d3dAPI)
-	{
-		m_d3dAPI = nv_water_d3d_api_d3d9;
-		m_d3d._9.m_pd3d9Device = pD3DDevice;
-		m_d3d._9.m_pd3d9Device->AddRef();
-
-		V_RETURN(allocateD3DObjects());
-	}
-
-	return reinit(params);
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Quadtree::initD3D10(const GFSDK_WaveWorks_Quadtree_Params& D3D10_ONLY(params), ID3D10Device* D3D10_ONLY(pD3DDevice))
-{
-#if WAVEWORKS_ENABLE_D3D10
-	HRESULT hr;
-
-	if(nv_water_d3d_api_d3d10 != m_d3dAPI)
-	{
-		releaseD3DObjects();
-	}
-	else if(m_d3d._10.m_pd3d10Device != pD3DDevice)
-	{
-		releaseD3DObjects();
-	}
-
-	if(nv_water_d3d_api_undefined == m_d3dAPI)
-	{
-		m_d3dAPI = nv_water_d3d_api_d3d10;
-		m_d3d._10.m_pd3d10Device = pD3DDevice;
-		m_d3d._10.m_pd3d10Device->AddRef();
-
-		V_RETURN(allocateD3DObjects());
-	}
-
-	return reinit(params);
-#else
-	return E_FAIL;
-#endif
-}
-
 HRESULT GFSDK_WaveWorks_Quadtree::initD3D11(const GFSDK_WaveWorks_Quadtree_Params& D3D11_ONLY(params), ID3D11Device* D3D11_ONLY(pD3DDevice))
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -823,38 +697,6 @@ HRESULT GFSDK_WaveWorks_Quadtree::initGeometry()
 	HRESULT hr;
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		{
-			const D3DVERTEXELEMENT9 grid_decl[] =
-			{
-				{0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
-				D3DDECL_END()
-			};
-
-			V_RETURN(NVWaveWorks_Mesh::CreateD3D9(m_d3d._9.m_pd3d9Device, grid_decl, sizeof(vertex_array[0]), vertex_array, num_vert, index_array, index_size_lookup[m_lods], &m_pMesh));
-		}
-		break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		{
-			const D3D10_INPUT_ELEMENT_DESC grid_layout[] = {
-				{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 }
-			};
-			const UINT num_layout_elements = sizeof(grid_layout)/sizeof(grid_layout[0]);
-
-			
-			V_RETURN(NVWaveWorks_Mesh::CreateD3D10(	m_d3d._10.m_pd3d10Device,
-													grid_layout, num_layout_elements,
-													SM4::g_GFSDK_WAVEWORKS_VERTEX_INPUT_Sig, sizeof(SM4::g_GFSDK_WAVEWORKS_VERTEX_INPUT_Sig),
-													sizeof(vertex_array[0]), vertex_array, num_vert,
-													index_array, index_size_lookup[m_lods],
-													&m_pMesh
-													));
-		}
-		break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 	case nv_water_d3d_api_d3d11:
 		{
@@ -1284,36 +1126,10 @@ HRESULT GFSDK_WaveWorks_Quadtree::flushRenderList(	Graphics_Context* pGC,
 #if WAVEWORKS_ENABLE_GRAPHICS
 		switch(m_d3dAPI)
 		{
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			{
-				const UINT rm_g_matLocalWorld = pShaderInputRegisterMappings[ShaderInputD3D9_g_matLocalWorld];
-				const UINT rm_g_vsEyePos = pShaderInputRegisterMappings[ShaderInputD3D9_g_vsEyePos];
-				const UINT rm_g_MorphParam = pShaderInputRegisterMappings[ShaderInputD3D9_g_MorphParam];
-				if(rm_g_matLocalWorld != nvrm_unused)
-					V_RETURN(pSavestateImpl->PreserveD3D9VertexShaderConstantF(rm_g_matLocalWorld, 3));
-				if(rm_g_vsEyePos != nvrm_unused)
-					V_RETURN(pSavestateImpl->PreserveD3D9VertexShaderConstantF(rm_g_vsEyePos, 1));
-				if(rm_g_MorphParam != nvrm_unused)
-					V_RETURN(pSavestateImpl->PreserveD3D9VertexShaderConstantF(rm_g_MorphParam, 1));
-			}
-			break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			{
-				const UINT reg = pShaderInputRegisterMappings[ShaderInputD3D10_vs_buffer];
-				if(reg != nvrm_unused)
-				{
-					V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderConstantBuffer(reg));
-				}
-			}
-			break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			{
-				const UINT reg = pShaderInputRegisterMappings[ShaderInputD3D10_vs_buffer];
+				const UINT reg = pShaderInputRegisterMappings[ShaderInputD3D11_vs_buffer];
 				if(reg != nvrm_unused)
 				{
 					V_RETURN(pSavestateImpl->PreserveD3D11PixelShaderConstantBuffer(pDC_d3d11, reg));
@@ -1387,38 +1203,6 @@ HRESULT GFSDK_WaveWorks_Quadtree::flushRenderList(	Graphics_Context* pGC,
 		gfsdk_float4 morphParam = gfsdk_make_float4(morph_distance_constant,0.f,0.f,node.morph_sign);
 		switch(m_d3dAPI)
 		{
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			{
-				UINT rm_g_matLocalWorld = pShaderInputRegisterMappings[ShaderInputD3D9_g_matLocalWorld];
-				UINT rm_g_vsEyePos = pShaderInputRegisterMappings[ShaderInputD3D9_g_vsEyePos];
-				UINT rm_g_MorphParam = pShaderInputRegisterMappings[ShaderInputD3D9_g_MorphParam];
-				if(rm_g_matLocalWorld != nvrm_unused)
-					V_RETURN(m_d3d._9.m_pd3d9Device->SetVertexShaderConstantF(rm_g_matLocalWorld, &matLocalWorld._11, 3));
-				if(rm_g_vsEyePos != nvrm_unused)
-					V_RETURN(m_d3d._9.m_pd3d9Device->SetVertexShaderConstantF(rm_g_vsEyePos, &eyePos.x, 1));
-				if(rm_g_MorphParam != nvrm_unused)
-					V_RETURN(m_d3d._9.m_pd3d9Device->SetVertexShaderConstantF(rm_g_MorphParam, &morphParam.x, 1));
-			}
-			break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			{
-				const UINT reg = pShaderInputRegisterMappings[ShaderInputD3D10_vs_buffer];
-				if(reg != nvrm_unused)
-				{
-					vs_cbuffer VSCB;
-					memcpy(&VSCB.g_matLocalWorld, &matLocalWorld, sizeof(VSCB.g_matLocalWorld));
-					memcpy(&VSCB.g_vsEyePos, &eyePos, sizeof(VSCB.g_vsEyePos));
-					memcpy(&VSCB.g_MorphParam, &morphParam, sizeof(VSCB.g_MorphParam));
-					m_d3d._10.m_pd3d10Device->UpdateSubresource(m_d3d._10.m_pd3d10VertexShaderCB, 0, NULL, &VSCB, 0, 0);
-					m_d3d._10.m_pd3d10Device->VSSetConstantBuffers(reg, 1, &m_d3d._10.m_pd3d10VertexShaderCB);
-
-				}
-			}
-			break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			{
@@ -1571,27 +1355,6 @@ HRESULT GFSDK_WaveWorks_Quadtree::buildRenderList(	Graphics_Context* pGC,
 #if WAVEWORKS_ENABLE_GRAPHICS
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		{
-			D3DVIEWPORT9 vp;
-			V_RETURN(m_d3d._9.m_pd3d9Device->GetViewport(&vp));
-			viewportW = FLOAT(vp.Width);
-			viewportH = FLOAT(vp.Height);
-			break;
-		}
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		{
-			D3D10_VIEWPORT vp;
-			UINT NumViewports = 1;
-			m_d3d._10.m_pd3d10Device->RSGetViewports(&NumViewports,&vp);
-			viewportW = FLOAT(vp.Width);
-			viewportH = FLOAT(vp.Height);
-			break;
-		}
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 	case nv_water_d3d_api_d3d11:
 		{
@@ -1739,16 +1502,6 @@ HRESULT GFSDK_WaveWorks_Quadtree::buildRenderListExplicit(	const gfsdk_float4x4&
 	return S_OK;
 }
 
-HRESULT GFSDK_WaveWorks_Quadtree::getShaderInputCountD3D9()
-{
-	return NumShaderInputsD3D9;
-}
-
-HRESULT GFSDK_WaveWorks_Quadtree::getShaderInputCountD3D10()
-{
-	return NumShaderInputsD3D10;
-}
-
 HRESULT GFSDK_WaveWorks_Quadtree::getShaderInputCountD3D11()
 {
 	return NumShaderInputsD3D11;
@@ -1764,34 +1517,6 @@ HRESULT GFSDK_WaveWorks_Quadtree::getShaderInputCountGL2()
 	return NumShaderInputsGL2;
 }
 
-HRESULT GFSDK_WaveWorks_Quadtree::getShaderInputDescD3D9(UINT D3D9_ONLY(inputIndex), GFSDK_WaveWorks_ShaderInput_Desc* D3D9_ONLY(pDesc))
-{
-#if WAVEWORKS_ENABLE_D3D9
-	if(inputIndex >= NumShaderInputsD3D9)
-		return E_FAIL;
-
-	*pDesc = ShaderInputD3D9Descs[inputIndex];
-
-	return S_OK;
-#else // WAVEWORKS_ENABLE_D3D9
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Quadtree::getShaderInputDescD3D10(UINT D3D10_ONLY(inputIndex), GFSDK_WaveWorks_ShaderInput_Desc* D3D10_ONLY(pDesc))
-{
-#if WAVEWORKS_ENABLE_D3D10
-	if(inputIndex >= NumShaderInputsD3D10)
-		return E_FAIL;
-
-	*pDesc = ShaderInputD3D10Descs[inputIndex];
-
-	return S_OK;
-#else // WAVEWORKS_ENABLE_D3D10
-	return E_FAIL;
-#endif
-}
-
 HRESULT GFSDK_WaveWorks_Quadtree::getShaderInputDescD3D11(UINT D3D11_ONLY(inputIndex), GFSDK_WaveWorks_ShaderInput_Desc* D3D11_ONLY(pDesc))
 {
 #if WAVEWORKS_ENABLE_D3D11
diff --git a/src/Quadtree_impl.h b/src/Quadtree_impl.h
index c57a72c..c332d97 100644
--- a/src/Quadtree_impl.h
+++ b/src/Quadtree_impl.h
@@ -49,8 +49,6 @@ public:
 	GFSDK_WaveWorks_Quadtree();
 	~GFSDK_WaveWorks_Quadtree();
 
-	HRESULT initD3D9(const GFSDK_WaveWorks_Quadtree_Params& param, IDirect3DDevice9* pD3DDevice);
-	HRESULT initD3D10(const GFSDK_WaveWorks_Quadtree_Params& param, ID3D10Device* pD3DDevice);
     HRESULT initD3D11(const GFSDK_WaveWorks_Quadtree_Params& param, ID3D11Device* pD3DDevice);
 	HRESULT initGnm(const GFSDK_WaveWorks_Quadtree_Params& param);
 	HRESULT initGL2(const GFSDK_WaveWorks_Quadtree_Params& param, GLuint Program);
@@ -77,10 +75,6 @@ public:
 
 	HRESULT getStats(GFSDK_WaveWorks_Quadtree_Stats& stats) const;
 
-    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();
@@ -177,21 +171,6 @@ private:
 	// D3D API handling
 	nv_water_d3d_api m_d3dAPI;
 
-#if WAVEWORKS_ENABLE_D3D9
-	struct D3D9Objects
-	{
-		IDirect3DDevice9* m_pd3d9Device;
-	};
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-	struct D3D10Objects
-	{
-		ID3D10Device* m_pd3d10Device;
-		ID3D10Buffer* m_pd3d10VertexShaderCB;
-	};
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
 	struct D3D11Objects
 	{
@@ -215,12 +194,6 @@ private:
 #endif
 	union
 	{
-#if WAVEWORKS_ENABLE_D3D9
-		D3D9Objects _9;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		D3D10Objects _10;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		D3D11Objects _11;
 #endif
diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index c4bd924..f6a4e98 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -32,44 +32,6 @@
 
 #include <string.h>
 
-GFSDK_WaveWorks_Savestate::GFSDK_WaveWorks_Savestate(IDirect3DDevice9* D3D9_ONLY(pD3DDevice), GFSDK_WaveWorks_StatePreserveFlags PreserveFlags) :
-	m_UserPreserveFlags(PreserveFlags)
-{
-	memset(&m_d3d, 0, sizeof(m_d3d));
-
-	m_d3dAPI = nv_water_d3d_api_d3d9;
-
-#if WAVEWORKS_ENABLE_D3D9
-	m_d3d._9.m_pEndVertexShaderConstantF = m_d3d._9.m_VertexShaderConstantF;
-	m_d3d._9.m_pEndPixelShaderConstantF = m_d3d._9.m_PixelShaderConstantF;
-	m_d3d._9.m_pEndTexture = m_d3d._9.m_Texture;
-	m_d3d._9.m_pEndSamplerState = m_d3d._9.m_SamplerState;
-	m_d3d._9.m_pEndRenderState = m_d3d._9.m_RenderState;
-
-	m_d3d._9.m_pd3d9Device = pD3DDevice;
-	m_d3d._9.m_pd3d9Device->AddRef();
-#endif
-}
-
-GFSDK_WaveWorks_Savestate::GFSDK_WaveWorks_Savestate(ID3D10Device* D3D10_ONLY(pD3DDevice), GFSDK_WaveWorks_StatePreserveFlags PreserveFlags) :
-	m_UserPreserveFlags(PreserveFlags)
-{
-	memset(&m_d3d, 0, sizeof(m_d3d));
-
-	m_d3dAPI = nv_water_d3d_api_d3d10;
-
-#if WAVEWORKS_ENABLE_D3D10
-	m_d3d._10.m_pEndVertexShaderConstantBuffer = m_d3d._10.m_VertexShaderConstantBuffer;
-	m_d3d._10.m_pEndPixelShaderConstantBuffer = m_d3d._10.m_PixelShaderConstantBuffer;
-	m_d3d._10.m_pEndVertexShaderSampler = m_d3d._10.m_VertexShaderSampler;
-	m_d3d._10.m_pEndPixelShaderSampler = m_d3d._10.m_PixelShaderSampler;
-	m_d3d._10.m_pEndVertexShaderResource = m_d3d._10.m_VertexShaderResource;
-	m_d3d._10.m_pEndPixelShaderResource = m_d3d._10.m_PixelShaderResource;
-
-	m_d3d._10.m_pd3d10Device = pD3DDevice;
-	m_d3d._10.m_pd3d10Device->AddRef();
-#endif
-}
 
 GFSDK_WaveWorks_Savestate::GFSDK_WaveWorks_Savestate(ID3D11Device* D3D11_ONLY(pD3DDevice), GFSDK_WaveWorks_StatePreserveFlags PreserveFlags) :
 	m_UserPreserveFlags(PreserveFlags)
@@ -106,18 +68,6 @@ GFSDK_WaveWorks_Savestate::~GFSDK_WaveWorks_Savestate()
 #if WAVEWORKS_ENABLE_GRAPHICS
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		ReleaseD3D9Resources();
-		m_d3d._9.m_pd3d9Device->Release();
-		break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		ReleaseD3D10Resources();
-		m_d3d._10.m_pd3d10Device->Release();
-		break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 	case nv_water_d3d_api_d3d11:
 		ReleaseD3D11Resources();
@@ -135,14 +85,6 @@ HRESULT GFSDK_WaveWorks_Savestate::Restore(Graphics_Context* pGC)
 #if WAVEWORKS_ENABLE_GRAPHICS
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		return RestoreD3D9();
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		return RestoreD3D10();
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 	case nv_water_d3d_api_d3d11:
 		{
@@ -158,753 +100,6 @@ HRESULT GFSDK_WaveWorks_Savestate::Restore(Graphics_Context* pGC)
 	return E_FAIL;
 }
 
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D9Viewport()
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-
-	if((m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Viewports) && !(m_d3d._9.m_PreservedFlags & D3D9Objects::ViewportPreserved))
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->GetViewport(&m_d3d._9.m_Viewport));
-		m_d3d._9.m_PreservedFlags |= D3D9Objects::ViewportPreserved;
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D9RenderTargets()
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-
-	if((m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_RenderTargets) && !(m_d3d._9.m_PreservedFlags & D3D9Objects::RenderTargetsPreserved))
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->GetRenderTarget(0, &m_d3d._9.m_pRenderTarget));
-		V_RETURN(m_d3d._9.m_pd3d9Device->GetDepthStencilSurface(&m_d3d._9.m_pDepthStencil));
-		
-		m_d3d._9.m_PreservedFlags |= D3D9Objects::RenderTargetsPreserved;
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D9Shaders()
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-
-	if((m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Shaders) && !(m_d3d._9.m_PreservedFlags & D3D9Objects::ShadersPreserved))
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->GetVertexShader(&m_d3d._9.m_pVertexShader));
-		V_RETURN(m_d3d._9.m_pd3d9Device->GetPixelShader(&m_d3d._9.m_pPixelShader));
-		
-		m_d3d._9.m_PreservedFlags |= D3D9Objects::ShadersPreserved;
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D9PixelShaderConstantF(UINT D3D9_ONLY(ix), UINT D3D9_ONLY(count))
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-
-	if(m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_ShaderConstants)
-	{
-		for(; count; --count, ++ix)
-		{
-			if(!m_d3d._9.m_PixelShaderConstantF_Flags[ix])
-			{
-				m_d3d._9.m_pEndPixelShaderConstantF->regIndex = ix;
-				V_RETURN(m_d3d._9.m_pd3d9Device->GetPixelShaderConstantF(ix, m_d3d._9.m_pEndPixelShaderConstantF->value, 1));
-				++m_d3d._9.m_pEndPixelShaderConstantF;
-
-				m_d3d._9.m_PixelShaderConstantF_Flags[ix] = 1;
-			}
-		}
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D9VertexShaderConstantF(UINT D3D9_ONLY(ix), UINT D3D9_ONLY(count))
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-
-	if(m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_ShaderConstants)
-	{
-		for(; count; --count, ++ix)
-		{
-			if(!m_d3d._9.m_VertexShaderConstantF_Flags[ix])
-			{
-				m_d3d._9.m_pEndVertexShaderConstantF->regIndex = ix;
-				V_RETURN(m_d3d._9.m_pd3d9Device->GetVertexShaderConstantF(ix, m_d3d._9.m_pEndVertexShaderConstantF->value, 1));
-				++m_d3d._9.m_pEndVertexShaderConstantF;
-
-				m_d3d._9.m_VertexShaderConstantF_Flags[ix] = 1;
-			}
-		}
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D9Texture(UINT D3D9_ONLY(ix))
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-
-	if(m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Samplers)
-	{
-		if(!(m_d3d._9.m_Texture_Flags[ix]))
-		{
-			m_d3d._9.m_pEndTexture->regIndex = ix;
-			V_RETURN(m_d3d._9.m_pd3d9Device->GetTexture(ix, &m_d3d._9.m_pEndTexture->pTexture));
-			++m_d3d._9.m_pEndTexture;
-
-			m_d3d._9.m_Texture_Flags[ix] = 1;
-		}
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D9SamplerState(UINT D3D9_ONLY(ix), D3DSAMPLERSTATETYPE D3D9_ONLY(type))
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-
-	if(m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Samplers)
-	{
-		if(!(m_d3d._9.m_SamplerState_Flags[ix][type]))
-		{
-			m_d3d._9.m_pEndSamplerState->regIndex = ix;
-			m_d3d._9.m_pEndSamplerState->type = type;
-			V_RETURN(m_d3d._9.m_pd3d9Device->GetSamplerState(ix, type, &m_d3d._9.m_pEndSamplerState->value));
-			++m_d3d._9.m_pEndSamplerState;
-
-			m_d3d._9.m_SamplerState_Flags[ix][type] = 0;
-		}
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D9RenderState(D3DRENDERSTATETYPE D3D9_ONLY(rs))
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-
-	if(m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Other)
-	{
-		if(!(m_d3d._9.m_RenderState_Flags[rs]))
-		{
-			m_d3d._9.m_pEndRenderState->type = rs;
-			V_RETURN(m_d3d._9.m_pd3d9Device->GetRenderState(rs, &m_d3d._9.m_pEndRenderState->value));
-			++m_d3d._9.m_pEndRenderState;
-
-			m_d3d._9.m_RenderState_Flags[rs] = 1;
-		}
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D9Streams()
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-
-	if((m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Streams) && !(m_d3d._9.m_PreservedFlags & D3D9Objects::StreamsPreserved))
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->GetVertexDeclaration(&m_d3d._9.m_pDecl));
-		V_RETURN(m_d3d._9.m_pd3d9Device->GetStreamSource(0, &m_d3d._9.m_pStream0VB, &m_d3d._9.m_Stream0Offset, &m_d3d._9.m_Stream0Stride));
-		V_RETURN(m_d3d._9.m_pd3d9Device->GetIndices(&m_d3d._9.m_pIB));
-		
-		m_d3d._9.m_PreservedFlags |= D3D9Objects::StreamsPreserved;
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::RestoreD3D9()
-{
-#if WAVEWORKS_ENABLE_D3D9
-	HRESULT hr;
-
-	assert(m_d3dAPI == nv_water_d3d_api_d3d9);
-
-	if(m_d3d._9.m_PreservedFlags & D3D9Objects::RenderTargetsPreserved)
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderTarget(0, m_d3d._9.m_pRenderTarget));
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetDepthStencilSurface(m_d3d._9.m_pDepthStencil));
-	}
-
-	if(m_d3d._9.m_PreservedFlags & D3D9Objects::ViewportPreserved)
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetViewport(&m_d3d._9.m_Viewport));
-	}
-
-	if(m_d3d._9.m_PreservedFlags & D3D9Objects::ShadersPreserved)
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetVertexShader(m_d3d._9.m_pVertexShader));
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShader(m_d3d._9.m_pPixelShader));
-	}
-
-	for(D3D9Objects::ShaderConstantF* it = m_d3d._9.m_VertexShaderConstantF; it != m_d3d._9.m_pEndVertexShaderConstantF; ++it)
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetVertexShaderConstantF(it->regIndex, it->value, 1));
-		m_d3d._9.m_VertexShaderConstantF_Flags[it->regIndex] = 0;
-	}
-
-	for(D3D9Objects::ShaderConstantF* it = m_d3d._9.m_PixelShaderConstantF; it != m_d3d._9.m_pEndPixelShaderConstantF; ++it)
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(it->regIndex, it->value, 1));
-		m_d3d._9.m_PixelShaderConstantF_Flags[it->regIndex] = 0;
-	}
-
-	for(D3D9Objects::Texture* it = m_d3d._9.m_Texture; it != m_d3d._9.m_pEndTexture; ++it)
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(it->regIndex, it->pTexture));
-		m_d3d._9.m_Texture_Flags[it->regIndex] = 0;
-	}
-
-	for(D3D9Objects::SamplerState* it = m_d3d._9.m_SamplerState; it != m_d3d._9.m_pEndSamplerState; ++it)
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(it->regIndex, it->type, it->value));
-		m_d3d._9.m_SamplerState_Flags[it->regIndex][it->type] = 0;
-	}
-
-	for(D3D9Objects::RenderState* it = m_d3d._9.m_RenderState; it != m_d3d._9.m_pEndRenderState; ++it)
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(it->type, it->value));
-		m_d3d._9.m_RenderState_Flags[it->type] = 0;
-	}
-
-	if(m_d3d._9.m_PreservedFlags & D3D9Objects::StreamsPreserved)
-	{
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetVertexDeclaration(m_d3d._9.m_pDecl));
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetStreamSource(0, m_d3d._9.m_pStream0VB, m_d3d._9.m_Stream0Offset, m_d3d._9.m_Stream0Stride));
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetIndices(m_d3d._9.m_pIB));
-	}
-
-	// Release ref-counts etc.
-	V_RETURN(ReleaseD3D9Resources());
-
-	// Reset remaining flags etc.
-	m_d3d._9.m_PreservedFlags = 0;
-
-	m_d3d._9.m_pEndVertexShaderConstantF = m_d3d._9.m_VertexShaderConstantF;
-	m_d3d._9.m_pEndPixelShaderConstantF = m_d3d._9.m_PixelShaderConstantF;
-	m_d3d._9.m_pEndTexture = m_d3d._9.m_Texture;
-	m_d3d._9.m_pEndSamplerState = m_d3d._9.m_SamplerState;
-	m_d3d._9.m_pEndRenderState = m_d3d._9.m_RenderState;
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::ReleaseD3D9Resources()
-{
-#if WAVEWORKS_ENABLE_D3D9
-	SAFE_RELEASE(m_d3d._9.m_pRenderTarget);
-	SAFE_RELEASE(m_d3d._9.m_pDepthStencil);
-
-	SAFE_RELEASE(m_d3d._9.m_pVertexShader);
-	SAFE_RELEASE(m_d3d._9.m_pPixelShader);
-
-	for(D3D9Objects::Texture* it = m_d3d._9.m_Texture; it != m_d3d._9.m_pEndTexture; ++it)
-	{
-		SAFE_RELEASE(it->pTexture);
-	}
-
-	SAFE_RELEASE(m_d3d._9.m_pDecl);
-	SAFE_RELEASE(m_d3d._9.m_pStream0VB);
-	SAFE_RELEASE(m_d3d._9.m_pIB);
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10Viewport()
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if((m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Viewports) && !(m_d3d._10.m_PreservedFlags & D3D10Objects::ViewportPreserved))
-	{
-		UINT num_vp = 1;
-		m_d3d._10.m_pd3d10Device->RSGetViewports(&num_vp, &m_d3d._10.m_Viewport);
-		m_d3d._10.m_PreservedFlags |= D3D10Objects::ViewportPreserved;
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10RenderTargets()
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if((m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_RenderTargets) && !(m_d3d._10.m_PreservedFlags & D3D10Objects::RenderTargetsPreserved))
-	{
-		m_d3d._10.m_pd3d10Device->OMGetRenderTargets(1, &m_d3d._10.m_pRenderTarget, &m_d3d._10.m_pDepthStencil);
-		m_d3d._10.m_PreservedFlags |= D3D10Objects::RenderTargetsPreserved;
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10Shaders()
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if((m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Shaders) && !(m_d3d._10.m_PreservedFlags & D3D10Objects::ShadersPreserved))
-	{
-		m_d3d._10.m_pd3d10Device->VSGetShader(&m_d3d._10.m_pVertexShader);
-		m_d3d._10.m_pd3d10Device->GSGetShader(&m_d3d._10.m_pGeomShader);
-		m_d3d._10.m_pd3d10Device->PSGetShader(&m_d3d._10.m_pPixelShader);
-
-		m_d3d._10.m_PreservedFlags |= D3D10Objects::ShadersPreserved;
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10Streams()
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if((m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Streams) && !(m_d3d._10.m_PreservedFlags & D3D10Objects::StreamsPreserved))
-	{
-		m_d3d._10.m_pd3d10Device->IAGetVertexBuffers(0, 1, &m_d3d._10.m_pSlot0VB, &m_d3d._10.m_Slot0VBOffset, &m_d3d._10.m_Slot0VBStride);
-		m_d3d._10.m_pd3d10Device->IAGetIndexBuffer(&m_d3d._10.m_pIB, &m_d3d._10.m_IBFormat, &m_d3d._10.m_IBOffset);
-		m_d3d._10.m_pd3d10Device->IAGetInputLayout(&m_d3d._10.m_pLayout);
-		m_d3d._10.m_pd3d10Device->IAGetPrimitiveTopology(&m_d3d._10.m_Topology);
-
-		m_d3d._10.m_PreservedFlags |= D3D10Objects::StreamsPreserved;
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10DepthStencil()
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if((m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Other) && !(m_d3d._10.m_PreservedFlags & D3D10Objects::DepthStencilPreserved))
-	{
-		m_d3d._10.m_pd3d10Device->OMGetDepthStencilState(&m_d3d._10.m_pDepthStencilState, &m_d3d._10.m_StencilRef);
-		m_d3d._10.m_PreservedFlags |= D3D10Objects::DepthStencilPreserved;
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10Blend()
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if((m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Other) && !(m_d3d._10.m_PreservedFlags & D3D10Objects::BlendPreserved))
-	{
-		m_d3d._10.m_pd3d10Device->OMGetBlendState(&m_d3d._10.m_pBlendState, m_d3d._10.m_BlendFactors, &m_d3d._10.m_SampleMask);
-		m_d3d._10.m_PreservedFlags |= D3D10Objects::BlendPreserved;
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10Raster()
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if((m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Other) && !(m_d3d._10.m_PreservedFlags & D3D10Objects::RasterPreserved))
-	{
-		m_d3d._10.m_pd3d10Device->RSGetState(&m_d3d._10.m_pRSState);
-		m_d3d._10.m_PreservedFlags |= D3D10Objects::RasterPreserved;
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10PixelShaderConstantBuffer(UINT D3D10_ONLY(ix))
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if(m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_ShaderConstants)
-	{
-		const WORD ixBit = WORD(0x0001 << ix);
-		if(!(m_d3d._10.m_PixelShaderConstantBuffer_Flags & ixBit))
-		{
-			m_d3d._10.m_pEndPixelShaderConstantBuffer->regIndex = ix;
-			m_d3d._10.m_pd3d10Device->PSGetConstantBuffers(ix, 1, &m_d3d._10.m_pEndPixelShaderConstantBuffer->pBuffer);
-			++m_d3d._10.m_pEndPixelShaderConstantBuffer;
-
-			m_d3d._10.m_PixelShaderConstantBuffer_Flags |= ixBit;
-		}
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10VertexShaderConstantBuffer(UINT D3D10_ONLY(ix))
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if(m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_ShaderConstants)
-	{
-		const WORD ixBit = WORD(0x0001 << ix);
-		if(!(m_d3d._10.m_VertexShaderConstantBuffer_Flags & ixBit))
-		{
-			m_d3d._10.m_pEndVertexShaderConstantBuffer->regIndex = ix;
-			m_d3d._10.m_pd3d10Device->VSGetConstantBuffers(ix, 1, &m_d3d._10.m_pEndVertexShaderConstantBuffer->pBuffer);
-			++m_d3d._10.m_pEndVertexShaderConstantBuffer;
-
-			m_d3d._10.m_VertexShaderConstantBuffer_Flags |= ixBit;
-		}
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10PixelShaderSampler(UINT D3D10_ONLY(ix))
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if(m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Samplers)
-	{
-		const WORD ixBit = WORD(0x0001 << ix);
-		if(!(m_d3d._10.m_PixelShaderSampler_Flags & ixBit))
-		{
-			m_d3d._10.m_pEndPixelShaderSampler->regIndex = ix;
-			m_d3d._10.m_pd3d10Device->PSGetSamplers(ix, 1, &m_d3d._10.m_pEndPixelShaderSampler->pSampler);
-			++m_d3d._10.m_pEndPixelShaderSampler;
-
-			m_d3d._10.m_PixelShaderSampler_Flags |= ixBit;
-		}
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10VertexShaderSampler(UINT D3D10_ONLY(ix))
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if(m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Samplers)
-	{
-		const WORD ixBit = WORD(0x0001 << ix);
-		if(!(m_d3d._10.m_VertexShaderSampler_Flags & ixBit))
-		{
-			m_d3d._10.m_pEndVertexShaderSampler->regIndex = ix;
-			m_d3d._10.m_pd3d10Device->VSGetSamplers(ix, 1, &m_d3d._10.m_pEndVertexShaderSampler->pSampler);
-			++m_d3d._10.m_pEndVertexShaderSampler;
-
-			m_d3d._10.m_VertexShaderSampler_Flags |= ixBit;
-		}
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10PixelShaderResource(UINT D3D10_ONLY(ix))
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if(m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Samplers)
-	{
-		if(!m_d3d._10.m_PixelShaderResource_Flags[ix])
-		{
-			m_d3d._10.m_pEndPixelShaderResource->regIndex = ix;
-			m_d3d._10.m_pd3d10Device->PSGetShaderResources(ix, 1, &m_d3d._10.m_pEndPixelShaderResource->pResource);
-			++m_d3d._10.m_pEndPixelShaderResource;
-
-			m_d3d._10.m_PixelShaderResource_Flags[ix] = 1;
-		}
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D10VertexShaderResource(UINT D3D10_ONLY(ix))
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if(m_UserPreserveFlags & GFSDK_WaveWorks_StatePreserve_Samplers)
-	{
-		if(!m_d3d._10.m_VertexShaderResource_Flags[ix])
-		{
-			m_d3d._10.m_pEndVertexShaderResource->regIndex = ix;
-			m_d3d._10.m_pd3d10Device->VSGetShaderResources(ix, 1, &m_d3d._10.m_pEndVertexShaderResource->pResource);
-			++m_d3d._10.m_pEndVertexShaderResource;
-
-			m_d3d._10.m_VertexShaderResource_Flags[ix] = 1;
-		}
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::RestoreD3D10()
-{
-#if WAVEWORKS_ENABLE_D3D10
-	HRESULT hr;
-
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	if(m_d3d._10.m_PreservedFlags & D3D10Objects::RenderTargetsPreserved)
-	{
-		m_d3d._10.m_pd3d10Device->OMSetRenderTargets(1, &m_d3d._10.m_pRenderTarget, m_d3d._10.m_pDepthStencil);
-	}
-
-	if(m_d3d._10.m_PreservedFlags & D3D10Objects::ViewportPreserved)
-	{
-		m_d3d._10.m_pd3d10Device->RSSetViewports(1, &m_d3d._10.m_Viewport);
-	}
-
-	if(m_d3d._10.m_PreservedFlags & D3D10Objects::ShadersPreserved)
-	{
-		m_d3d._10.m_pd3d10Device->VSSetShader(m_d3d._10.m_pVertexShader);
-		m_d3d._10.m_pd3d10Device->GSSetShader(m_d3d._10.m_pGeomShader);
-		m_d3d._10.m_pd3d10Device->PSSetShader(m_d3d._10.m_pPixelShader);
-	}
-
-	if(m_d3d._10.m_PreservedFlags & D3D10Objects::StreamsPreserved)
-	{
-		m_d3d._10.m_pd3d10Device->IASetVertexBuffers(0, 1, &m_d3d._10.m_pSlot0VB, &m_d3d._10.m_Slot0VBOffset, &m_d3d._10.m_Slot0VBStride);
-		m_d3d._10.m_pd3d10Device->IASetIndexBuffer(m_d3d._10.m_pIB, m_d3d._10.m_IBFormat, m_d3d._10.m_IBOffset);
-		m_d3d._10.m_pd3d10Device->IASetInputLayout(m_d3d._10.m_pLayout);
-		m_d3d._10.m_pd3d10Device->IASetPrimitiveTopology(m_d3d._10.m_Topology);
-	}
-
-	if(m_d3d._10.m_PreservedFlags & D3D10Objects::DepthStencilPreserved)
-	{
-		m_d3d._10.m_pd3d10Device->OMSetDepthStencilState(m_d3d._10.m_pDepthStencilState, m_d3d._10.m_StencilRef);
-	}
-
-	if(m_d3d._10.m_PreservedFlags & D3D10Objects::BlendPreserved)
-	{
-		m_d3d._10.m_pd3d10Device->OMSetBlendState(m_d3d._10.m_pBlendState, m_d3d._10.m_BlendFactors, m_d3d._10.m_SampleMask);
-	}
-
-	if(m_d3d._10.m_PreservedFlags & D3D10Objects::RasterPreserved)
-	{
-		m_d3d._10.m_pd3d10Device->RSSetState(m_d3d._10.m_pRSState);
-	}
-
-	for(D3D10Objects::ShaderConstantBuffer* it = m_d3d._10.m_VertexShaderConstantBuffer; it != m_d3d._10.m_pEndVertexShaderConstantBuffer; ++it)
-	{
-		m_d3d._10.m_pd3d10Device->VSSetConstantBuffers(it->regIndex, 1, &it->pBuffer);
-	}
-	m_d3d._10.m_VertexShaderConstantBuffer_Flags = 0;
-
-	for(D3D10Objects::ShaderConstantBuffer* it = m_d3d._10.m_PixelShaderConstantBuffer; it != m_d3d._10.m_pEndPixelShaderConstantBuffer; ++it)
-	{
-		m_d3d._10.m_pd3d10Device->PSSetConstantBuffers(it->regIndex, 1, &it->pBuffer);
-	}
-	m_d3d._10.m_PixelShaderConstantBuffer_Flags = 0;
-
-	for(D3D10Objects::ShaderSampler* it = m_d3d._10.m_VertexShaderSampler; it != m_d3d._10.m_pEndVertexShaderSampler; ++it)
-	{
-		m_d3d._10.m_pd3d10Device->VSSetSamplers(it->regIndex, 1, &it->pSampler);
-	}
-	m_d3d._10.m_VertexShaderSampler_Flags = 0;
-
-	for(D3D10Objects::ShaderSampler* it = m_d3d._10.m_PixelShaderSampler; it != m_d3d._10.m_pEndPixelShaderSampler; ++it)
-	{
-		m_d3d._10.m_pd3d10Device->PSSetSamplers(it->regIndex, 1, &it->pSampler);
-	}
-	m_d3d._10.m_PixelShaderSampler_Flags = 0;
-
-	for(D3D10Objects::ShaderResource* it = m_d3d._10.m_VertexShaderResource; it != m_d3d._10.m_pEndVertexShaderResource; ++it)
-	{
-		m_d3d._10.m_pd3d10Device->VSSetShaderResources(it->regIndex, 1, &it->pResource);
-		m_d3d._10.m_VertexShaderResource_Flags[it->regIndex] = 0;
-	}
-
-	for(D3D10Objects::ShaderResource* it = m_d3d._10.m_PixelShaderResource; it != m_d3d._10.m_pEndPixelShaderResource; ++it)
-	{
-		m_d3d._10.m_pd3d10Device->PSSetShaderResources(it->regIndex, 1, &it->pResource);
-		m_d3d._10.m_PixelShaderResource_Flags[it->regIndex] = 0;
-	}
-
-	// Release ref-counts etc.
-	V_RETURN(ReleaseD3D10Resources());
-
-	// Reset remaining flags etc.
-	m_d3d._10.m_PreservedFlags = 0;
-
-	m_d3d._10.m_pEndVertexShaderConstantBuffer = m_d3d._10.m_VertexShaderConstantBuffer;
-	m_d3d._10.m_pEndPixelShaderConstantBuffer = m_d3d._10.m_PixelShaderConstantBuffer;
-	m_d3d._10.m_pEndVertexShaderSampler = m_d3d._10.m_VertexShaderSampler;
-	m_d3d._10.m_pEndPixelShaderSampler = m_d3d._10.m_PixelShaderSampler;
-	m_d3d._10.m_pEndVertexShaderResource = m_d3d._10.m_VertexShaderResource;
-	m_d3d._10.m_pEndPixelShaderResource = m_d3d._10.m_PixelShaderResource;
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Savestate::ReleaseD3D10Resources()
-{
-#if WAVEWORKS_ENABLE_D3D10
-	assert(m_d3dAPI == nv_water_d3d_api_d3d10);
-
-	SAFE_RELEASE(m_d3d._10.m_pRenderTarget);
-	SAFE_RELEASE(m_d3d._10.m_pDepthStencil);
-
-	SAFE_RELEASE(m_d3d._10.m_pVertexShader);
-	SAFE_RELEASE(m_d3d._10.m_pGeomShader);
-	SAFE_RELEASE(m_d3d._10.m_pPixelShader);
-
-	SAFE_RELEASE(m_d3d._10.m_pSlot0VB);
-	SAFE_RELEASE(m_d3d._10.m_pIB);
-	SAFE_RELEASE(m_d3d._10.m_pLayout);
-
-	SAFE_RELEASE(m_d3d._10.m_pDepthStencilState);
-
-	SAFE_RELEASE(m_d3d._10.m_pBlendState);
-
-	SAFE_RELEASE(m_d3d._10.m_pRSState);
-
-	for(D3D10Objects::ShaderConstantBuffer* it = m_d3d._10.m_VertexShaderConstantBuffer; it != m_d3d._10.m_pEndVertexShaderConstantBuffer; ++it)
-	{
-		SAFE_RELEASE(it->pBuffer);
-	}
-
-	for(D3D10Objects::ShaderConstantBuffer* it = m_d3d._10.m_PixelShaderConstantBuffer; it != m_d3d._10.m_pEndPixelShaderConstantBuffer; ++it)
-	{
-		SAFE_RELEASE(it->pBuffer);
-	}
-
-	for(D3D10Objects::ShaderSampler* it = m_d3d._10.m_VertexShaderSampler; it != m_d3d._10.m_pEndVertexShaderSampler; ++it)
-	{
-		SAFE_RELEASE(it->pSampler);
-	}
-
-	for(D3D10Objects::ShaderSampler* it = m_d3d._10.m_PixelShaderSampler; it != m_d3d._10.m_pEndPixelShaderSampler; ++it)
-	{
-		SAFE_RELEASE(it->pSampler);
-	}
-
-	for(D3D10Objects::ShaderResource* it = m_d3d._10.m_VertexShaderResource; it != m_d3d._10.m_pEndVertexShaderResource; ++it)
-	{
-		SAFE_RELEASE(it->pResource);
-	}
-
-	for(D3D10Objects::ShaderResource* it = m_d3d._10.m_PixelShaderResource; it != m_d3d._10.m_pEndPixelShaderResource; ++it)
-	{
-		SAFE_RELEASE(it->pResource);
-	}
-
-	return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
 HRESULT GFSDK_WaveWorks_Savestate::PreserveD3D11Viewport(ID3D11DeviceContext* D3D11_ONLY(pDC))
 {
 #if WAVEWORKS_ENABLE_D3D11
diff --git a/src/Savestate_impl.h b/src/Savestate_impl.h
index be68623..927d1c4 100644
--- a/src/Savestate_impl.h
+++ b/src/Savestate_impl.h
@@ -39,39 +39,10 @@ struct ID3D11DeviceContext;
 struct GFSDK_WaveWorks_Savestate
 {
 public:
-	GFSDK_WaveWorks_Savestate(IDirect3DDevice9* pD3DDevice, GFSDK_WaveWorks_StatePreserveFlags PreserveFlags);
-	GFSDK_WaveWorks_Savestate(ID3D10Device* pD3DDevice, GFSDK_WaveWorks_StatePreserveFlags PreserveFlags);
     GFSDK_WaveWorks_Savestate(ID3D11Device* pD3DDevice, GFSDK_WaveWorks_StatePreserveFlags PreserveFlags);
 	~GFSDK_WaveWorks_Savestate();
 
 
-	HRESULT PreserveD3D9Viewport();
-	HRESULT PreserveD3D9RenderTargets();
-	HRESULT PreserveD3D9Shaders();
-	HRESULT PreserveD3D9Streams();
-
-	HRESULT PreserveD3D9PixelShaderConstantF(UINT ix, UINT count);
-	HRESULT PreserveD3D9VertexShaderConstantF(UINT ix, UINT count);
-	HRESULT PreserveD3D9Texture(UINT ix);
-	HRESULT PreserveD3D9SamplerState(UINT ix, D3DSAMPLERSTATETYPE type);
-	HRESULT PreserveD3D9RenderState(D3DRENDERSTATETYPE rs);
-
-
-	HRESULT PreserveD3D10Viewport();
-	HRESULT PreserveD3D10RenderTargets();
-	HRESULT PreserveD3D10Shaders();
-	HRESULT PreserveD3D10Streams();
-	HRESULT PreserveD3D10DepthStencil();
-	HRESULT PreserveD3D10Blend();
-	HRESULT PreserveD3D10Raster();
-
-	HRESULT PreserveD3D10PixelShaderConstantBuffer(UINT ix);
-	HRESULT PreserveD3D10VertexShaderConstantBuffer(UINT ix);
-	HRESULT PreserveD3D10PixelShaderSampler(UINT ix);
-	HRESULT PreserveD3D10VertexShaderSampler(UINT ix);
-	HRESULT PreserveD3D10PixelShaderResource(UINT ix);
-	HRESULT PreserveD3D10VertexShaderResource(UINT ix);
-
 
 	HRESULT PreserveD3D11Viewport(ID3D11DeviceContext* pDC);
 	HRESULT PreserveD3D11RenderTargets(ID3D11DeviceContext* pDC);
@@ -110,204 +81,12 @@ protected:
 
 private:
 
-	HRESULT RestoreD3D9();
-	HRESULT ReleaseD3D9Resources();
-
-	HRESULT RestoreD3D10();
-	HRESULT ReleaseD3D10Resources();
-
 	HRESULT RestoreD3D11(ID3D11DeviceContext* pDC);
 	HRESULT ReleaseD3D11Resources();
 
 	// D3D API handling
 	nv_water_d3d_api m_d3dAPI;
 
-#if WAVEWORKS_ENABLE_D3D9
-	struct D3D9Objects
-	{
-		IDirect3DDevice9* m_pd3d9Device;
-
-		// What is preserved?
-		enum PreservedFlags
-		{
-			ViewportPreserved				= 1,
-			RenderTargetsPreserved			= 2,
-			ShadersPreserved				= 4,
-			StreamsPreserved				= 8
-		};
-
-		DWORD m_PreservedFlags;
-
-		D3DVIEWPORT9 m_Viewport;
-
-		IDirect3DSurface9* m_pRenderTarget;
-		IDirect3DSurface9* m_pDepthStencil;
-
-		IDirect3DPixelShader9* m_pPixelShader;
-		IDirect3DVertexShader9* m_pVertexShader;
-
-		// Shader constants
-		enum { NumShaderConstantF = 256 };
-		UCHAR m_VertexShaderConstantF_Flags[NumShaderConstantF];
-		UCHAR m_PixelShaderConstantF_Flags[NumShaderConstantF];
-
-		struct ShaderConstantF
-		{
-			UINT regIndex;
-			FLOAT value[4];
-		};
-
-		ShaderConstantF m_VertexShaderConstantF[NumShaderConstantF];
-		ShaderConstantF* m_pEndVertexShaderConstantF;
-		ShaderConstantF m_PixelShaderConstantF[NumShaderConstantF];
-		ShaderConstantF* m_pEndPixelShaderConstantF;
-
-		// Textures
-		enum { NumSampler = D3DVERTEXTEXTURESAMPLER3 + 1 };
-		UCHAR m_Texture_Flags[NumSampler];
-
-		struct Texture
-		{
-			UINT regIndex;
-			IDirect3DBaseTexture9* pTexture;
-		};
-
-		Texture m_Texture[NumSampler];
-		Texture* m_pEndTexture;
-
-		// Sampler state
-		enum { NumSamplerStateType = D3DSAMP_DMAPOFFSET + 1 };
-		UCHAR m_SamplerState_Flags[NumSampler][NumSamplerStateType];
-
-		struct SamplerState
-		{
-			UINT regIndex;
-			D3DSAMPLERSTATETYPE type;
-			DWORD value;
-		};
-
-		SamplerState m_SamplerState[NumSampler * NumSamplerStateType];
-		SamplerState* m_pEndSamplerState;
-
-		// Render state
-		enum { NumRenderStateType = D3DRS_BLENDOPALPHA + 1 };
-		UCHAR m_RenderState_Flags[NumRenderStateType];
-
-		struct RenderState
-		{
-			D3DRENDERSTATETYPE type;
-			DWORD value;
-		};
-
-		RenderState m_RenderState[NumRenderStateType];
-		RenderState* m_pEndRenderState;
-
-		// Stream
-		UINT m_Stream0Offset;
-		UINT m_Stream0Stride;
-		IDirect3DVertexDeclaration9* m_pDecl;
-		IDirect3DVertexBuffer9* m_pStream0VB;
-		IDirect3DIndexBuffer9* m_pIB;
-	};
-#endif
-
-#if WAVEWORKS_ENABLE_D3D10
-	struct D3D10Objects
-	{
-		ID3D10Device* m_pd3d10Device;
-
-		// What is preserved?
-		enum PreservedFlags
-		{
-			ViewportPreserved				= 1,
-			RenderTargetsPreserved			= 2,
-			ShadersPreserved				= 4,
-			StreamsPreserved				= 8,
-			DepthStencilPreserved			= 16,
-			BlendPreserved					= 32,
-			RasterPreserved					= 64
-		};
-
-		DWORD m_PreservedFlags;
-
-		D3D10_VIEWPORT m_Viewport;
-
-		ID3D10RenderTargetView* m_pRenderTarget;
-		ID3D10DepthStencilView* m_pDepthStencil;
-
-		ID3D10PixelShader* m_pPixelShader;
-		ID3D10GeometryShader* m_pGeomShader;
-		ID3D10VertexShader* m_pVertexShader;
-
-		ID3D10DepthStencilState* m_pDepthStencilState;
-		UINT m_StencilRef;
-
-		ID3D10BlendState* m_pBlendState;
-		UINT m_SampleMask;
-		FLOAT m_BlendFactors[4];
-
-		ID3D10RasterizerState* m_pRSState;
-
-		// Shader constant buffers
-		enum { NumShaderConstantBuffer = 16 };
-		WORD m_VertexShaderConstantBuffer_Flags;
-		WORD m_PixelShaderConstantBuffer_Flags;
-
-		struct ShaderConstantBuffer
-		{
-			UINT regIndex;
-			ID3D10Buffer* pBuffer;
-		};
-
-		ShaderConstantBuffer m_VertexShaderConstantBuffer[NumShaderConstantBuffer];
-		ShaderConstantBuffer* m_pEndVertexShaderConstantBuffer;
-		ShaderConstantBuffer m_PixelShaderConstantBuffer[NumShaderConstantBuffer];
-		ShaderConstantBuffer* m_pEndPixelShaderConstantBuffer;
-
-		// Shader samplers
-		enum { NumShaderSampler = 16 };
-		WORD m_VertexShaderSampler_Flags;
-		WORD m_PixelShaderSampler_Flags;
-
-		struct ShaderSampler
-		{
-			UINT regIndex;
-			ID3D10SamplerState* pSampler;
-		};
-
-		ShaderSampler m_VertexShaderSampler[NumShaderSampler];
-		ShaderSampler* m_pEndVertexShaderSampler;
-		ShaderSampler m_PixelShaderSampler[NumShaderSampler];
-		ShaderSampler* m_pEndPixelShaderSampler;
-
-		// Shader resources
-		enum { NumShaderResource = 128 };
-		UCHAR m_VertexShaderResource_Flags[NumShaderResource];
-		UCHAR m_PixelShaderResource_Flags[NumShaderResource];
-
-		struct ShaderResource
-		{
-			UINT regIndex;
-			ID3D10ShaderResourceView* pResource;
-		};
-
-		ShaderResource m_VertexShaderResource[NumShaderResource];
-		ShaderResource* m_pEndVertexShaderResource;
-		ShaderResource m_PixelShaderResource[NumShaderResource];
-		ShaderResource* m_pEndPixelShaderResource;
-
-		// Stream
-		ID3D10InputLayout* m_pLayout;
-		ID3D10Buffer* m_pSlot0VB;
-		UINT m_Slot0VBOffset;
-		UINT m_Slot0VBStride;
-		ID3D10Buffer* m_pIB;
-		UINT m_IBOffset;
-		DXGI_FORMAT m_IBFormat;
-		D3D10_PRIMITIVE_TOPOLOGY m_Topology;
-	};
-#endif
-
 #if WAVEWORKS_ENABLE_D3D11
 	struct D3D11Objects
 	{
@@ -471,12 +250,6 @@ private:
 
 	union
 	{
-#if WAVEWORKS_ENABLE_D3D9
-		D3D9Objects _9;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		D3D10Objects _10;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
         D3D11Objects _11;
 #endif
diff --git a/src/Simulation.cpp b/src/Simulation.cpp
index c166ed5..cc54db0 100644
--- a/src/Simulation.cpp
+++ b/src/Simulation.cpp
@@ -65,19 +65,10 @@ namespace {
 	#endif
 
 #endif
-#if WAVEWORKS_ENABLE_D3D9
-namespace CalcGradient {
-	#include "CalcGradient_ps_3_0.h"
-	#include "CalcGradient_vs_3_0.h"
-}
-namespace FoamGeneration {
-	#include "FoamGeneration_ps_3_0.h"
-	#include "FoamGeneration_vs_3_0.h"
-}
-#endif
+
 
 namespace SM4 {
-#if WAVEWORKS_ENABLE_D3D10 || WAVEWORKS_ENABLE_D3D11
+#if WAVEWORKS_ENABLE_D3D11
 namespace CalcGradient {
 	#include "CalcGradient_ps_4_0.h"
 	#include "CalcGradient_vs_4_0.h"
@@ -155,57 +146,6 @@ const DXGI_SAMPLE_DESC kNoSample = {1, 0};
 #endif
 #endif
 
-enum ShaderInputsD3D9
-{
-    ShaderInputD3D9_g_samplerDisplacementMap0 = 0,
-    ShaderInputD3D9_g_samplerDisplacementMap1,
-    ShaderInputD3D9_g_samplerDisplacementMap2,
-    ShaderInputD3D9_g_samplerDisplacementMap3,
-    ShaderInputD3D9_g_samplerGradientMap0,
-    ShaderInputD3D9_g_samplerGradientMap1,
-    ShaderInputD3D9_g_samplerGradientMap2,
-    ShaderInputD3D9_g_samplerGradientMap3,
-    ShaderInputD3D9_g_WorldEye,
-    ShaderInputD3D9_g_Pad1,
-	ShaderInputD3D9_g_UVScaleCascade0123,
-    ShaderInputD3D9_g_TexelLength_x2_PS,
-    ShaderInputD3D9_g_Cascade1Scale_PS,
-    ShaderInputD3D9_g_Cascade1TexelScale_PS,
-    ShaderInputD3D9_g_Cascade1UVOffset_PS,
-    ShaderInputD3D9_g_Cascade2Scale_PS,
-    ShaderInputD3D9_g_Cascade2TexelScale_PS,
-    ShaderInputD3D9_g_Cascade2UVOffset_PS,
-    ShaderInputD3D9_g_Cascade3Scale_PS,
-    ShaderInputD3D9_g_Cascade3TexelScale_PS,
-    ShaderInputD3D9_g_Cascade3UVOffset_PS,
-
-    NumShaderInputsD3D9
-};
-
-enum ShaderInputsD3D10
-{
-    ShaderInputD3D10_vs_buffer = 0,
-    ShaderInputD3D10_g_samplerDisplacementMap0,
-    ShaderInputD3D10_g_samplerDisplacementMap1,
-	ShaderInputD3D10_g_samplerDisplacementMap2,
-	ShaderInputD3D10_g_samplerDisplacementMap3,
-    ShaderInputD3D10_g_textureDisplacementMap0,
-    ShaderInputD3D10_g_textureDisplacementMap1,
-	ShaderInputD3D10_g_textureDisplacementMap2,
-	ShaderInputD3D10_g_textureDisplacementMap3,
-    ShaderInputD3D10_ps_buffer,
-    ShaderInputD3D10_g_samplerGradientMap0,
-    ShaderInputD3D10_g_samplerGradientMap1,
-	ShaderInputD3D10_g_samplerGradientMap2,
-	ShaderInputD3D10_g_samplerGradientMap3,
-    ShaderInputD3D10_g_textureGradientMap0,
-    ShaderInputD3D10_g_textureGradientMap1,
-	ShaderInputD3D10_g_textureGradientMap2,
-	ShaderInputD3D10_g_textureGradientMap3,
-
-    NumShaderInputsD3D10
-};
-
 enum ShaderInputsD3D11
 {
     ShaderInputD3D11_vs_buffer = 0,
@@ -298,55 +238,6 @@ enum ShaderInputsGL2
     ShaderInputGL2_g_Cascade3UVOffset_PS,
     NumShaderInputsGL2
 };
-// NB: These should be kept synchronisd with the shader source
-#if WAVEWORKS_ENABLE_D3D9
-const GFSDK_WaveWorks_ShaderInput_Desc ShaderInputDescsD3D9[NumShaderInputsD3D9] = {
-    { GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Sampler, "nvsf_g_samplerDisplacementMap0", 0 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Sampler, "nvsf_g_samplerDisplacementMap1", 1 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Sampler, "nvsf_g_samplerDisplacementMap2", 2 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Sampler, "nvsf_g_samplerDisplacementMap3", 3 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Sampler, "nvsf_g_samplerGradientMap0", 0 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Sampler, "nvsf_g_samplerGradientMap1", 1 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Sampler, "nvsf_g_samplerGradientMap2", 2 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Sampler, "nvsf_g_samplerGradientMap3", 3 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_FloatConstant, "nvsf_g_WorldEye", 0 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_FloatConstant, "nvsf_g_Pad1", 1 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_FloatConstant, "nvsf_g_UVScaleCascade0123", 2 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_FloatConstant, "nvsf_g_TexelLength_x2_PS", 0 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_FloatConstant, "nvsf_g_Cascade1Scale_PS", 1 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_FloatConstant, "nvsf_g_Cascade1TexelScale_PS", 2 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_FloatConstant, "nvsf_g_Cascade1UVOffset_PS", 3 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_FloatConstant, "nvsf_g_Cascade2Scale_PS", 4 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_FloatConstant, "nvsf_g_Cascade2TexelScale_PS", 5 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_FloatConstant, "nvsf_g_Cascade2UVOffset_PS", 6 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_FloatConstant, "nvsf_g_Cascade3Scale_PS", 7 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_FloatConstant, "nvsf_g_Cascade3TexelScale_PS", 8 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_FloatConstant, "nvsf_g_Cascade3UVOffset_PS", 9 },
-};
-#endif // WAVEWORKS_ENABLE_D3D9
-
-#if WAVEWORKS_ENABLE_D3D10
-const GFSDK_WaveWorks_ShaderInput_Desc ShaderInputDescsD3D10[NumShaderInputsD3D10] = {
-    { GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_ConstantBuffer, "nvsf_attr_vs_buffer", 0 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Sampler, "nvsf_g_samplerDisplacementMap0", 0 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Sampler, "nvsf_g_samplerDisplacementMap1", 1 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Sampler, "nvsf_g_samplerDisplacementMap2", 2 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Sampler, "nvsf_g_samplerDisplacementMap3", 3 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Texture, "nvsf_g_textureDisplacementMap0", 0 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Texture, "nvsf_g_textureDisplacementMap1", 1 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Texture, "nvsf_g_textureDisplacementMap2", 2 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::VertexShader_Texture, "nvsf_g_textureDisplacementMap3", 3 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_ConstantBuffer, "nvsf_attr_ps_buffer", 0 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Sampler, "nvsf_g_samplerGradientMap0", 0 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Sampler, "nvsf_g_samplerGradientMap1", 1 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Sampler, "nvsf_g_samplerGradientMap2", 2 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Sampler, "nvsf_g_samplerGradientMap3", 3 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Texture, "nvsf_g_textureGradientMap0", 0 },
-    { GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Texture, "nvsf_g_textureGradientMap1", 1 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Texture, "nvsf_g_textureGradientMap2", 2 },
-	{ GFSDK_WaveWorks_ShaderInput_Desc::PixelShader_Texture, "nvsf_g_textureGradientMap3", 3 }
-};
-#endif // WAVEWORKS_ENABLE_D3D10
 
 #if WAVEWORKS_ENABLE_D3D11
 const GFSDK_WaveWorks_ShaderInput_Desc ShaderInputDescsD3D11[NumShaderInputsD3D11] = {
@@ -547,44 +438,6 @@ void GFSDK_WaveWorks_Simulation::releaseAll()
 
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-            SAFE_RELEASE(m_d3d._9.m_pd3d9GradCalcVS);
-            SAFE_RELEASE(m_d3d._9.m_pd3d9GradCalcPS);
-			SAFE_RELEASE(m_d3d._9.m_pd3d9FoamGenPS);
-			SAFE_RELEASE(m_d3d._9.m_pd3d9FoamGenVS);
-			SAFE_RELEASE(m_d3d._9.m_pd3d9Device);
-
-            m_d3dAPI = nv_water_d3d_api_undefined;
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-            SAFE_RELEASE(m_d3d._10.m_pd3d10GradCalcVS);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10GradCalcPS);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10GradCalcPixelShaderCB);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10FoamGenVS);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10FoamGenPS);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10FoamGenPixelShaderCB);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10PointSampler);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10NoDepthStencil);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10AlwaysSolidRasterizer);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10CalcGradBlendState);
-			SAFE_RELEASE(m_d3d._10.m_pd3d10AccumulateFoamBlendState);
-			SAFE_RELEASE(m_d3d._10.m_pd3d10WriteAccumulatedFoamBlendState);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10LinearNoMipSampler);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10GradMapSampler);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10PixelShaderCB);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10VertexShaderCB);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10Device);
-
-            m_d3dAPI = nv_water_d3d_api_undefined;
-        }
-        break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -660,35 +513,6 @@ HRESULT GFSDK_WaveWorks_Simulation::initGradMapSamplers()
 #if WAVEWORKS_ENABLE_GRAPHICS
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		{
-		}
-		break;
-#endif 
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			HRESULT hr;
-            SAFE_RELEASE(m_d3d._10.m_pd3d10GradMapSampler);
-            D3D10_SAMPLER_DESC anisoSamplerDesc;
-            anisoSamplerDesc.Filter = m_params.aniso_level > 1 ? D3D10_FILTER_ANISOTROPIC : D3D10_FILTER_MIN_MAG_MIP_LINEAR;
-            anisoSamplerDesc.AddressU = D3D10_TEXTURE_ADDRESS_WRAP;
-            anisoSamplerDesc.AddressV = D3D10_TEXTURE_ADDRESS_WRAP;
-            anisoSamplerDesc.AddressW = D3D10_TEXTURE_ADDRESS_WRAP;
-            anisoSamplerDesc.MipLODBias = 0.f;
-            anisoSamplerDesc.MaxAnisotropy = m_params.aniso_level;
-            anisoSamplerDesc.ComparisonFunc = D3D10_COMPARISON_NEVER;
-            anisoSamplerDesc.BorderColor[0] = 0.f;
-            anisoSamplerDesc.BorderColor[1] = 0.f;
-            anisoSamplerDesc.BorderColor[2] = 0.f;
-            anisoSamplerDesc.BorderColor[3] = 0.f;
-            anisoSamplerDesc.MinLOD = 0.f;
-            anisoSamplerDesc.MaxLOD = FLT_MAX;
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateSamplerState(&anisoSamplerDesc, &m_d3d._10.m_pd3d10GradMapSampler));
-        }
-        break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -773,129 +597,6 @@ HRESULT GFSDK_WaveWorks_Simulation::initShaders()
 #if WAVEWORKS_ENABLE_GRAPHICS
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			HRESULT hr;
-            SAFE_RELEASE(m_d3d._9.m_pd3d9GradCalcVS);
-            SAFE_RELEASE(m_d3d._9.m_pd3d9GradCalcPS);
-            SAFE_RELEASE(m_d3d._9.m_pd3d9FoamGenVS);
-            SAFE_RELEASE(m_d3d._9.m_pd3d9FoamGenPS);
-            V_RETURN(m_d3d._9.m_pd3d9Device->CreateVertexShader((DWORD*)CalcGradient::g_vs30_vs, &m_d3d._9.m_pd3d9GradCalcVS));
-            V_RETURN(m_d3d._9.m_pd3d9Device->CreatePixelShader((DWORD*)CalcGradient::g_ps30_ps, &m_d3d._9.m_pd3d9GradCalcPS));
-			V_RETURN(m_d3d._9.m_pd3d9Device->CreateVertexShader((DWORD*)FoamGeneration::g_vs30_vs, &m_d3d._9.m_pd3d9FoamGenVS));
-			V_RETURN(m_d3d._9.m_pd3d9Device->CreatePixelShader((DWORD*)FoamGeneration::g_ps30_ps, &m_d3d._9.m_pd3d9FoamGenPS));
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			HRESULT hr;
-            SAFE_RELEASE(m_d3d._10.m_pd3d10GradCalcVS);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10GradCalcPS);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10FoamGenVS);
-            SAFE_RELEASE(m_d3d._10.m_pd3d10FoamGenPS);
-			V_RETURN(m_d3d._10.m_pd3d10Device->CreateVertexShader((void*)SM4::CalcGradient::g_vs, sizeof(SM4::CalcGradient::g_vs), &m_d3d._10.m_pd3d10GradCalcVS));
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreatePixelShader((void*)SM4::CalcGradient::g_ps, sizeof(SM4::CalcGradient::g_ps), &m_d3d._10.m_pd3d10GradCalcPS));
-			V_RETURN(m_d3d._10.m_pd3d10Device->CreateVertexShader((void*)SM4::FoamGeneration::g_vs, sizeof(SM4::FoamGeneration::g_vs), &m_d3d._10.m_pd3d10FoamGenVS));
-			V_RETURN(m_d3d._10.m_pd3d10Device->CreatePixelShader((void*)SM4::FoamGeneration::g_ps, sizeof(SM4::FoamGeneration::g_ps), &m_d3d._10.m_pd3d10FoamGenPS));
-
-            D3D10_BUFFER_DESC cbDesc;
-            cbDesc.ByteWidth = sizeof(ps_calcgradient_cbuffer);
-            cbDesc.Usage = D3D10_USAGE_DEFAULT;
-            cbDesc.BindFlags = D3D10_BIND_CONSTANT_BUFFER;
-            cbDesc.CPUAccessFlags = 0;
-            cbDesc.MiscFlags = 0;
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateBuffer(&cbDesc, NULL, &m_d3d._10.m_pd3d10GradCalcPixelShaderCB));
-
-            cbDesc.ByteWidth = sizeof(ps_foamgeneration_cbuffer);
-            cbDesc.Usage = D3D10_USAGE_DEFAULT;
-            cbDesc.BindFlags = D3D10_BIND_CONSTANT_BUFFER;
-            cbDesc.CPUAccessFlags = 0;
-            cbDesc.MiscFlags = 0;
-			V_RETURN(m_d3d._10.m_pd3d10Device->CreateBuffer(&cbDesc, NULL, &m_d3d._10.m_pd3d10FoamGenPixelShaderCB));
-
-            cbDesc.ByteWidth = sizeof(ps_attr_cbuffer);
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateBuffer(&cbDesc, NULL, &m_d3d._10.m_pd3d10PixelShaderCB));
-
-            cbDesc.ByteWidth = sizeof(vs_attr_cbuffer);
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateBuffer(&cbDesc, NULL, &m_d3d._10.m_pd3d10VertexShaderCB));
-
-            D3D10_SAMPLER_DESC pointSamplerDesc;
-            pointSamplerDesc.Filter = D3D10_FILTER_MIN_MAG_MIP_POINT;
-            pointSamplerDesc.AddressU = D3D10_TEXTURE_ADDRESS_WRAP;
-            pointSamplerDesc.AddressV = D3D10_TEXTURE_ADDRESS_WRAP;
-            pointSamplerDesc.AddressW = D3D10_TEXTURE_ADDRESS_WRAP;
-            pointSamplerDesc.MipLODBias = 0.f;
-            pointSamplerDesc.MaxAnisotropy = 0;
-            pointSamplerDesc.ComparisonFunc = D3D10_COMPARISON_NEVER;
-            pointSamplerDesc.BorderColor[0] = 0.f;
-            pointSamplerDesc.BorderColor[1] = 0.f;
-            pointSamplerDesc.BorderColor[2] = 0.f;
-            pointSamplerDesc.BorderColor[3] = 0.f;
-            pointSamplerDesc.MinLOD = 0.f;
-            pointSamplerDesc.MaxLOD = 0.f;	// NB: No mipping, effectively
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateSamplerState(&pointSamplerDesc, &m_d3d._10.m_pd3d10PointSampler));
-
-            D3D10_SAMPLER_DESC linearNoMipSampleDesc = pointSamplerDesc;
-            linearNoMipSampleDesc.Filter = D3D10_FILTER_MIN_MAG_LINEAR_MIP_POINT;
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateSamplerState(&linearNoMipSampleDesc, &m_d3d._10.m_pd3d10LinearNoMipSampler));
-
-            const D3D10_DEPTH_STENCILOP_DESC defaultStencilOp = {D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_COMPARISON_ALWAYS};
-            D3D10_DEPTH_STENCIL_DESC dsDesc;
-            dsDesc.DepthEnable = FALSE;
-            dsDesc.DepthWriteMask = D3D10_DEPTH_WRITE_MASK_ZERO;
-            dsDesc.DepthFunc = D3D10_COMPARISON_LESS;
-            dsDesc.StencilEnable = FALSE;
-            dsDesc.StencilReadMask = D3D10_DEFAULT_STENCIL_READ_MASK;
-            dsDesc.StencilWriteMask = D3D10_DEFAULT_STENCIL_WRITE_MASK;
-            dsDesc.FrontFace = defaultStencilOp;
-            dsDesc.BackFace = defaultStencilOp;
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateDepthStencilState(&dsDesc, &m_d3d._10.m_pd3d10NoDepthStencil));
-
-            D3D10_RASTERIZER_DESC rastDesc;
-            rastDesc.FillMode = D3D10_FILL_SOLID;
-            rastDesc.CullMode = D3D10_CULL_NONE;
-            rastDesc.FrontCounterClockwise = FALSE;
-            rastDesc.DepthBias = 0;
-            rastDesc.DepthBiasClamp = 0.f;
-            rastDesc.SlopeScaledDepthBias = 0.f;
-            rastDesc.DepthClipEnable = FALSE;
-            rastDesc.ScissorEnable = FALSE;
-            rastDesc.MultisampleEnable = FALSE;
-            rastDesc.AntialiasedLineEnable = FALSE;
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateRasterizerState(&rastDesc, &m_d3d._10.m_pd3d10AlwaysSolidRasterizer));
-
-            D3D10_BLEND_DESC blendDesc;
-            blendDesc.AlphaToCoverageEnable = FALSE;
-            blendDesc.BlendEnable[0] = FALSE;
-            blendDesc.BlendEnable[1] = FALSE;
-            blendDesc.BlendEnable[2] = FALSE;
-            blendDesc.BlendEnable[3] = FALSE;
-            blendDesc.BlendEnable[4] = FALSE;
-            blendDesc.BlendEnable[5] = FALSE;
-            blendDesc.BlendEnable[6] = FALSE;
-            blendDesc.BlendEnable[7] = FALSE;
-			blendDesc.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_RED | D3D10_COLOR_WRITE_ENABLE_GREEN | D3D10_COLOR_WRITE_ENABLE_BLUE;
-            blendDesc.RenderTargetWriteMask[1] = 0x0F;
-            blendDesc.RenderTargetWriteMask[2] = 0x0F;
-            blendDesc.RenderTargetWriteMask[3] = 0x0F;
-            blendDesc.RenderTargetWriteMask[4] = 0x0F;
-            blendDesc.RenderTargetWriteMask[5] = 0x0F;
-            blendDesc.RenderTargetWriteMask[6] = 0x0F;
-            blendDesc.RenderTargetWriteMask[7] = 0x0F;
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateBlendState(&blendDesc, &m_d3d._10.m_pd3d10CalcGradBlendState));
-
-			blendDesc.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL;
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateBlendState(&blendDesc, &m_d3d._10.m_pd3d10AccumulateFoamBlendState));
-
-			blendDesc.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALPHA;
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateBlendState(&blendDesc, &m_d3d._10.m_pd3d10WriteAccumulatedFoamBlendState));
-
-		}
-        break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -1113,14 +814,6 @@ HRESULT GFSDK_WaveWorks_Simulation::initTextureArrays()
 #if WAVEWORKS_ENABLE_GRAPHICS
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		break;
-#endif 
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-		break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
 		break;
@@ -1173,75 +866,6 @@ HRESULT GFSDK_WaveWorks_Simulation::initTextureArrays()
     return S_OK;
 }
 
-
-HRESULT GFSDK_WaveWorks_Simulation::initD3D9(const GFSDK_WaveWorks_Detailed_Simulation_Params& D3D9_ONLY(params), IDirect3DDevice9* D3D9_ONLY(pD3DDevice))
-{
-#if WAVEWORKS_ENABLE_D3D9
-    HRESULT hr;
-
-    if(nv_water_d3d_api_d3d9 != m_d3dAPI)
-    {
-        releaseAll();
-    }
-    else if(m_d3d._9.m_pd3d9Device != pD3DDevice)
-    {
-        releaseAll();
-    }
-
-    if(nv_water_d3d_api_undefined == m_d3dAPI)
-    {
-        m_d3dAPI = nv_water_d3d_api_d3d9;
-        m_d3d._9.m_pd3d9Device = pD3DDevice;
-        m_d3d._9.m_pd3d9Device->AddRef();
-
-        m_params = params;
-        V_RETURN(allocateAll());
-    }
-    else
-    {
-        V_RETURN(reinit(params));
-    }
-
-    return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Simulation::initD3D10(const GFSDK_WaveWorks_Detailed_Simulation_Params& D3D10_ONLY(params), ID3D10Device* D3D10_ONLY(pD3DDevice))
-{
-#if WAVEWORKS_ENABLE_D3D10
-    HRESULT hr;
-
-    if(nv_water_d3d_api_d3d10 != m_d3dAPI)
-    {
-        releaseAll();
-    }
-    else if(m_d3d._10.m_pd3d10Device != pD3DDevice)
-    {
-        releaseAll();
-    }
-
-    if(nv_water_d3d_api_undefined == m_d3dAPI)
-    {
-        m_d3dAPI = nv_water_d3d_api_d3d10;
-        m_d3d._10.m_pd3d10Device = pD3DDevice;
-        m_d3d._10.m_pd3d10Device->AddRef();
-
-        m_params = params;
-        V_RETURN(allocateAll());
-    }
-    else
-    {
-        V_RETURN(reinit(params));
-    }
-
-    return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
 HRESULT GFSDK_WaveWorks_Simulation::initD3D11(const GFSDK_WaveWorks_Detailed_Simulation_Params& D3D11_ONLY(params), GFSDK_WaveWorks_CPU_Scheduler_Interface* D3D11_ONLY(pOptionalScheduler), ID3D11Device* D3D11_ONLY(pD3DDevice))
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -1370,14 +994,6 @@ HRESULT GFSDK_WaveWorks_Simulation::allocateSimulation(int cascade)
 	if(pFFTSim) {
 		switch(m_d3dAPI)
 		{
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			return pFFTSim->initD3D9(m_d3d._9.m_pd3d9Device);
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			return pFFTSim->initD3D10(m_d3d._10.m_pd3d10Device);
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			return pFFTSim->initD3D11(m_d3d._11.m_pd3d11Device);
@@ -1431,14 +1047,6 @@ HRESULT GFSDK_WaveWorks_Simulation::allocateSimulationManager()
 	if(m_pSimulationManager) {
 		switch(m_d3dAPI)
 		{
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			return m_pSimulationManager->initD3D9(m_d3d._9.m_pd3d9Device);
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			return m_pSimulationManager->initD3D10(m_d3d._10.m_pd3d10Device);
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			return m_pSimulationManager->initD3D11(m_d3d._11.m_pd3d11Device);
@@ -1487,14 +1095,6 @@ HRESULT  GFSDK_WaveWorks_Simulation::allocateGFXTimer()
 
 	switch(m_d3dAPI)
 	{
-#if WAVEWORKS_ENABLE_D3D9
-	case nv_water_d3d_api_d3d9:
-		return m_pGFXTimer->initD3D9(m_d3d._9.m_pd3d9Device);
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-	case nv_water_d3d_api_d3d10:
-		return m_pGFXTimer->initD3D10(m_d3d._10.m_pd3d10Device);
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 	case nv_water_d3d_api_d3d11:
 		return m_pGFXTimer->initD3D11(m_d3d._11.m_pd3d11Device);
@@ -1714,16 +1314,6 @@ HRESULT GFSDK_WaveWorks_Simulation::updateGradientMaps(Graphics_Context* pGC, GF
 
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			result=updateGradientMapsD3D9(pSavestateImpl);
-			break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			result=updateGradientMapsD3D10(pSavestateImpl);
-			break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			result=updateGradientMapsD3D11(pGC, pSavestateImpl);
@@ -1751,412 +1341,6 @@ HRESULT GFSDK_WaveWorks_Simulation::updateGradientMaps(Graphics_Context* pGC, GF
 	return result;
 }
 
-HRESULT GFSDK_WaveWorks_Simulation::updateGradientMapsD3D10(GFSDK_WaveWorks_Savestate* D3D10_ONLY(pSavestateImpl))
-{
-#if WAVEWORKS_ENABLE_D3D10
-    HRESULT hr;
-
-    // Preserve
-    if(pSavestateImpl)
-    {
-        V_RETURN(pSavestateImpl->PreserveD3D10Viewport());
-        V_RETURN(pSavestateImpl->PreserveD3D10RenderTargets());
-        V_RETURN(pSavestateImpl->PreserveD3D10Shaders());
-        V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderConstantBuffer(0));
-        V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderSampler(0));
-        V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderResource(0));
-        V_RETURN(pSavestateImpl->PreserveD3D10DepthStencil());
-        V_RETURN(pSavestateImpl->PreserveD3D10Blend());
-        V_RETURN(pSavestateImpl->PreserveD3D10Raster());
-
-        for(int cascade = 0; cascade != m_params.num_cascades; ++cascade)
-        {
-            V_RETURN(cascade_states[cascade].m_pQuadMesh->PreserveState(NULL, pSavestateImpl));
-        }
-    }
-
-    for(int cascade = 0; cascade != m_params.num_cascades; ++cascade)
-    {
-		if(cascade_states[cascade].m_gradient_map_version == cascade_states[cascade].m_pFFTSimulation->getDisplacementMapVersion())
-            continue;
-		
-		// Clear the gradient map if necessary
-		const FLOAT kBlack[] = {0.f,0.f,0.f,0.f};
-		if(cascade_states[cascade].m_gradient_map_needs_clear[m_active_GPU_slot]) {
-			m_d3d._10.m_pd3d10Device->ClearRenderTargetView(cascade_states[cascade].m_d3d._10.m_pd3d10GradientRenderTarget[m_active_GPU_slot],kBlack);
-			cascade_states[cascade].m_gradient_map_needs_clear[m_active_GPU_slot] = false;
-		}
-
-		// Rendering folding to gradient map //////////////////////////////////
-		
-        // Render-targets + viewport
-        m_d3d._10.m_pd3d10Device->OMSetRenderTargets(1, &cascade_states[cascade].m_d3d._10.m_pd3d10GradientRenderTarget[m_active_GPU_slot], NULL);
-
-        int dmap_dim =m_params.cascades[cascade].fft_resolution;
-        D3D10_VIEWPORT new_vp;
-        new_vp.TopLeftX = 0;
-        new_vp.TopLeftY = 0;
-        new_vp.Width = dmap_dim;
-        new_vp.Height = dmap_dim;
-        new_vp.MinDepth = 0.f;
-        new_vp.MaxDepth = 0.f;
-        UINT num_new_vp = 1;
-        m_d3d._10.m_pd3d10Device->RSSetViewports(num_new_vp, &new_vp);
-
-        // Shaders
-        m_d3d._10.m_pd3d10Device->VSSetShader(m_d3d._10.m_pd3d10GradCalcVS);
-        m_d3d._10.m_pd3d10Device->GSSetShader(NULL);
-        m_d3d._10.m_pd3d10Device->PSSetShader(m_d3d._10.m_pd3d10GradCalcPS);
-
-        // Constants
-        ps_calcgradient_cbuffer PSCB;
-        PSCB.g_ChoppyScale = m_params.cascades[cascade].choppy_scale * dmap_dim / m_params.cascades[cascade].fft_period;
-		if(m_params.cascades[0].fft_period > 1000.0f) PSCB.g_ChoppyScale *= 1.0f + 0.2f * log(m_params.cascades[0].fft_period/1000.0f);
-		PSCB.g_GradMap2TexelWSScale = 0.5f*dmap_dim / m_params.cascades[cascade].fft_period ; 
-		PSCB.g_OneTexel_Left = gfsdk_make_float4(-1.0f/dmap_dim, 0, 0, 0);
-        PSCB.g_OneTexel_Right = gfsdk_make_float4( 1.0f/dmap_dim, 0, 0, 0);
-        PSCB.g_OneTexel_Back = gfsdk_make_float4( 0,-1.0f/dmap_dim, 0, 0);
-        PSCB.g_OneTexel_Front = gfsdk_make_float4( 0, 1.0f/dmap_dim, 0, 0);
-        m_d3d._10.m_pd3d10Device->UpdateSubresource(m_d3d._10.m_pd3d10GradCalcPixelShaderCB, 0, NULL, &PSCB, 0, 0);
-        m_d3d._10.m_pd3d10Device->PSSetConstantBuffers(0, 1, &m_d3d._10.m_pd3d10GradCalcPixelShaderCB);
-
-        // Textures/samplers
-        m_d3d._10.m_pd3d10Device->PSSetShaderResources(0, 1, cascade_states[cascade].m_pFFTSimulation->GetDisplacementMapD3D10());
-        m_d3d._10.m_pd3d10Device->PSSetSamplers(0, 1, &m_d3d._10.m_pd3d10PointSampler);
-
-		// Render state
-		m_d3d._10.m_pd3d10Device->OMSetDepthStencilState(m_d3d._10.m_pd3d10NoDepthStencil, 0);
-		m_d3d._10.m_pd3d10Device->OMSetBlendState(m_d3d._10.m_pd3d10CalcGradBlendState, NULL, 0xFFFFFFFF);
-		m_d3d._10.m_pd3d10Device->RSSetState(m_d3d._10.m_pd3d10AlwaysSolidRasterizer);
-		// Draw
-		V_RETURN(cascade_states[cascade].m_pQuadMesh->Draw(NULL, NVWaveWorks_Mesh::PT_TriangleStrip, 0, 0, 4, 0, 2, NULL));
-
-
-		// Accumulating energy in foam energy map //////////////////////////////////
-
-		// Clear the foam map, to ensure inter-frame deps get broken on multi-GPU
-		m_d3d._10.m_pd3d10Device->ClearRenderTargetView(cascade_states[cascade].m_d3d._10.m_pd3d10FoamEnergyRenderTarget,kBlack);
-
-        // Render-targets + viewport
-		m_d3d._10.m_pd3d10Device->OMSetRenderTargets(1, &cascade_states[cascade].m_d3d._10.m_pd3d10FoamEnergyRenderTarget, NULL);
-
-        dmap_dim = m_params.cascades[cascade].fft_resolution;
-        new_vp.TopLeftX = 0;
-        new_vp.TopLeftY = 0;
-        new_vp.Width = dmap_dim;
-        new_vp.Height = dmap_dim;
-        new_vp.MinDepth = 0.f;
-        new_vp.MaxDepth = 0.f;
-        num_new_vp = 1;
-        m_d3d._10.m_pd3d10Device->RSSetViewports(num_new_vp, &new_vp);
-
-        // Shaders
-		m_d3d._10.m_pd3d10Device->VSSetShader(m_d3d._10.m_pd3d10FoamGenVS);
-        m_d3d._10.m_pd3d10Device->GSSetShader(NULL);
-		m_d3d._10.m_pd3d10Device->PSSetShader(m_d3d._10.m_pd3d10FoamGenPS);
-
-		// Constants
-		ps_foamgeneration_cbuffer fgcb;
-		fgcb.g_SourceComponents = gfsdk_make_float4(0,0,0.0f,1.0f); // getting component W of grad map as source for energy
-		fgcb.g_UVOffsets = gfsdk_make_float4(0,1.0f,0,0); // blurring by Y
-		fgcb.nvsf_g_DissipationFactors_Accumulation = m_params.cascades[cascade].foam_generation_amount*(float)m_dFoamSimDeltaTime*50.0f; 
-		fgcb.nvsf_g_DissipationFactors_Fadeout		= pow(m_params.cascades[cascade].foam_falloff_speed,(float)m_dFoamSimDeltaTime*50.0f);
-		fgcb.nvsf_g_DissipationFactors_BlurExtents	= min(0.5f,m_params.cascades[cascade].foam_dissipation_speed*(float)m_dFoamSimDeltaTime*m_params.cascades[0].fft_period * (1000.0f/m_params.cascades[0].fft_period)/m_params.cascades[cascade].fft_period)/dmap_dim;
-		fgcb.nvsf_g_FoamGenerationThreshold			= m_params.cascades[cascade].foam_generation_threshold;
-
-		m_d3d._10.m_pd3d10Device->UpdateSubresource(m_d3d._10.m_pd3d10FoamGenPixelShaderCB, 0, NULL, &fgcb, 0, 0);	    
-		m_d3d._10.m_pd3d10Device->PSSetConstantBuffers(0, 1, &m_d3d._10.m_pd3d10FoamGenPixelShaderCB);
-
-        // Textures/samplers
-        m_d3d._10.m_pd3d10Device->PSSetShaderResources(0, 1, &cascade_states[cascade].m_d3d._10.m_pd3d10GradientMap[m_active_GPU_slot]);
-		m_d3d._10.m_pd3d10Device->PSSetSamplers(0, 1, &m_d3d._10.m_pd3d10LinearNoMipSampler);
-
-		// Render state
-		m_d3d._10.m_pd3d10Device->OMSetDepthStencilState(m_d3d._10.m_pd3d10NoDepthStencil, 0);
-		m_d3d._10.m_pd3d10Device->OMSetBlendState(m_d3d._10.m_pd3d10AccumulateFoamBlendState, NULL, 0xFFFFFFFF);
-		m_d3d._10.m_pd3d10Device->RSSetState(m_d3d._10.m_pd3d10AlwaysSolidRasterizer);
-		// Draw
-		V_RETURN(cascade_states[cascade].m_pQuadMesh->Draw(NULL, NVWaveWorks_Mesh::PT_TriangleStrip, 0, 0, 4, 0, 2, NULL));
-
-		// Clear shader resource from inputs
-		ID3D10ShaderResourceView* pNullSRV = NULL;
-		m_d3d._10.m_pd3d10Device->PSSetShaderResources(0, 1, &pNullSRV);
-
-		// Writing back energy to gradient map //////////////////////////////////
-
-        // Render-targets + viewport
-		m_d3d._10.m_pd3d10Device->OMSetRenderTargets(1, &cascade_states[cascade].m_d3d._10.m_pd3d10GradientRenderTarget[m_active_GPU_slot], NULL);
-
-        dmap_dim = m_params.cascades[cascade].fft_resolution;
-        new_vp.TopLeftX = 0;
-        new_vp.TopLeftY = 0;
-        new_vp.Width = dmap_dim;
-        new_vp.Height = dmap_dim;
-        new_vp.MinDepth = 0.f;
-        new_vp.MaxDepth = 0.f;
-        num_new_vp = 1;
-        m_d3d._10.m_pd3d10Device->RSSetViewports(num_new_vp, &new_vp);
-
-        // Shaders
-		m_d3d._10.m_pd3d10Device->VSSetShader(m_d3d._10.m_pd3d10FoamGenVS);
-        m_d3d._10.m_pd3d10Device->GSSetShader(NULL);
-		m_d3d._10.m_pd3d10Device->PSSetShader(m_d3d._10.m_pd3d10FoamGenPS);
-
-		// Constants
-		fgcb.g_SourceComponents = gfsdk_make_float4(1.0f,0,0,0); // getting component R of energy map as source for energy
-		fgcb.g_UVOffsets = gfsdk_make_float4(1.0f,0,0,0); // blurring by X
-		fgcb.nvsf_g_DissipationFactors_Accumulation = 0.0f; 
-		fgcb.nvsf_g_DissipationFactors_Fadeout		= 1.0f;
-		fgcb.nvsf_g_DissipationFactors_BlurExtents	= min(0.5f,m_params.cascades[cascade].foam_dissipation_speed*(float)m_dFoamSimDeltaTime*m_params.cascades[0].fft_period * (1000.0f/m_params.cascades[0].fft_period)/m_params.cascades[cascade].fft_period)/dmap_dim;
-
-		m_d3d._10.m_pd3d10Device->UpdateSubresource(m_d3d._10.m_pd3d10FoamGenPixelShaderCB, 0, NULL, &fgcb, 0, 0);	    
-		m_d3d._10.m_pd3d10Device->PSSetConstantBuffers(0, 1, &m_d3d._10.m_pd3d10FoamGenPixelShaderCB);
-
-        // Textures/samplers
-		m_d3d._10.m_pd3d10Device->PSSetShaderResources(0, 1, &cascade_states[cascade].m_d3d._10.m_pd3d10FoamEnergyMap);
-		m_d3d._10.m_pd3d10Device->PSSetSamplers(0, 1, &m_d3d._10.m_pd3d10LinearNoMipSampler);
-
-		// Render state
-		m_d3d._10.m_pd3d10Device->OMSetDepthStencilState(m_d3d._10.m_pd3d10NoDepthStencil, 0);
-		m_d3d._10.m_pd3d10Device->OMSetBlendState(m_d3d._10.m_pd3d10WriteAccumulatedFoamBlendState, NULL, 0xFFFFFFFF);
-		m_d3d._10.m_pd3d10Device->RSSetState(m_d3d._10.m_pd3d10AlwaysSolidRasterizer);
-		
-		// Draw
-		V_RETURN(cascade_states[cascade].m_pQuadMesh->Draw(NULL, NVWaveWorks_Mesh::PT_TriangleStrip, 0, 0, 4, 0, 2, NULL));
-
-        // Generate mips
-        m_d3d._10.m_pd3d10Device->GenerateMips(cascade_states[cascade].m_d3d._10.m_pd3d10GradientMap[m_active_GPU_slot]);
-
-        cascade_states[cascade].m_gradient_map_version = cascade_states[cascade].m_pFFTSimulation->getDisplacementMapVersion();
-    }
-
-	// Clear any lingering displacement map reference
-	ID3D10ShaderResourceView* pNullSRV = NULL;
-	m_d3d._10.m_pd3d10Device->PSSetShaderResources(0, 1, &pNullSRV);
-
-    return S_OK;
-#else
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Simulation::updateGradientMapsD3D9(GFSDK_WaveWorks_Savestate* D3D9_ONLY(pSavestateImpl))
-{
-#if WAVEWORKS_ENABLE_D3D9
-    HRESULT hr;
-
-    // Preserve
-    const UINT NumPSConstants = 5;
-    if(pSavestateImpl)
-    {
-        V_RETURN(pSavestateImpl->PreserveD3D9Viewport());
-        V_RETURN(pSavestateImpl->PreserveD3D9RenderTargets());
-        V_RETURN(pSavestateImpl->PreserveD3D9Shaders());
-
-        V_RETURN(pSavestateImpl->PreserveD3D9PixelShaderConstantF(0, NumPSConstants));
-        V_RETURN(pSavestateImpl->PreserveD3D9Texture(0));
-        V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(0, D3DSAMP_MIPFILTER));
-        V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(0, D3DSAMP_MINFILTER));
-        V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(0, D3DSAMP_MAGFILTER));
-        V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(0, D3DSAMP_ADDRESSU));
-        V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(0, D3DSAMP_ADDRESSV));
-
-        V_RETURN(pSavestateImpl->PreserveD3D9RenderState(D3DRS_ZENABLE));
-        V_RETURN(pSavestateImpl->PreserveD3D9RenderState(D3DRS_ZWRITEENABLE));
-        V_RETURN(pSavestateImpl->PreserveD3D9RenderState(D3DRS_FILLMODE));
-        V_RETURN(pSavestateImpl->PreserveD3D9RenderState(D3DRS_CULLMODE));
-        V_RETURN(pSavestateImpl->PreserveD3D9RenderState(D3DRS_ALPHABLENDENABLE));
-        V_RETURN(pSavestateImpl->PreserveD3D9RenderState(D3DRS_ALPHATESTENABLE));
-        V_RETURN(pSavestateImpl->PreserveD3D9RenderState(D3DRS_COLORWRITEENABLE));
-        V_RETURN(pSavestateImpl->PreserveD3D9RenderState(D3DRS_STENCILENABLE));
-
-        for(int cascade = 0; cascade != m_params.num_cascades; ++cascade)
-        {
-            V_RETURN(cascade_states[cascade].m_pQuadMesh->PreserveState(NULL, pSavestateImpl));
-        }
-    }
-
-    for(int cascade = 0; cascade != m_params.num_cascades; ++cascade)
-    {
-        if(cascade_states[cascade].m_gradient_map_version == cascade_states[cascade].m_pFFTSimulation->getDisplacementMapVersion())
-            continue;
-
-		// DX9 FOAM
-
-		// Rendering folding to gradient map //////////////////////////////////
-        // Set targets
-        LPDIRECT3DSURFACE9 new_target_gradmap;
-        V_RETURN(cascade_states[cascade].m_d3d._9.m_pd3d9GradientMap[m_active_GPU_slot]->GetSurfaceLevel(0, &new_target_gradmap));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderTarget(0, new_target_gradmap));
-        SAFE_RELEASE(new_target_gradmap);
-
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetDepthStencilSurface(NULL));
-
-		// Clear the gradient map if necessary
-		const D3DCOLOR kBlack = 0x00000000;
-		if(cascade_states[cascade].m_gradient_map_needs_clear[m_active_GPU_slot]) {
-			V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_COLORWRITEENABLE	, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA));
-			V_RETURN(m_d3d._9.m_pd3d9Device->Clear(0,NULL,D3DCLEAR_TARGET,kBlack,0.f,0));
-			cascade_states[cascade].m_gradient_map_needs_clear[m_active_GPU_slot] = false;
-		}
-
-        // Shaders
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetVertexShader(m_d3d._9.m_pd3d9GradCalcVS));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShader(m_d3d._9.m_pd3d9GradCalcPS));
-
-        // Constants
-        int dmap_dim =m_params.cascades[cascade].fft_resolution;
-
-		gfsdk_float4 oneLeft = gfsdk_make_float4(-1.0f/dmap_dim, 0, 0, 0);
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(1, (FLOAT*)&oneLeft, 1));
-        gfsdk_float4 oneRight = gfsdk_make_float4( 1.0f/dmap_dim, 0, 0, 0);
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(2, (FLOAT*)&oneRight, 1));
-        gfsdk_float4 oneBack = gfsdk_make_float4( 0,-1.0f/dmap_dim, 0, 0);
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(3, (FLOAT*)&oneBack, 1));
-        gfsdk_float4 oneFront = gfsdk_make_float4( 0, 1.0f/dmap_dim, 0, 0);
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(4, (FLOAT*)&oneFront, 1));
-        //
-		gfsdk_F32 fGradMap2TexelWSScale = 0.5f*dmap_dim / m_params.cascades[cascade].fft_period;
-		gfsdk_F32 fChoppyScale = m_params.cascades[cascade].choppy_scale * dmap_dim / m_params.cascades[cascade].fft_period;
-		if(m_params.cascades[0].fft_period > 1000.0f) fChoppyScale *= 1.0f + 0.2f * log(m_params.cascades[0].fft_period/1000.0f);
-		gfsdk_float4 g_Scales = gfsdk_make_float4(fChoppyScale,fGradMap2TexelWSScale,0.f,0.f);
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(0, (FLOAT*)&g_Scales, 1));
-
-        // Textures/samplers
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(0, cascade_states[cascade].m_pFFTSimulation->GetDisplacementMapD3D9()));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
-
-        // Render state
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ZENABLE			, FALSE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ZWRITEENABLE		, FALSE)); 
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_FILLMODE			, D3DFILL_SOLID));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_CULLMODE			, D3DCULL_NONE ));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ALPHABLENDENABLE	, FALSE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ALPHATESTENABLE	, FALSE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_COLORWRITEENABLE	, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_STENCILENABLE		, FALSE));
-
-		// Draw
-		V_RETURN(cascade_states[cascade].m_pQuadMesh->Draw(NULL, NVWaveWorks_Mesh::PT_TriangleStrip, 0, 0, 4, 0, 2, NULL));
-
-		// Accumulating energy in foam energy map //////////////////////////////////
-
-        // Set targets
-        LPDIRECT3DSURFACE9 new_target_foamenergymap;
-        V_RETURN(cascade_states[cascade].m_d3d._9.m_pd3d9FoamEnergyMap->GetSurfaceLevel(0, &new_target_foamenergymap));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderTarget(0, new_target_foamenergymap));
-        SAFE_RELEASE(new_target_foamenergymap);
-
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetDepthStencilSurface(NULL));
-
-		// Clear the foam map, to ensure inter-frame deps get broken on multi-GPU
-		V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_COLORWRITEENABLE	, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA));
-		V_RETURN(m_d3d._9.m_pd3d9Device->Clear(0,NULL,D3DCLEAR_TARGET,kBlack,0.f,0));
-
-        // Shaders
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetVertexShader(m_d3d._9.m_pd3d9FoamGenVS));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShader(m_d3d._9.m_pd3d9FoamGenPS));
-
-        // Constants
-		gfsdk_float4 g_DissipationFactors;
-		g_DissipationFactors.z    = m_params.cascades[cascade].foam_generation_amount*(float)m_dFoamSimDeltaTime*50.0f; 
-			//nvsf_g_DissipationFactors_Accumulation
-		g_DissipationFactors.y	  = pow(m_params.cascades[cascade].foam_falloff_speed,(float)m_dFoamSimDeltaTime*50.0f);
-			//nvsf_g_DissipationFactors_Fadeout
-		g_DissipationFactors.x 	  = min(0.5f,m_params.cascades[cascade].foam_dissipation_speed*(float)m_dFoamSimDeltaTime*m_params.cascades[0].fft_period * (1000.0f/m_params.cascades[0].fft_period)/m_params.cascades[cascade].fft_period)/dmap_dim;
-			//g_DissipationFactors_BlurExtents
-		g_DissipationFactors.w    = m_params.cascades[cascade].foam_generation_threshold;
-			//nvsf_g_FoamGenerationThreshold
-		gfsdk_float4 g_SourceComponents = gfsdk_make_float4(0,0,0.0f,1.0f); // getting component W of grad map as source for energy
-		gfsdk_float4 g_UVOffsets = gfsdk_make_float4(0,1.0f,0,0);			 // blurring by Y
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(0, (FLOAT*)&g_DissipationFactors, 1));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(1, (FLOAT*)&g_SourceComponents, 1));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(2, (FLOAT*)&g_UVOffsets, 1));
-
-        // Textures / samplers
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(0, cascade_states[cascade].m_d3d._9.m_pd3d9GradientMap[m_active_GPU_slot]));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
-
-        // Render state
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ZENABLE			, FALSE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ZWRITEENABLE		, FALSE)); 
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_FILLMODE			, D3DFILL_SOLID));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_CULLMODE			, D3DCULL_NONE ));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ALPHABLENDENABLE	, FALSE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ALPHATESTENABLE	, FALSE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_COLORWRITEENABLE	, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_STENCILENABLE		, FALSE));
-
-        // Draw
-        V_RETURN(cascade_states[cascade].m_pQuadMesh->Draw(NULL, NVWaveWorks_Mesh::PT_TriangleStrip, 0, 0, 4, 0, 2, NULL));
-
-		// Writing back energy to gradient map //////////////////////////////////
-
-        // Set targets
-        LPDIRECT3DSURFACE9 new_target_gradmap_writeback;
-        V_RETURN(cascade_states[cascade].m_d3d._9.m_pd3d9GradientMap[m_active_GPU_slot]->GetSurfaceLevel(0, &new_target_gradmap_writeback));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderTarget(0, new_target_gradmap_writeback));
-        SAFE_RELEASE(new_target_gradmap_writeback);
-
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetDepthStencilSurface(NULL));
-
-        // Shaders
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetVertexShader(m_d3d._9.m_pd3d9FoamGenVS));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShader(m_d3d._9.m_pd3d9FoamGenPS));
-
-        // Constants
-		g_DissipationFactors.z    = 0; 
-			//nvsf_g_DissipationFactors_Accumulation
-		g_DissipationFactors.y	  = 1.0f;
-			//nvsf_g_DissipationFactors_Fadeout
-		g_DissipationFactors.x 	  = min(0.5f,m_params.cascades[cascade].foam_dissipation_speed*(float)m_dFoamSimDeltaTime*m_params.cascades[0].fft_period * (1000.0f/m_params.cascades[0].fft_period)/m_params.cascades[cascade].fft_period)/dmap_dim;
-			//g_DissipationFactors_BlurExtents
-		g_DissipationFactors.w    = 0;
-			//nvsf_g_FoamGenerationThreshold
-		g_SourceComponents = gfsdk_make_float4(1.0f,0,0,0); // getting component R of energy map as source for energy
-		g_UVOffsets = gfsdk_make_float4(1.0f,0,0,0);			 // blurring by Y
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(0, (FLOAT*)&g_DissipationFactors, 1));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(1, (FLOAT*)&g_SourceComponents, 1));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(2, (FLOAT*)&g_UVOffsets, 1));
-
-        // Textures / samplers
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(0, cascade_states[cascade].m_d3d._9.m_pd3d9FoamEnergyMap));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
-
-        // Render state
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ZENABLE			, FALSE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ZWRITEENABLE		, FALSE)); 
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_FILLMODE			, D3DFILL_SOLID));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_CULLMODE			, D3DCULL_NONE ));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ALPHABLENDENABLE	, FALSE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_ALPHATESTENABLE	, FALSE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_COLORWRITEENABLE	, D3DCOLORWRITEENABLE_ALPHA));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetRenderState(D3DRS_STENCILENABLE		, FALSE));
-
-        // Draw
-        V_RETURN(cascade_states[cascade].m_pQuadMesh->Draw(NULL, NVWaveWorks_Mesh::PT_TriangleStrip, 0, 0, 4, 0, 2, NULL));
-		
-        cascade_states[cascade].m_gradient_map_version = cascade_states[cascade].m_pFFTSimulation->getDisplacementMapVersion();
-    }
-
-    return S_OK;
-#else
-return E_FAIL;
-#endif
-}
-
 HRESULT GFSDK_WaveWorks_Simulation::updateGradientMapsD3D11(Graphics_Context* pGC, GFSDK_WaveWorks_Savestate* pSavestateImpl)
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -2877,14 +2061,6 @@ HRESULT GFSDK_WaveWorks_Simulation::setRenderState(	Graphics_Context* pGC,
 
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        return setRenderStateD3D9(matView, pShaderInputRegisterMappings, pSavestateImpl);
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        return setRenderStateD3D10(matView, pShaderInputRegisterMappings, pSavestateImpl);
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
 		{
@@ -2918,482 +2094,6 @@ HRESULT GFSDK_WaveWorks_Simulation::setRenderState(	Graphics_Context* pGC,
 #endif // WAVEWORKS_ENABLE_GRAPHICS
 }
 
-HRESULT GFSDK_WaveWorks_Simulation::setRenderStateD3D9(	const gfsdk_float4x4& D3D9_ONLY(matView),
-															const UINT* D3D9_ONLY(pShaderInputRegisterMappings),
-															GFSDK_WaveWorks_Savestate* D3D9_ONLY(pSavestateImpl)
-															)
-{
-#if WAVEWORKS_ENABLE_D3D9
-    HRESULT hr;
-
-	const UINT rm_g_samplerDisplacementMap0 = pShaderInputRegisterMappings[ShaderInputD3D9_g_samplerDisplacementMap0];
-    const UINT rm_g_samplerDisplacementMap1 = pShaderInputRegisterMappings[ShaderInputD3D9_g_samplerDisplacementMap1];
-	const UINT rm_g_samplerDisplacementMap2 = pShaderInputRegisterMappings[ShaderInputD3D9_g_samplerDisplacementMap2];
-    const UINT rm_g_samplerDisplacementMap3 = pShaderInputRegisterMappings[ShaderInputD3D9_g_samplerDisplacementMap3];
-    const UINT rm_g_samplerGradientMap0 = pShaderInputRegisterMappings[ShaderInputD3D9_g_samplerGradientMap0];
-    const UINT rm_g_samplerGradientMap1 = pShaderInputRegisterMappings[ShaderInputD3D9_g_samplerGradientMap1];
-    const UINT rm_g_samplerGradientMap2 = pShaderInputRegisterMappings[ShaderInputD3D9_g_samplerGradientMap2];
-    const UINT rm_g_samplerGradientMap3 = pShaderInputRegisterMappings[ShaderInputD3D9_g_samplerGradientMap3];
-    const UINT rm_g_WorldEye = pShaderInputRegisterMappings[ShaderInputD3D9_g_WorldEye];
-    const UINT rm_g_UVScaleCascade0123 = pShaderInputRegisterMappings[ShaderInputD3D9_g_UVScaleCascade0123];
-    const UINT rm_g_TexelLength_x2_PS = pShaderInputRegisterMappings[ShaderInputD3D9_g_TexelLength_x2_PS];
-    const UINT rm_g_Cascade1Scale_PS = pShaderInputRegisterMappings[ShaderInputD3D9_g_Cascade1Scale_PS];
-    const UINT rm_g_Cascade1TexelScale_PS = pShaderInputRegisterMappings[ShaderInputD3D9_g_Cascade1TexelScale_PS];
-    const UINT rm_g_Cascade1UVOffset_PS = pShaderInputRegisterMappings[ShaderInputD3D9_g_Cascade1UVOffset_PS];
-    const UINT rm_g_Cascade2Scale_PS = pShaderInputRegisterMappings[ShaderInputD3D9_g_Cascade2Scale_PS];
-    const UINT rm_g_Cascade2TexelScale_PS = pShaderInputRegisterMappings[ShaderInputD3D9_g_Cascade2TexelScale_PS];
-    const UINT rm_g_Cascade2UVOffset_PS = pShaderInputRegisterMappings[ShaderInputD3D9_g_Cascade2UVOffset_PS];
-    const UINT rm_g_Cascade3Scale_PS = pShaderInputRegisterMappings[ShaderInputD3D9_g_Cascade3Scale_PS];
-    const UINT rm_g_Cascade3TexelScale_PS = pShaderInputRegisterMappings[ShaderInputD3D9_g_Cascade3TexelScale_PS];
-    const UINT rm_g_Cascade3UVOffset_PS = pShaderInputRegisterMappings[ShaderInputD3D9_g_Cascade3UVOffset_PS];
-
-    const DWORD gradMapMinFilterMode = m_params.aniso_level > 1 ? D3DTEXF_ANISOTROPIC : D3DTEXF_LINEAR;
-
-    // Preserve state as necessary
-    if(pSavestateImpl)
-    {
-        if(rm_g_samplerDisplacementMap0 != nvrm_unused)
-        {
-            const UINT displacementMapSampler = D3DVERTEXTEXTURESAMPLER0 + rm_g_samplerDisplacementMap0;
-            V_RETURN(pSavestateImpl->PreserveD3D9Texture(displacementMapSampler));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MIPFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MINFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MAGFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_ADDRESSU));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_ADDRESSV));
-        }
-        if(rm_g_samplerDisplacementMap1 != nvrm_unused)
-        {
-            const UINT displacementMapSampler = D3DVERTEXTEXTURESAMPLER0 + rm_g_samplerDisplacementMap1;
-            V_RETURN(pSavestateImpl->PreserveD3D9Texture(displacementMapSampler));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MIPFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MINFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MAGFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_ADDRESSU));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_ADDRESSV));
-        }
-        if(rm_g_samplerDisplacementMap2 != nvrm_unused)
-        {
-            const UINT displacementMapSampler = D3DVERTEXTEXTURESAMPLER0 + rm_g_samplerDisplacementMap2;
-            V_RETURN(pSavestateImpl->PreserveD3D9Texture(displacementMapSampler));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MIPFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MINFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MAGFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_ADDRESSU));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_ADDRESSV));
-        }
-        if(rm_g_samplerDisplacementMap3 != nvrm_unused)
-        {
-            const UINT displacementMapSampler = D3DVERTEXTEXTURESAMPLER0 + rm_g_samplerDisplacementMap3;
-            V_RETURN(pSavestateImpl->PreserveD3D9Texture(displacementMapSampler));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MIPFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MINFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_MAGFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_ADDRESSU));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(displacementMapSampler, D3DSAMP_ADDRESSV));
-        }
-        //
-        if(rm_g_samplerGradientMap0 != nvrm_unused)
-        {
-            const UINT gradMapSampler = rm_g_samplerGradientMap0;
-            V_RETURN(pSavestateImpl->PreserveD3D9Texture(gradMapSampler));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MIPFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MINFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MAGFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_ADDRESSU));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_ADDRESSV));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MAXANISOTROPY));
-        }
-        if(rm_g_samplerGradientMap1 != nvrm_unused)
-        {
-            const UINT gradMapSampler = rm_g_samplerGradientMap1;
-            V_RETURN(pSavestateImpl->PreserveD3D9Texture(gradMapSampler));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MIPFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MINFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MAGFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_ADDRESSU));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_ADDRESSV));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MAXANISOTROPY));
-        }
-        if(rm_g_samplerGradientMap2 != nvrm_unused)
-        {
-            const UINT gradMapSampler = rm_g_samplerGradientMap2;
-            V_RETURN(pSavestateImpl->PreserveD3D9Texture(gradMapSampler));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MIPFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MINFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MAGFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_ADDRESSU));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_ADDRESSV));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MAXANISOTROPY));
-        }
-        if(rm_g_samplerGradientMap3 != nvrm_unused)
-        {
-            const UINT gradMapSampler = rm_g_samplerGradientMap3;
-            V_RETURN(pSavestateImpl->PreserveD3D9Texture(gradMapSampler));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MIPFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MINFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MAGFILTER));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_ADDRESSU));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_ADDRESSV));
-            V_RETURN(pSavestateImpl->PreserveD3D9SamplerState(gradMapSampler, D3DSAMP_MAXANISOTROPY));
-        }
-        //
-
-        if(rm_g_WorldEye != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9VertexShaderConstantF(rm_g_WorldEye, 1));
-        if(rm_g_UVScaleCascade0123 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9VertexShaderConstantF(rm_g_UVScaleCascade0123, 1));
-
-		if(rm_g_TexelLength_x2_PS != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9PixelShaderConstantF(rm_g_TexelLength_x2_PS, 1));
-        if(rm_g_Cascade1Scale_PS != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9PixelShaderConstantF(rm_g_Cascade1Scale_PS, 1));
-        if(rm_g_Cascade1TexelScale_PS != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9PixelShaderConstantF(rm_g_Cascade1TexelScale_PS, 1));
-        if(rm_g_Cascade1UVOffset_PS != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9PixelShaderConstantF(rm_g_Cascade1UVOffset_PS, 1));
-		if(rm_g_Cascade2Scale_PS != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9PixelShaderConstantF(rm_g_Cascade2Scale_PS, 1));
-        if(rm_g_Cascade2TexelScale_PS != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9PixelShaderConstantF(rm_g_Cascade2TexelScale_PS, 1));
-        if(rm_g_Cascade2UVOffset_PS != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9PixelShaderConstantF(rm_g_Cascade2UVOffset_PS, 1));
-        if(rm_g_Cascade3Scale_PS != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9PixelShaderConstantF(rm_g_Cascade3Scale_PS, 1));
-        if(rm_g_Cascade3TexelScale_PS != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9PixelShaderConstantF(rm_g_Cascade3TexelScale_PS, 1));
-        if(rm_g_Cascade3UVOffset_PS != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D9PixelShaderConstantF(rm_g_Cascade3UVOffset_PS, 1));
-    }
-
-    // Textures
-    if(rm_g_samplerDisplacementMap0 != nvrm_unused)
-    {
-        const UINT displacementMapSampler = D3DVERTEXTEXTURESAMPLER0 + rm_g_samplerDisplacementMap0;
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(displacementMapSampler, cascade_states[0].m_pFFTSimulation->GetDisplacementMapD3D9()));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MIPFILTER, D3DTEXF_NONE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MINFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
-    }
-    if(rm_g_samplerDisplacementMap1 != nvrm_unused)
-    {
-        const UINT displacementMapSampler = D3DVERTEXTEXTURESAMPLER0 + rm_g_samplerDisplacementMap1;
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(displacementMapSampler, cascade_states[1].m_pFFTSimulation->GetDisplacementMapD3D9()));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MIPFILTER, D3DTEXF_NONE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MINFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
-    }
-    if(rm_g_samplerDisplacementMap2 != nvrm_unused)
-    {
-        const UINT displacementMapSampler = D3DVERTEXTEXTURESAMPLER0 + rm_g_samplerDisplacementMap2;
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(displacementMapSampler, cascade_states[2].m_pFFTSimulation->GetDisplacementMapD3D9()));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MIPFILTER, D3DTEXF_NONE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MINFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
-    }
-    if(rm_g_samplerDisplacementMap3 != nvrm_unused)
-    {
-        const UINT displacementMapSampler = D3DVERTEXTEXTURESAMPLER0 + rm_g_samplerDisplacementMap3;
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(displacementMapSampler, cascade_states[3].m_pFFTSimulation->GetDisplacementMapD3D9()));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MIPFILTER, D3DTEXF_NONE));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MINFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(displacementMapSampler, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
-    }
-    //
-    if(rm_g_samplerGradientMap0 != nvrm_unused)
-    {
-        const UINT gradMapSampler = rm_g_samplerGradientMap0;
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(gradMapSampler, cascade_states[0].m_d3d._9.m_pd3d9GradientMap[m_active_GPU_slot]));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MINFILTER, gradMapMinFilterMode));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MAXANISOTROPY, m_params.aniso_level));
-    }
-    if(rm_g_samplerGradientMap1 != nvrm_unused)
-    {
-        const UINT gradMapSampler = rm_g_samplerGradientMap1;
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(gradMapSampler, cascade_states[1].m_d3d._9.m_pd3d9GradientMap[m_active_GPU_slot]));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MINFILTER, gradMapMinFilterMode));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MAXANISOTROPY, m_params.aniso_level));
-    }
-    if(rm_g_samplerGradientMap2 != nvrm_unused)
-    {
-        const UINT gradMapSampler = rm_g_samplerGradientMap2;
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(gradMapSampler, cascade_states[2].m_d3d._9.m_pd3d9GradientMap[m_active_GPU_slot]));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MINFILTER, gradMapMinFilterMode));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MAXANISOTROPY, m_params.aniso_level));
-    }
-    if(rm_g_samplerGradientMap3 != nvrm_unused)
-    {
-        const UINT gradMapSampler = rm_g_samplerGradientMap3;
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetTexture(gradMapSampler, cascade_states[3].m_d3d._9.m_pd3d9GradientMap[m_active_GPU_slot]));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MINFILTER, gradMapMinFilterMode));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetSamplerState(gradMapSampler, D3DSAMP_MAXANISOTROPY, m_params.aniso_level));
-    }
-    // Constants
-	gfsdk_float4 UVScaleCascade0123;
-	UVScaleCascade0123.x = 1.0f / m_params.cascades[0].fft_period;
-	UVScaleCascade0123.y = 1.0f / m_params.cascades[1].fft_period;
-	UVScaleCascade0123.z = 1.0f / m_params.cascades[2].fft_period;
-	UVScaleCascade0123.w = 1.0f / m_params.cascades[3].fft_period;
-
-	gfsdk_float4x4 inv_mat_view;
-	gfsdk_float4 vec_original = {0,0,0,1};
-	gfsdk_float4 vec_transformed;
-	mat4Inverse(inv_mat_view,matView);
-	vec4Mat4Mul(vec_transformed, vec_original, inv_mat_view);
-	gfsdk_float4 vGlobalEye = vec_transformed;
-
-	const gfsdk_float4 texel_len = gfsdk_make_float4(m_params.cascades[0].fft_period / m_params.cascades[0].fft_resolution,0,0,0);
-    const gfsdk_float4 cascade1Scale = gfsdk_make_float4(m_params.cascades[0].fft_period/m_params.cascades[1].fft_period,0,0,0);
-	const gfsdk_float4 cascade1TexelScale = gfsdk_make_float4((m_params.cascades[0].fft_period * m_params.cascades[1].fft_resolution) / (m_params.cascades[1].fft_period * m_params.cascades[0].fft_resolution),0,0,0);
-	const gfsdk_float4 cascade1UVOffset = gfsdk_make_float4(0,0,0,0);
-    const gfsdk_float4 cascade2Scale = gfsdk_make_float4(m_params.cascades[0].fft_period/m_params.cascades[2].fft_period,0,0,0);
-	const gfsdk_float4 cascade2TexelScale = gfsdk_make_float4((m_params.cascades[0].fft_period * m_params.cascades[2].fft_resolution) / (m_params.cascades[2].fft_period * m_params.cascades[0].fft_resolution),0,0,0);
-	const gfsdk_float4 cascade2UVOffset = gfsdk_make_float4(0,0,0,0);
-    const gfsdk_float4 cascade3Scale = gfsdk_make_float4(m_params.cascades[0].fft_period/m_params.cascades[3].fft_period,0,0,0);
-	const gfsdk_float4 cascade3TexelScale = gfsdk_make_float4((m_params.cascades[0].fft_period * m_params.cascades[3].fft_resolution) / (m_params.cascades[3].fft_period * m_params.cascades[0].fft_resolution),0,0,0);
-	const gfsdk_float4 cascade3UVOffset = gfsdk_make_float4(0,0,0,0);
-
-    if(rm_g_WorldEye != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetVertexShaderConstantF(rm_g_WorldEye, (FLOAT*)&vGlobalEye, 1));
-    if(rm_g_UVScaleCascade0123 != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetVertexShaderConstantF(rm_g_UVScaleCascade0123, (FLOAT*)&UVScaleCascade0123, 1));
-	if(rm_g_TexelLength_x2_PS != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(rm_g_TexelLength_x2_PS, (FLOAT*)&texel_len, 1));
-    //
-    if(rm_g_Cascade1Scale_PS != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(rm_g_Cascade1Scale_PS, (FLOAT*)&cascade1Scale, 1));
-    if(rm_g_Cascade1TexelScale_PS != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(rm_g_Cascade1TexelScale_PS, (FLOAT*)&cascade1TexelScale, 1));
-    if(rm_g_Cascade1UVOffset_PS != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(rm_g_Cascade1UVOffset_PS, (FLOAT*)&cascade1UVOffset, 1));
-    if(rm_g_Cascade2Scale_PS != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(rm_g_Cascade2Scale_PS, (FLOAT*)&cascade2Scale, 1));
-    if(rm_g_Cascade2TexelScale_PS != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(rm_g_Cascade2TexelScale_PS, (FLOAT*)&cascade2TexelScale, 1));
-    if(rm_g_Cascade2UVOffset_PS != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(rm_g_Cascade2UVOffset_PS, (FLOAT*)&cascade2UVOffset, 1));
-    if(rm_g_Cascade3Scale_PS != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(rm_g_Cascade3Scale_PS, (FLOAT*)&cascade3Scale, 1));
-    if(rm_g_Cascade3TexelScale_PS != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(rm_g_Cascade3TexelScale_PS, (FLOAT*)&cascade3TexelScale, 1));
-    if(rm_g_Cascade3UVOffset_PS != nvrm_unused)
-        V_RETURN(m_d3d._9.m_pd3d9Device->SetPixelShaderConstantF(rm_g_Cascade3UVOffset_PS, (FLOAT*)&cascade3UVOffset, 1));
-
-    return S_OK;
-#else
-return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Simulation::setRenderStateD3D10(	const gfsdk_float4x4& D3D10_ONLY(matView),
-															const UINT* D3D10_ONLY(pShaderInputRegisterMappings),
-															GFSDK_WaveWorks_Savestate* D3D10_ONLY(pSavestateImpl)
-															)
-{
-#if WAVEWORKS_ENABLE_D3D10
-    HRESULT hr;
-    const UINT rm_vs_buffer = pShaderInputRegisterMappings[ShaderInputD3D10_vs_buffer];
-    const UINT rm_g_samplerDisplacementMap0 = pShaderInputRegisterMappings[ShaderInputD3D10_g_samplerDisplacementMap0];
-    const UINT rm_g_samplerDisplacementMap1 = pShaderInputRegisterMappings[ShaderInputD3D10_g_samplerDisplacementMap1];
-	const UINT rm_g_samplerDisplacementMap2 = pShaderInputRegisterMappings[ShaderInputD3D10_g_samplerDisplacementMap2];
-	const UINT rm_g_samplerDisplacementMap3 = pShaderInputRegisterMappings[ShaderInputD3D10_g_samplerDisplacementMap3];
-    const UINT rm_g_textureDisplacementMap0 = pShaderInputRegisterMappings[ShaderInputD3D10_g_textureDisplacementMap0];
-    const UINT rm_g_textureDisplacementMap1 = pShaderInputRegisterMappings[ShaderInputD3D10_g_textureDisplacementMap1];
-	const UINT rm_g_textureDisplacementMap2 = pShaderInputRegisterMappings[ShaderInputD3D10_g_textureDisplacementMap2];
-	const UINT rm_g_textureDisplacementMap3 = pShaderInputRegisterMappings[ShaderInputD3D10_g_textureDisplacementMap3];
-    const UINT rm_ps_buffer = pShaderInputRegisterMappings[ShaderInputD3D10_ps_buffer];
-    const UINT rm_g_samplerGradientMap0 = pShaderInputRegisterMappings[ShaderInputD3D10_g_samplerGradientMap0];
-    const UINT rm_g_samplerGradientMap1 = pShaderInputRegisterMappings[ShaderInputD3D10_g_samplerGradientMap1];
-	const UINT rm_g_samplerGradientMap2 = pShaderInputRegisterMappings[ShaderInputD3D10_g_samplerGradientMap2];
-	const UINT rm_g_samplerGradientMap3 = pShaderInputRegisterMappings[ShaderInputD3D10_g_samplerGradientMap3];
-    const UINT rm_g_textureGradientMap0 = pShaderInputRegisterMappings[ShaderInputD3D10_g_textureGradientMap0];
-    const UINT rm_g_textureGradientMap1 = pShaderInputRegisterMappings[ShaderInputD3D10_g_textureGradientMap1];
-	const UINT rm_g_textureGradientMap2 = pShaderInputRegisterMappings[ShaderInputD3D10_g_textureGradientMap2];
-	const UINT rm_g_textureGradientMap3 = pShaderInputRegisterMappings[ShaderInputD3D10_g_textureGradientMap3];
-
-    // Preserve state as necessary
-    if(pSavestateImpl)
-    {
-        // Samplers/textures
-		//VS
-        if(rm_g_samplerDisplacementMap0 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10VertexShaderSampler(rm_g_samplerDisplacementMap0));
-        if(rm_g_samplerDisplacementMap1 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10VertexShaderSampler(rm_g_samplerDisplacementMap1));
-        if(rm_g_samplerDisplacementMap2 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10VertexShaderSampler(rm_g_samplerDisplacementMap2));
-        if(rm_g_samplerDisplacementMap3 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10VertexShaderSampler(rm_g_samplerDisplacementMap3));
-
-		if(rm_g_textureDisplacementMap0 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10VertexShaderResource(rm_g_textureDisplacementMap0));
-        if(rm_g_textureDisplacementMap1 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10VertexShaderResource(rm_g_textureDisplacementMap1));
-        if(rm_g_textureDisplacementMap2 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10VertexShaderResource(rm_g_textureDisplacementMap2));
-        if(rm_g_textureDisplacementMap3 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10VertexShaderResource(rm_g_textureDisplacementMap3));
-
-		// PS
-        if(rm_g_samplerGradientMap0 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderSampler(rm_g_samplerGradientMap0));
-        if(rm_g_samplerGradientMap1 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderSampler(rm_g_samplerGradientMap1));
-        if(rm_g_samplerGradientMap2 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderSampler(rm_g_samplerGradientMap2));
-        if(rm_g_samplerGradientMap3 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderSampler(rm_g_samplerGradientMap3));
-
-        if(rm_g_textureGradientMap0 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderResource(rm_g_textureGradientMap0));
-        if(rm_g_textureGradientMap1 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderResource(rm_g_textureGradientMap1));
-        if(rm_g_textureGradientMap2 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderResource(rm_g_textureGradientMap2));
-        if(rm_g_textureGradientMap3 != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderResource(rm_g_textureGradientMap3));
- 
-        // Constants
-        if(rm_vs_buffer != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10VertexShaderConstantBuffer(rm_vs_buffer));
-        if(rm_ps_buffer != nvrm_unused)
-            V_RETURN(pSavestateImpl->PreserveD3D10PixelShaderConstantBuffer(rm_ps_buffer));
-    }
-
-    // Vertex textures/samplers
-    if(rm_g_samplerDisplacementMap0 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->VSSetSamplers(rm_g_samplerDisplacementMap0, 1, &m_d3d._10.m_pd3d10LinearNoMipSampler);
-    if(rm_g_samplerDisplacementMap1 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->VSSetSamplers(rm_g_samplerDisplacementMap1, 1, &m_d3d._10.m_pd3d10LinearNoMipSampler);
-    if(rm_g_samplerDisplacementMap2 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->VSSetSamplers(rm_g_samplerDisplacementMap2, 1, &m_d3d._10.m_pd3d10LinearNoMipSampler);
-    if(rm_g_samplerDisplacementMap3 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->VSSetSamplers(rm_g_samplerDisplacementMap3, 1, &m_d3d._10.m_pd3d10LinearNoMipSampler);
-    //
-    if(rm_g_textureDisplacementMap0 != nvrm_unused)
-		m_d3d._10.m_pd3d10Device->VSSetShaderResources(rm_g_textureDisplacementMap0, 1, cascade_states[0].m_pFFTSimulation->GetDisplacementMapD3D10());
-    if(rm_g_textureDisplacementMap1 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->VSSetShaderResources(rm_g_textureDisplacementMap1, 1, cascade_states[1].m_pFFTSimulation->GetDisplacementMapD3D10());
-    if(rm_g_textureDisplacementMap2 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->VSSetShaderResources(rm_g_textureDisplacementMap2, 1, cascade_states[2].m_pFFTSimulation->GetDisplacementMapD3D10());
-    if(rm_g_textureDisplacementMap3 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->VSSetShaderResources(rm_g_textureDisplacementMap3, 1, cascade_states[3].m_pFFTSimulation->GetDisplacementMapD3D10());
-
-	
-	// Pixel textures/samplers
-    if(rm_g_samplerGradientMap0 != nvrm_unused)
-		m_d3d._10.m_pd3d10Device->PSSetSamplers(rm_g_samplerGradientMap0, 1, &m_d3d._10.m_pd3d10GradMapSampler);
-    if(rm_g_samplerGradientMap1 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->PSSetSamplers(rm_g_samplerGradientMap1, 1, &m_d3d._10.m_pd3d10GradMapSampler);
-    if(rm_g_samplerGradientMap2 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->PSSetSamplers(rm_g_samplerGradientMap2, 1, &m_d3d._10.m_pd3d10GradMapSampler);
-    if(rm_g_samplerGradientMap3 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->PSSetSamplers(rm_g_samplerGradientMap3, 1, &m_d3d._10.m_pd3d10GradMapSampler);
-	//
-    if(rm_g_textureGradientMap0 != nvrm_unused)
-		m_d3d._10.m_pd3d10Device->PSSetShaderResources(rm_g_textureGradientMap0, 1, &cascade_states[0].m_d3d._10.m_pd3d10GradientMap[m_active_GPU_slot]);
-    if(rm_g_textureGradientMap1 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->PSSetShaderResources(rm_g_textureGradientMap1, 1, &cascade_states[1].m_d3d._10.m_pd3d10GradientMap[m_active_GPU_slot]);
-    if(rm_g_textureGradientMap2 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->PSSetShaderResources(rm_g_textureGradientMap2, 1, &cascade_states[2].m_d3d._10.m_pd3d10GradientMap[m_active_GPU_slot]);
-    if(rm_g_textureGradientMap3 != nvrm_unused)
-        m_d3d._10.m_pd3d10Device->PSSetShaderResources(rm_g_textureGradientMap3, 1, &cascade_states[3].m_d3d._10.m_pd3d10GradientMap[m_active_GPU_slot]);
-	
-    // Constants
-    vs_attr_cbuffer VSCB;
-    vs_attr_cbuffer* pVSCB = NULL;
-    if(rm_vs_buffer != nvrm_unused)
-    {
-        pVSCB = &VSCB;
-
-        pVSCB->g_UVScaleCascade0123[0] = 1.0f / m_params.cascades[0].fft_period;
-        pVSCB->g_UVScaleCascade0123[1] = 1.0f / m_params.cascades[1].fft_period;
-        pVSCB->g_UVScaleCascade0123[2] = 1.0f / m_params.cascades[2].fft_period;
-        pVSCB->g_UVScaleCascade0123[3] = 1.0f / m_params.cascades[3].fft_period;
-
-		gfsdk_float4x4 inv_mat_view;
-		gfsdk_float4 vec_original = {0,0,0,1};
-		gfsdk_float4 vec_transformed;
-		mat4Inverse(inv_mat_view,matView);
-		vec4Mat4Mul(vec_transformed, vec_original, inv_mat_view);
-		gfsdk_float4 vGlobalEye = vec_transformed;
-
-        pVSCB->g_WorldEye[0] = vGlobalEye.x;
-        pVSCB->g_WorldEye[1] = vGlobalEye.y;
-        pVSCB->g_WorldEye[2] = vGlobalEye.z;
-    }
-
-	ps_attr_cbuffer PSCB;
-    ps_attr_cbuffer* pPSCB = NULL;
-	const FLOAT texel_len = m_params.cascades[0].fft_period / m_params.cascades[0].fft_resolution;
-    const float cascade1Scale = m_params.cascades[0].fft_period/m_params.cascades[1].fft_period;
-    const float cascade1UVOffset = 0.f; // half-pixel not required in D3D10
-    const float cascade2Scale = m_params.cascades[0].fft_period/m_params.cascades[2].fft_period;
-    const float cascade2UVOffset = 0.f; // half-pixel not required in D3D10
-    const float cascade3Scale = m_params.cascades[0].fft_period/m_params.cascades[3].fft_period;
-    const float cascade3UVOffset = 0.f; // half-pixel not required in D3D10
-
-    if(rm_ps_buffer != nvrm_unused)
-    {
-        pPSCB = &PSCB;
-		pPSCB->g_TexelLength_x2_PS = texel_len;
-    }
-
-    if(NULL != pPSCB)
-    {
-        pPSCB->g_Cascade1Scale_PS = cascade1Scale;
-        pPSCB->g_Cascade1UVOffset_PS = cascade1UVOffset;
-        pPSCB->g_Cascade2Scale_PS = cascade2Scale;
-        pPSCB->g_Cascade2UVOffset_PS = cascade2UVOffset;
-        pPSCB->g_Cascade3Scale_PS = cascade3Scale;
-        pPSCB->g_Cascade3UVOffset_PS = cascade3UVOffset;
-        pPSCB->g_Cascade1TexelScale_PS = (m_params.cascades[0].fft_period * m_params.cascades[1].fft_resolution) / (m_params.cascades[1].fft_period * m_params.cascades[0].fft_resolution);
-		pPSCB->g_Cascade2TexelScale_PS = (m_params.cascades[0].fft_period * m_params.cascades[2].fft_resolution) / (m_params.cascades[2].fft_period * m_params.cascades[0].fft_resolution);
-		pPSCB->g_Cascade3TexelScale_PS = (m_params.cascades[0].fft_period * m_params.cascades[3].fft_resolution) / (m_params.cascades[3].fft_period * m_params.cascades[0].fft_resolution);
-    }
-
-    if(pVSCB)
-    {
-        m_d3d._10.m_pd3d10Device->UpdateSubresource(m_d3d._10.m_pd3d10VertexShaderCB, 0, NULL, pVSCB, 0, 0);
-        m_d3d._10.m_pd3d10Device->VSSetConstantBuffers(rm_vs_buffer, 1, &m_d3d._10.m_pd3d10VertexShaderCB);
-    }
-
-    if(pPSCB)
-    {
-        m_d3d._10.m_pd3d10Device->UpdateSubresource(m_d3d._10.m_pd3d10PixelShaderCB, 0, NULL, pPSCB, 0, 0);
-        m_d3d._10.m_pd3d10Device->PSSetConstantBuffers(rm_ps_buffer, 1, &m_d3d._10.m_pd3d10PixelShaderCB);
-    }
-
-    return S_OK;
-#else
-return E_FAIL;
-#endif
-}
-
 HRESULT GFSDK_WaveWorks_Simulation::setRenderStateD3D11(	ID3D11DeviceContext* D3D11_ONLY(pDC),
 															const gfsdk_float4x4& D3D11_ONLY(matView),
 															const UINT* D3D11_ONLY(pShaderInputRegisterMappings),
@@ -4270,16 +2970,6 @@ HRESULT GFSDK_WaveWorks_Simulation::kick(gfsdk_U64* pKickID, Graphics_Context* p
     return S_OK;
 }
 
-HRESULT GFSDK_WaveWorks_Simulation::getShaderInputCountD3D9()
-{
-    return NumShaderInputsD3D9;
-}
-
-HRESULT GFSDK_WaveWorks_Simulation::getShaderInputCountD3D10()
-{
-    return NumShaderInputsD3D10;
-}
-
 HRESULT GFSDK_WaveWorks_Simulation::getShaderInputCountD3D11()
 {
     return NumShaderInputsD3D11;
@@ -4300,34 +2990,6 @@ HRESULT GFSDK_WaveWorks_Simulation::getTextureUnitCountGL2(bool useTextureArrays
 	return useTextureArrays? 2:8;
 }
 
-HRESULT GFSDK_WaveWorks_Simulation::getShaderInputDescD3D9(UINT D3D9_ONLY(inputIndex), GFSDK_WaveWorks_ShaderInput_Desc* D3D9_ONLY(pDesc))
-{
-#if WAVEWORKS_ENABLE_D3D9
-    if(inputIndex >= NumShaderInputsD3D9)
-        return E_FAIL;
-
-    *pDesc = ShaderInputDescsD3D9[inputIndex];
-
-    return S_OK;
-#else // WAVEWORKS_ENABLE_D3D9
-	return E_FAIL;
-#endif
-}
-
-HRESULT GFSDK_WaveWorks_Simulation::getShaderInputDescD3D10(UINT D3D10_ONLY(inputIndex), GFSDK_WaveWorks_ShaderInput_Desc* D3D10_ONLY(pDesc))
-{
-#if WAVEWORKS_ENABLE_D3D10
-    if(inputIndex >= NumShaderInputsD3D10)
-        return E_FAIL;
-
-    *pDesc = ShaderInputDescsD3D10[inputIndex];
-
-    return S_OK;
-#else // WAVEWORKS_ENABLE_D3D10
-	return E_FAIL;
-#endif
-}
-
 HRESULT GFSDK_WaveWorks_Simulation::getShaderInputDescD3D11(UINT D3D11_ONLY(inputIndex), GFSDK_WaveWorks_ShaderInput_Desc* D3D11_ONLY(pDesc))
 {
 #if WAVEWORKS_ENABLE_D3D11
@@ -4424,36 +3086,7 @@ HRESULT GFSDK_WaveWorks_Simulation::allocateRenderingResources(int cascade)
 	{
 		switch(m_d3dAPI)
 		{
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			{
-				V_RETURN(m_d3d._9.m_pd3d9Device->CreateTexture(dmap_dim, dmap_dim, 0, D3DUSAGE_RENDERTARGET|D3DUSAGE_AUTOGENMIPMAP, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &cascade_states[cascade].m_d3d._9.m_pd3d9GradientMap[gpu_slot], NULL));
-			}
-			break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			{
-				D3D10_TEXTURE2D_DESC gradMapTD;
-				gradMapTD.Width = dmap_dim;
-				gradMapTD.Height = dmap_dim;
-				gradMapTD.MipLevels = 0;
-				gradMapTD.ArraySize = 1;
-				gradMapTD.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
-				gradMapTD.SampleDesc = kNoSample;
-				gradMapTD.Usage = D3D10_USAGE_DEFAULT;
-				gradMapTD.BindFlags = D3D10_BIND_SHADER_RESOURCE | D3D10_BIND_RENDER_TARGET;
-				gradMapTD.CPUAccessFlags = 0;
-				gradMapTD.MiscFlags = D3D10_RESOURCE_MISC_GENERATE_MIPS;
 
-				ID3D10Texture2D* pD3D10Texture = NULL;
-				V_RETURN(m_d3d._10.m_pd3d10Device->CreateTexture2D(&gradMapTD, NULL, &pD3D10Texture));
-				V_RETURN(m_d3d._10.m_pd3d10Device->CreateShaderResourceView(pD3D10Texture, NULL, &cascade_states[cascade].m_d3d._10.m_pd3d10GradientMap[gpu_slot]));
-				V_RETURN(m_d3d._10.m_pd3d10Device->CreateRenderTargetView(pD3D10Texture, NULL, &cascade_states[cascade].m_d3d._10.m_pd3d10GradientRenderTarget[gpu_slot]));
-				SAFE_RELEASE(pD3D10Texture);
-			}
-			break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			{
@@ -4561,37 +3194,6 @@ HRESULT GFSDK_WaveWorks_Simulation::allocateRenderingResources(int cascade)
 
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			V_RETURN(m_d3d._9.m_pd3d9Device->CreateTexture(dmap_dim, dmap_dim, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R16F, D3DPOOL_DEFAULT, &cascade_states[cascade].m_d3d._9.m_pd3d9FoamEnergyMap, NULL));
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-            D3D10_TEXTURE2D_DESC foamenergyTD;
-            foamenergyTD.Width = dmap_dim;
-            foamenergyTD.Height = dmap_dim;
-            foamenergyTD.MipLevels = 1;
-            foamenergyTD.ArraySize = 1;
-			foamenergyTD.Format = DXGI_FORMAT_R16_FLOAT;
-            foamenergyTD.SampleDesc = kNoSample;
-            foamenergyTD.Usage = D3D10_USAGE_DEFAULT;
-            foamenergyTD.BindFlags = D3D10_BIND_SHADER_RESOURCE | D3D10_BIND_RENDER_TARGET;
-            foamenergyTD.CPUAccessFlags = 0;
-            foamenergyTD.MiscFlags = 0;
-
-            ID3D10Texture2D* pD3D10FoamEnergyTexture = NULL;
-            V_RETURN(m_d3d._10.m_pd3d10Device->CreateTexture2D(&foamenergyTD, NULL, &pD3D10FoamEnergyTexture));
-			V_RETURN(m_d3d._10.m_pd3d10Device->CreateShaderResourceView(pD3D10FoamEnergyTexture, NULL, &cascade_states[cascade].m_d3d._10.m_pd3d10FoamEnergyMap));
-			V_RETURN(m_d3d._10.m_pd3d10Device->CreateRenderTargetView(pD3D10FoamEnergyTexture, NULL, &cascade_states[cascade].m_d3d._10.m_pd3d10FoamEnergyRenderTarget));
-            SAFE_RELEASE(pD3D10FoamEnergyTexture);
-		
-		}
-		break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -4673,21 +3275,6 @@ void GFSDK_WaveWorks_Simulation::releaseRenderingResources(int cascade)
 	{
 		switch(m_d3dAPI)
 		{
-#if WAVEWORKS_ENABLE_D3D9
-		case nv_water_d3d_api_d3d9:
-			{
-				SAFE_RELEASE(cascade_states[cascade].m_d3d._9.m_pd3d9GradientMap[gpu_slot]);
-			}
-			break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-		case nv_water_d3d_api_d3d10:
-			{
-				SAFE_RELEASE(cascade_states[cascade].m_d3d._10.m_pd3d10GradientMap[gpu_slot]);
-				SAFE_RELEASE(cascade_states[cascade].m_d3d._10.m_pd3d10GradientRenderTarget[gpu_slot]);
-			}
-			break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		case nv_water_d3d_api_d3d11:
 			{
@@ -4718,20 +3305,6 @@ void GFSDK_WaveWorks_Simulation::releaseRenderingResources(int cascade)
 
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-            SAFE_RELEASE(cascade_states[cascade].m_d3d._9.m_pd3d9FoamEnergyMap);
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			SAFE_RELEASE(cascade_states[cascade].m_d3d._10.m_pd3d10FoamEnergyMap);
-			SAFE_RELEASE(cascade_states[cascade].m_d3d._10.m_pd3d10FoamEnergyRenderTarget);
-		}
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
@@ -4771,11 +3344,6 @@ HRESULT GFSDK_WaveWorks_Simulation::initQuadMesh(int GFX_ONLY(cascade))
 
     // Vertices
     float tex_adjust = 0.f;
-    if(nv_water_d3d_api_d3d9 == m_d3dAPI)
-    {
-        // Half-texel offset required in D3D9
-        tex_adjust = 0.5f / m_params.cascades[cascade].fft_resolution;
-    }
 
     float vertices[] = {-1.0f,  1.0f, 0,	tex_adjust,      tex_adjust,     
                         -1.0f, -1.0f, 0,	tex_adjust,      tex_adjust+1.0f,
@@ -4798,42 +3366,6 @@ HRESULT GFSDK_WaveWorks_Simulation::initQuadMesh(int GFX_ONLY(cascade))
     // Init mesh
     switch(m_d3dAPI)
     {
-#if WAVEWORKS_ENABLE_D3D9
-    case nv_water_d3d_api_d3d9:
-        {
-			HRESULT hr;
-
-            const D3DVERTEXELEMENT9 quad_decl[] =
-            {
-                {0,  0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
-                {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
-                D3DDECL_END()
-            };
-
-            V_RETURN(NVWaveWorks_Mesh::CreateD3D9(m_d3d._9.m_pd3d9Device, quad_decl, VertexStride, vertices, 4, indices, 4, &cascade_states[cascade].m_pQuadMesh));
-        }
-        break;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-    case nv_water_d3d_api_d3d10:
-        {
-			HRESULT hr;
-
-            const D3D10_INPUT_ELEMENT_DESC quad_layout[] = {
-                { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
-                { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
-            };
-            const UINT num_layout_elements = sizeof(quad_layout)/sizeof(quad_layout[0]);
-
-            V_RETURN(NVWaveWorks_Mesh::CreateD3D10(	m_d3d._10.m_pd3d10Device,
-													quad_layout, num_layout_elements,
-													SM4::CalcGradient::g_vs, sizeof(SM4::CalcGradient::g_vs),
-													VertexStride, vertices, 4, indices, 4,
-													&cascade_states[cascade].m_pQuadMesh
-													));
-        }
-        break;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
     case nv_water_d3d_api_d3d11:
         {
diff --git a/src/Simulation_impl.h b/src/Simulation_impl.h
index 0a80e71..d450927 100644
--- a/src/Simulation_impl.h
+++ b/src/Simulation_impl.h
@@ -69,8 +69,6 @@ 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);
@@ -110,10 +108,6 @@ public:
 										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();
@@ -127,20 +121,10 @@ 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,
@@ -171,24 +155,6 @@ private:
 		// 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
         {
@@ -219,12 +185,6 @@ private:
 #endif
 		union
         {
-#if WAVEWORKS_ENABLE_D3D9
-            D3D9Objects _9;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-            D3D10Objects _10;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 			D3D11Objects _11;
 #endif
@@ -271,49 +231,6 @@ private:
     // 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
     {
@@ -417,12 +334,6 @@ private:
 #endif
 	union
     {
-#if WAVEWORKS_ENABLE_D3D9
-        D3D9Objects _9;
-#endif
-#if WAVEWORKS_ENABLE_D3D10
-        D3D10Objects _10;
-#endif
 #if WAVEWORKS_ENABLE_D3D11
 		D3D11Objects _11;
 #endif