From d7578eed4f1e329b6a44865f8f2acbf5a1854b29 Mon Sep 17 00:00:00 2001 From: Xottab-DUTY Date: Sat, 30 Dec 2017 01:46:00 +0500 Subject: [PATCH] Return OpenGL renderer back! Revert "Revert "Merge pull request #103 from Armada651/opengl"" This reverts commit 5f019d8f883625af96a0ead06c5f0c732e456e87. --- src/Include/xrAPI/xrAPI.h | 2 + src/Layers/xrRender/Blender_BmmD.cpp | 54 ++++ .../xrRender/Blender_Editor_Selection.cpp | 6 +- src/Layers/xrRender/Blender_Editor_Wire.cpp | 6 +- src/Layers/xrRender/Blender_Lm(EbB).cpp | 2 +- src/Layers/xrRender/Blender_Model_EbB.cpp | 51 ++++ src/Layers/xrRender/Blender_Particle.cpp | 44 +-- src/Layers/xrRender/Blender_Recorder_R2.cpp | 2 +- src/Layers/xrRender/Blender_Screen_SET.cpp | 90 +++++- src/Layers/xrRender/Blender_tree.cpp | 81 ++++++ src/Layers/xrRender/ColorMapManager.cpp | 14 + src/Layers/xrRender/D3DUtils.cpp | 4 +- src/Layers/xrRender/D3DXRenderBase.h | 6 +- src/Layers/xrRender/Debug/dxPixEventWrapper.h | 2 +- src/Layers/xrRender/DetailManager.cpp | 4 +- src/Layers/xrRender/DetailManager.h | 7 +- src/Layers/xrRender/DetailManager_VS.cpp | 24 +- src/Layers/xrRender/DetailModel.cpp | 4 +- src/Layers/xrRender/FBasicVisual.cpp | 5 + src/Layers/xrRender/FBasicVisual.h | 12 +- src/Layers/xrRender/FSkinned.cpp | 182 ++++++++----- src/Layers/xrRender/FTreeVisual.cpp | 8 + src/Layers/xrRender/FVisual.cpp | 58 ++-- src/Layers/xrRender/HW.h | 43 ++- src/Layers/xrRender/HWCaps.cpp | 6 +- src/Layers/xrRender/Light_DB.cpp | 4 +- src/Layers/xrRender/Light_Package.cpp | 4 +- .../Light_Render_Direct.cpp | 0 .../Light_Render_Direct.h | 0 .../Light_Render_Direct_ComputeXFS.cpp | 0 src/Layers/xrRender/ModelPool.cpp | 17 +- src/Layers/xrRender/QueryHelper.h | 90 ++++-- src/Layers/xrRender/R_Backend.cpp | 42 ++- src/Layers/xrRender/R_Backend.h | 256 +++++++++++------- src/Layers/xrRender/R_Backend_DBG.cpp | 8 +- src/Layers/xrRender/R_Backend_Runtime.cpp | 75 ++--- src/Layers/xrRender/R_Backend_Runtime.h | 29 +- src/Layers/xrRender/R_DStreams.cpp | 54 +++- src/Layers/xrRender/R_DStreams.h | 34 ++- src/Layers/xrRender/ResourceManager.cpp | 4 +- src/Layers/xrRender/ResourceManager.h | 14 +- src/Layers/xrRender/ResourceManager_Reset.cpp | 12 +- src/Layers/xrRender/SH_Atomic.cpp | 59 ++-- src/Layers/xrRender/SH_Atomic.h | 27 +- src/Layers/xrRender/SH_RT.h | 6 + src/Layers/xrRender/SH_Texture.cpp | 2 + src/Layers/xrRender/SH_Texture.h | 87 +++++- src/Layers/xrRender/Shader.cpp | 10 +- src/Layers/xrRender/Shader.h | 15 +- src/Layers/xrRender/SkeletonX.cpp | 2 +- src/Layers/xrRender/SkeletonX.h | 4 +- src/Layers/xrRender/WallmarksEngine.cpp | 2 +- .../xrRender/blenders/Blender_Recorder.cpp | 2 +- .../xrRender/blenders/Blender_Recorder.h | 13 +- src/Layers/xrRender/dxApplicationRender.cpp | 8 +- src/Layers/xrRender/dxConsoleRender.cpp | 2 +- src/Layers/xrRender/dxConsoleRender.h | 2 +- src/Layers/xrRender/dxDebugRender.cpp | 2 +- src/Layers/xrRender/dxEnvironmentRender.cpp | 15 +- src/Layers/xrRender/light.cpp | 28 +- src/Layers/xrRender/light.h | 16 +- .../{xrRenderPC_R2 => xrRender}/light_GI.cpp | 0 .../{xrRenderPC_R2 => xrRender}/light_gi.h | 0 .../light_smapvis.cpp | 0 .../light_smapvis.h | 0 .../{xrRenderPC_R2 => xrRender}/light_vis.cpp | 0 src/Layers/xrRender/r__dsgraph_build.cpp | 87 ++++-- src/Layers/xrRender/r__dsgraph_render.cpp | 10 +- src/Layers/xrRender/r__dsgraph_types.h | 27 +- src/Layers/xrRender/r__occlusion.cpp | 9 +- src/Layers/xrRender/r__occlusion.h | 4 + src/Layers/xrRender/r__screenshot.cpp | 124 ++++----- src/Layers/xrRender/r__sector_traversal.cpp | 2 +- src/Layers/xrRender/r_constants.cpp | 13 +- src/Layers/xrRender/r_constants.h | 22 +- src/Layers/xrRender/r_constants_cache.h | 4 +- src/Layers/xrRender/tss.h | 2 +- src/Layers/xrRender/tss_def.cpp | 17 ++ src/Layers/xrRender/tss_def.h | 4 + src/Layers/xrRender/xrD3DDefs.h | 27 +- src/Layers/xrRender/xrRender_console.cpp | 20 +- .../xrRenderDX10/Blender_Recorder_R3.cpp | 4 +- .../dx10ShaderResourceStateCache.cpp | 12 +- .../dx10ShaderResourceStateCache.h | 12 +- .../dx10MinMaxSMBlender.cpp | 0 .../dx10MinMaxSMBlender.h | 0 src/Layers/xrRenderDX10/dx10SH_Texture.cpp | 2 + src/Layers/xrRenderPC_GL/gl_R_render.cpp | 4 +- src/Layers/xrRenderPC_GL/gl_loader.cpp | 13 +- src/Layers/xrRenderPC_GL/rgl.h | 2 +- src/Layers/xrRenderPC_GL/xrRender_GL.cpp | 24 +- src/Layers/xrRenderPC_GL/xrRender_GL.vcxproj | 193 +++++-------- src/Layers/xrRenderPC_R1/stdafx.h | 1 + src/Layers/xrRenderPC_R2/r2.h | 2 +- src/Layers/xrRenderPC_R2/stdafx.h | 1 + src/Layers/xrRenderPC_R2/xrRender_R2.vcxproj | 16 +- .../xrRenderPC_R2/xrRender_R2.vcxproj.filters | 16 +- .../xrRenderPC_R3/Light_Render_Direct.cpp | 2 - src/Layers/xrRenderPC_R3/r3.h | 2 +- src/Layers/xrRenderPC_R3/r3_rendertarget.cpp | 2 +- src/Layers/xrRenderPC_R3/stdafx.h | 1 + src/Layers/xrRenderPC_R3/xrRender_R3.vcxproj | 20 +- .../xrRenderPC_R3/xrRender_R3.vcxproj.filters | 20 +- .../xrRenderPC_R4/Light_Render_Direct.cpp | 2 - src/Layers/xrRenderPC_R4/r4.h | 2 +- src/Layers/xrRenderPC_R4/stdafx.h | 1 + src/Layers/xrRenderPC_R4/xrRender_R4.vcxproj | 16 +- .../xrRenderPC_R4/xrRender_R4.vcxproj.filters | 16 +- src/engine.sln | 28 ++ src/xrEngine/EngineAPI.cpp | 30 +- src/xrEngine/EngineAPI.h | 1 + src/xrEngine/defines.h | 5 +- src/xrEngine/main.cpp | 6 +- src/xrEngine/xrSASH.cpp | 10 +- src/xrEngine/xr_ioc_cmd.cpp | 4 +- 115 files changed, 1779 insertions(+), 725 deletions(-) rename src/Layers/{xrRenderPC_R2 => xrRender}/Light_Render_Direct.cpp (100%) rename src/Layers/{xrRenderPC_R2 => xrRender}/Light_Render_Direct.h (100%) rename src/Layers/{xrRenderPC_R3 => xrRender}/Light_Render_Direct_ComputeXFS.cpp (100%) rename src/Layers/{xrRenderPC_R2 => xrRender}/light_GI.cpp (100%) rename src/Layers/{xrRenderPC_R2 => xrRender}/light_gi.h (100%) rename src/Layers/{xrRenderPC_R2 => xrRender}/light_smapvis.cpp (100%) rename src/Layers/{xrRenderPC_R2 => xrRender}/light_smapvis.h (100%) rename src/Layers/{xrRenderPC_R2 => xrRender}/light_vis.cpp (100%) rename src/Layers/{xrRenderPC_R3 => xrRenderDX10}/dx10MinMaxSMBlender.cpp (100%) rename src/Layers/{xrRenderPC_R3 => xrRenderDX10}/dx10MinMaxSMBlender.h (100%) delete mode 100644 src/Layers/xrRenderPC_R3/Light_Render_Direct.cpp delete mode 100644 src/Layers/xrRenderPC_R4/Light_Render_Direct.cpp diff --git a/src/Include/xrAPI/xrAPI.h b/src/Include/xrAPI/xrAPI.h index b68b64c7a38..b3b1b57b89a 100644 --- a/src/Include/xrAPI/xrAPI.h +++ b/src/Include/xrAPI/xrAPI.h @@ -35,10 +35,12 @@ class XRAPI_API EngineGlobalEnvironment SupportCheck CheckR2; SupportCheck CheckR3; SupportCheck CheckR4; + SupportCheck CheckRGL; SetupEnv SetupR1; SetupEnv SetupR2; SetupEnv SetupR3; SetupEnv SetupR4; + SetupEnv SetupRGL; SetupEnv SetupCurrentRenderer; }; diff --git a/src/Layers/xrRender/Blender_BmmD.cpp b/src/Layers/xrRender/Blender_BmmD.cpp index 47c8a3e34e8..af8c703acad 100644 --- a/src/Layers/xrRender/Blender_BmmD.cpp +++ b/src/Layers/xrRender/Blender_BmmD.cpp @@ -182,6 +182,60 @@ void CBlender_BmmD::Compile(CBlender_Compile& C) break; } } +#elif RENDER==R_GL +////////////////////////////////////////////////////////////////////////// +// GL +////////////////////////////////////////////////////////////////////////// +#include "uber_deffer.h" +void CBlender_BmmD::Compile (CBlender_Compile& C) +{ + IBlender::Compile (C); + // codepath is the same, only the shaders differ + // ***only pixel shaders differ*** + string256 mask; + strconcat (sizeof(mask),mask,C.L_textures[0].c_str(),"_mask"); + switch(C.iElement) + { + case SE_R2_NORMAL_HQ: // deffer + uber_deffer (C, true, "impl","impl",false,oT2_Name[0]?oT2_Name:0,true); + C.r_Sampler ("s_mask", mask); + C.r_Sampler ("s_lmap", C.L_textures[1]); + + C.r_Sampler ("s_dt_r", oR_Name, false, D3DTADDRESS_WRAP, D3DTEXF_ANISOTROPIC,D3DTEXF_LINEAR, D3DTEXF_ANISOTROPIC); + C.r_Sampler ("s_dt_g", oG_Name, false, D3DTADDRESS_WRAP, D3DTEXF_ANISOTROPIC,D3DTEXF_LINEAR, D3DTEXF_ANISOTROPIC); + C.r_Sampler ("s_dt_b", oB_Name, false, D3DTADDRESS_WRAP, D3DTEXF_ANISOTROPIC,D3DTEXF_LINEAR, D3DTEXF_ANISOTROPIC); + C.r_Sampler ("s_dt_a", oA_Name, false, D3DTADDRESS_WRAP, D3DTEXF_ANISOTROPIC,D3DTEXF_LINEAR, D3DTEXF_ANISOTROPIC); + + C.r_Sampler ("s_dn_r", strconcat(sizeof(mask),mask,oR_Name,"_bump") ); + C.r_Sampler ("s_dn_g", strconcat(sizeof(mask),mask,oG_Name,"_bump") ); + C.r_Sampler ("s_dn_b", strconcat(sizeof(mask),mask,oB_Name,"_bump") ); + C.r_Sampler ("s_dn_a", strconcat(sizeof(mask),mask,oA_Name,"_bump") ); + + C.r_Stencil ( TRUE,D3DCMP_ALWAYS,0xff,0x7f,D3DSTENCILOP_KEEP,D3DSTENCILOP_REPLACE,D3DSTENCILOP_KEEP); + C.r_StencilRef (0x01); + + C.r_End (); + break; + case SE_R2_NORMAL_LQ: // deffer + uber_deffer (C, false, "base","impl",false,oT2_Name[0]?oT2_Name:0,true); + + C.r_Sampler ("s_lmap", C.L_textures[1]); + + C.r_Stencil ( TRUE,D3DCMP_ALWAYS,0xff,0x7f,D3DSTENCILOP_KEEP,D3DSTENCILOP_REPLACE,D3DSTENCILOP_KEEP); + C.r_StencilRef (0x01); + + C.r_End (); + break; + case SE_R2_SHADOW: // smap + //if (RImplementation.o.HW_smap) C.r_Pass ("shadow_direct_base","dumb", FALSE,TRUE,TRUE,FALSE); + //else C.r_Pass ("shadow_direct_base","shadow_direct_base",FALSE); + C.r_Pass ("shadow_direct_base","dumb", FALSE,TRUE,TRUE,FALSE); + C.r_Sampler ("s_base",C.L_textures[0]); + C.r_ColorWriteEnable(false, false, false, false); + C.r_End (); + break; + } +} #else ////////////////////////////////////////////////////////////////////////// // R3 diff --git a/src/Layers/xrRender/Blender_Editor_Selection.cpp b/src/Layers/xrRender/Blender_Editor_Selection.cpp index 9eec68a7dca..a2f077af4c9 100644 --- a/src/Layers/xrRender/Blender_Editor_Selection.cpp +++ b/src/Layers/xrRender/Blender_Editor_Selection.cpp @@ -29,7 +29,7 @@ void CBlender_Editor_Selection::Load(IReader& fs, u16 version) void CBlender_Editor_Selection::Compile(CBlender_Compile& C) { IBlender::Compile(C); -#if !defined(USE_DX10) && !defined(USE_DX11) +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) if (C.bEditor) { C.PassBegin(); @@ -51,9 +51,9 @@ void CBlender_Editor_Selection::Compile(CBlender_Compile& C) C.PassEnd(); } else -#endif // USE_DX10 +#endif // USE_DX10 { - C.r_Pass("editor", "simple_color", FALSE, TRUE, FALSE, TRUE, D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA); + C.r_Pass("editor", "simple_color", true, TRUE, FALSE, TRUE, D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA); C.r_End(); } } diff --git a/src/Layers/xrRender/Blender_Editor_Wire.cpp b/src/Layers/xrRender/Blender_Editor_Wire.cpp index 32f4898ba51..6c0e0391e6f 100644 --- a/src/Layers/xrRender/Blender_Editor_Wire.cpp +++ b/src/Layers/xrRender/Blender_Editor_Wire.cpp @@ -29,7 +29,7 @@ void CBlender_Editor_Wire::Load(IReader& fs, u16 version) void CBlender_Editor_Wire::Compile(CBlender_Compile& C) { IBlender::Compile(C); -#if !defined(USE_DX10) && !defined(USE_DX11) +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) if (C.bEditor) { C.PassBegin(); @@ -51,9 +51,9 @@ void CBlender_Editor_Wire::Compile(CBlender_Compile& C) C.PassEnd(); } else -#endif // USE_DX10 +#endif // USE_DX10 { - C.r_Pass("editor", "simple_color", FALSE, TRUE, TRUE); + C.r_Pass("editor", "simple_color", false, TRUE, TRUE); C.r_End(); } } diff --git a/src/Layers/xrRender/Blender_Lm(EbB).cpp b/src/Layers/xrRender/Blender_Lm(EbB).cpp index 612e8221cb1..e0711909132 100644 --- a/src/Layers/xrRender/Blender_Lm(EbB).cpp +++ b/src/Layers/xrRender/Blender_Lm(EbB).cpp @@ -143,7 +143,7 @@ void CBlender_LmEbB::Compile(CBlender_Compile& C) } } } -#elif RENDER == R_R2 +#elif RENDER == R_R2 || RENDER == R_GL ////////////////////////////////////////////////////////////////////////// // R2 ////////////////////////////////////////////////////////////////////////// diff --git a/src/Layers/xrRender/Blender_Model_EbB.cpp b/src/Layers/xrRender/Blender_Model_EbB.cpp index 958a082652b..b104386c5ab 100644 --- a/src/Layers/xrRender/Blender_Model_EbB.cpp +++ b/src/Layers/xrRender/Blender_Model_EbB.cpp @@ -188,6 +188,57 @@ void CBlender_Model_EbB::Compile(CBlender_Compile& C) } } } +#elif RENDER == R_GL +#include "uber_deffer.h" +void CBlender_Model_EbB::Compile(CBlender_Compile& C) +{ + IBlender::Compile(C); + + if (oBlend.value) + { + // forward + LPCSTR vsname = 0; + LPCSTR psname = 0; + switch (C.iElement) + { + case 0: + case 1: + vsname = psname = "model_env_lq"; + C.r_Pass(vsname, psname, TRUE, TRUE, FALSE, TRUE, D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA, TRUE, 0); + C.r_Sampler ("s_base", C.L_textures[0]); + C.r_Sampler ("s_env", oT2_Name,false,D3DTADDRESS_CLAMP); + C.r_End(); + break; + } + } + else + { + // deferred + switch (C.iElement) + { + case SE_R2_NORMAL_HQ: // deffer + uber_deffer(C, true, "model", "base", false, 0, true); + C.r_Stencil(TRUE, D3DCMP_ALWAYS, 0xff, 0x7f, D3DSTENCILOP_KEEP, D3DSTENCILOP_REPLACE, D3DSTENCILOP_KEEP); + C.r_StencilRef(0x01); + C.r_End(); + break; + case SE_R2_NORMAL_LQ: // deffer + uber_deffer(C, false, "model", "base", false, 0, true); + C.r_Stencil(TRUE, D3DCMP_ALWAYS, 0xff, 0x7f, D3DSTENCILOP_KEEP, D3DSTENCILOP_REPLACE, D3DSTENCILOP_KEEP); + C.r_StencilRef(0x01); + C.r_End(); + break; + case SE_R2_SHADOW: // smap + //if (RImplementation.o.HW_smap) C.r_Pass ("shadow_direct_model","dumb", FALSE,TRUE,TRUE,FALSE); + //else C.r_Pass ("shadow_direct_model","shadow_direct_base",FALSE); + C.r_Pass("shadow_direct_model", "dumb", FALSE, TRUE, TRUE, FALSE); + C.r_Sampler ("s_base",C.L_textures[0]); + C.r_ColorWriteEnable(false, false, false, false); + C.r_End(); + break; + } + } +} #else #include "uber_deffer.h" void CBlender_Model_EbB::Compile(CBlender_Compile& C) diff --git a/src/Layers/xrRender/Blender_Particle.cpp b/src/Layers/xrRender/Blender_Particle.cpp index fa21ed8ad84..8cfa9b03fa9 100644 --- a/src/Layers/xrRender/Blender_Particle.cpp +++ b/src/Layers/xrRender/Blender_Particle.cpp @@ -91,7 +91,7 @@ void CBlender_Particle::Compile(CBlender_Compile& C) C.r_Sampler("s_base", C.L_textures[0], false, oClamp.value ? D3DTADDRESS_CLAMP : D3DTADDRESS_WRAP); C.r_End(); } -#elif RENDER == R_R2 +#elif RENDER == R_R2 || RENDER == R_GL void CBlender_Particle::Compile(CBlender_Compile& C) { IBlender::Compile(C); @@ -128,7 +128,7 @@ void CBlender_Particle::Compile(CBlender_Compile& C) C.r_End(); break; case SE_R2_SHADOW: // smap - // HARD or SOFT: shadow-map + // HARD or SOFT: shadow-map switch (oBlend.IDselected) { case 0: @@ -184,18 +184,18 @@ void CBlender_Particle::Compile(CBlender_Compile& C) "particle", "particle", FALSE, TRUE, FALSE, TRUE, D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA, TRUE, 0); break; // BLEND case 2: - C.r_Pass("particle", "particle", FALSE, TRUE, FALSE, TRUE, D3DBLEND_ONE, D3DBLEND_ONE, TRUE, 0); + C.r_Pass("particle", "particle", false, TRUE, FALSE, TRUE, D3DBLEND_ONE, D3DBLEND_ONE, TRUE, 0); break; // ADD case 3: - C.r_Pass("particle", "particle", FALSE, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, TRUE, 0); + C.r_Pass("particle", "particle", false, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, TRUE, 0); break; // MUL case 4: - C.r_Pass("particle", "particle", FALSE, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_SRCCOLOR, TRUE, 0); + C.r_Pass("particle", "particle", false, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_SRCCOLOR, TRUE, 0); break; // MUL_2X case 5: - C.r_Pass("particle", "particle", FALSE, TRUE, FALSE, TRUE, D3DBLEND_SRCALPHA, D3DBLEND_ONE, TRUE, 0); + C.r_Pass("particle", "particle", false, TRUE, FALSE, TRUE, D3DBLEND_SRCALPHA, D3DBLEND_ONE, TRUE, 0); break; // ALPHA-ADD - }; + } { // C.r_Sampler ("s_base", C.L_textures[0],false,oClamp.value?D3DTADDRESS_CLAMP:D3DTADDRESS_WRAP); C.r_dx10Texture("s_base", C.L_textures[0]); @@ -214,38 +214,38 @@ void CBlender_Particle::Compile(CBlender_Compile& C) switch (oBlend.IDselected) { case 0: - C.r_Pass("particle", "particle", FALSE, TRUE, TRUE, FALSE, D3DBLEND_ONE, D3DBLEND_ZERO, TRUE, 200); + C.r_Pass("particle", "particle", false, TRUE, TRUE, FALSE, D3DBLEND_ONE, D3DBLEND_ZERO, TRUE, 200); C.r_ColorWriteEnable(false, false, false, false); break; // SET case 1: - C.r_Pass("particle-clip", "particle_s-blend", FALSE, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, - TRUE, 0); + C.r_Pass("particle-clip", "particle_s-blend", false, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, + TRUE, 0); break; // BLEND case 2: - C.r_Pass("particle-clip", "particle_s-add", FALSE, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, - TRUE, 0); + C.r_Pass("particle-clip", "particle_s-add", false, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, + TRUE, 0); break; // ADD case 3: - C.r_Pass("particle-clip", "particle_s-mul", FALSE, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, - TRUE, 0); + C.r_Pass("particle-clip", "particle_s-mul", false, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, + TRUE, 0); break; // MUL case 4: - C.r_Pass("particle-clip", "particle_s-mul", FALSE, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, - TRUE, 0); + C.r_Pass("particle-clip", "particle_s-mul", false, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, + TRUE, 0); break; // MUL_2X case 5: - C.r_Pass("particle-clip", "particle_s-aadd", FALSE, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, - TRUE, 0); + C.r_Pass("particle-clip", "particle_s-aadd", false, TRUE, FALSE, TRUE, D3DBLEND_DESTCOLOR, + D3DBLEND_ZERO, TRUE, 0); break; // ALPHA-ADD - }; + } { - // C.r_Sampler ("s_base", C.L_textures[0],false,oClamp.value?D3DTADDRESS_CLAMP:D3DTADDRESS_WRAP); + //C.r_Sampler ("s_base", C.L_textures[0],false,oClamp.value?D3DTADDRESS_CLAMP:D3DTADDRESS_WRAP); C.r_dx10Texture("s_base", C.L_textures[0]); u32 hSampler = C.r_dx10Sampler("smp_base"); if (oClamp.value && (hSampler != (u32)-1)) C.i_dx10Address(hSampler, D3DTADDRESS_CLAMP); // Igor: soft particles - // C.r_Sampler ("s_position", "$user$position"); + //C.r_Sampler ("s_position", "$user$position"); C.r_dx10Texture("s_position", "$user$position"); C.r_dx10Sampler("smp_nofilter"); } @@ -253,6 +253,6 @@ void CBlender_Particle::Compile(CBlender_Compile& C) break; case 4: // deffer-EMAP break; - }; + } } #endif diff --git a/src/Layers/xrRender/Blender_Recorder_R2.cpp b/src/Layers/xrRender/Blender_Recorder_R2.cpp index 0d2677ae824..20883d04e44 100644 --- a/src/Layers/xrRender/Blender_Recorder_R2.cpp +++ b/src/Layers/xrRender/Blender_Recorder_R2.cpp @@ -27,7 +27,7 @@ void CBlender_Compile::r_Pass(LPCSTR _vs, LPCSTR _ps, bool bFog, BOOL bZtest, BO SVS* vs = RImplementation.Resources->_CreateVS(_vs); dest.ps = ps; dest.vs = vs; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) SGS* gs = RImplementation.Resources->_CreateGS("null"); dest.gs = gs; #ifdef USE_DX11 diff --git a/src/Layers/xrRender/Blender_Screen_SET.cpp b/src/Layers/xrRender/Blender_Screen_SET.cpp index a47cce7218d..e4f2c752d23 100644 --- a/src/Layers/xrRender/Blender_Screen_SET.cpp +++ b/src/Layers/xrRender/Blender_Screen_SET.cpp @@ -208,7 +208,95 @@ void CBlender_Screen_SET::Compile(CBlender_Compile& C) C.r_End(); } -#else // USE_DX10 +#elif defined(USE_OGL) +void CBlender_Screen_SET::Compile(CBlender_Compile& C) +{ + IBlender::Compile(C); + //C.r_Pass ("stub_notransform_t", "Blender_Screen_SET", false); + + if (oBlend.IDselected == 6) + { + // Usually for wallmarks + C.r_Pass("stub_notransform_t", "stub_default_ma", false); + + VERIFY(C.L_textures.size()>0); + C.r_Sampler("s_base", C.L_textures[0], false, D3DTADDRESS_CLAMP); + } + else + { + if (9 == oBlend.IDselected) + { + // 4x R + C.r_Pass("stub_notransform_t_m4", "stub_default", false); + //C.StageSET_Color (D3DTA_TEXTURE, D3DTOP_MODULATE4X, D3DTA_DIFFUSE); + //C.StageSET_Alpha (D3DTA_TEXTURE, D3DTOP_SELECTARG1, D3DTA_DIFFUSE); + } + else + { + if ((7 == oBlend.IDselected) || (8 == oBlend.IDselected)) + { + // 2x R + C.r_Pass("stub_notransform_t_m2", "stub_default", false); + //C.StageSET_Color (D3DTA_TEXTURE, D3DTOP_MODULATE2X, D3DTA_DIFFUSE); + //C.StageSET_Alpha (D3DTA_TEXTURE, D3DTOP_SELECTARG1, D3DTA_DIFFUSE); + } + else + { + // 1x R + C.r_Pass("stub_notransform_t", "stub_default", false); + //C.StageSET_Color (D3DTA_TEXTURE, D3DTOP_MODULATE, D3DTA_DIFFUSE); + //C.StageSET_Alpha (D3DTA_TEXTURE, D3DTOP_MODULATE, D3DTA_DIFFUSE); + } + } + //C.Stage_Texture (oT_Name); + //C.Stage_Matrix (oT_xform, 0); + //C.Stage_Constant ("$null"); + //C.StageEnd (); + VERIFY(C.L_textures.size()>0); + C.r_Sampler("s_base", C.L_textures[0], false, D3DTADDRESS_CLAMP); + } + + C.PassSET_ZB(oZTest.value, oZWrite.value); + + switch (oBlend.IDselected) + { + case 0: // SET + C.PassSET_Blend(FALSE, D3DBLEND_ONE, D3DBLEND_ZERO, FALSE, 0); + break; + case 1: // BLEND + C.PassSET_Blend(TRUE, D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA, TRUE, oAREF.value); + break; + case 2: // ADD + C.PassSET_Blend(TRUE, D3DBLEND_ONE, D3DBLEND_ONE, FALSE, oAREF.value); + break; + case 3: // MUL + C.PassSET_Blend(TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_ZERO, FALSE, oAREF.value); + break; + case 4: // MUL_2X + C.PassSET_Blend(TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_SRCCOLOR, FALSE, oAREF.value); + break; + case 5: // ALPHA-ADD + C.PassSET_Blend(TRUE, D3DBLEND_SRCALPHA, D3DBLEND_ONE, TRUE, oAREF.value); + break; + case 6: // MUL_2X + A-test + C.PassSET_Blend(TRUE, D3DBLEND_DESTCOLOR, D3DBLEND_SRCCOLOR, FALSE, oAREF.value); + break; + case 7: // SET (2r) + C.PassSET_Blend(TRUE, D3DBLEND_ONE, D3DBLEND_ZERO, TRUE, 0); + break; + case 8: // BLEND (2r) + C.PassSET_Blend(TRUE, D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA, TRUE, oAREF.value); + break; + case 9: // BLEND (2r) + C.PassSET_Blend(TRUE, D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA, TRUE, oAREF.value); + break; + } + C.PassSET_LightFog(oLighting.value, oFog.value); + + C.r_End(); +} + +#else // USE_DX10 void CBlender_Screen_SET::Compile(CBlender_Compile& C) { diff --git a/src/Layers/xrRender/Blender_tree.cpp b/src/Layers/xrRender/Blender_tree.cpp index f0905f5458e..4b15d4dd7be 100644 --- a/src/Layers/xrRender/Blender_tree.cpp +++ b/src/Layers/xrRender/Blender_tree.cpp @@ -194,6 +194,87 @@ void CBlender_Tree::Compile(CBlender_Compile& C) break; } } +#elif RENDER==R_GL +////////////////////////////////////////////////////////////////////////// +// GL +////////////////////////////////////////////////////////////////////////// +#include "uber_deffer.h" +void CBlender_Tree::Compile (CBlender_Compile& C) +{ + IBlender::Compile (C); + + //*************** codepath is the same, only shaders differ + LPCSTR tvs; + LPCSTR tvs_s; + if (oNotAnTree.value) + { + tvs="tree_s"; + if (oBlend.value) tvs_s="shadow_direct_tree_s_aref"; + else tvs_s="shadow_direct_tree_s"; + } + else + { + tvs = "tree"; + if (oBlend.value) tvs_s="shadow_direct_tree_aref"; + else tvs_s="shadow_direct_tree"; + } + + bool bUseATOC = (oBlend.value && (RImplementation.o.dx10_msaa_alphatest==CRender::MSAA_ATEST_DX10_0_ATOC)); + + switch (C.iElement) + { + case SE_R2_NORMAL_HQ: // deffer + if (bUseATOC) + { + uber_deffer (C,true,tvs,"base_atoc",oBlend.value,0,true); + C.r_Stencil ( TRUE,D3DCMP_ALWAYS,0xff,0x7f,D3DSTENCILOP_KEEP,D3DSTENCILOP_REPLACE,D3DSTENCILOP_KEEP); + C.r_ColorWriteEnable(false, false, false, false); + C.r_StencilRef (0x01); + // Alpha to coverage. + C.RS.SetRS (XRDX10RS_ALPHATOCOVERAGE, TRUE); + C.r_End (); + } + + uber_deffer (C,true,tvs,"base",oBlend.value,0,true); + C.r_Stencil ( TRUE,D3DCMP_ALWAYS,0xff,0x7f,D3DSTENCILOP_KEEP,D3DSTENCILOP_REPLACE,D3DSTENCILOP_KEEP); + C.r_StencilRef (0x01); + //C.PassSET_ZB (true,false); + // Need only for ATOC to emulate stencil test + if (bUseATOC) + C.RS.SetRS ( D3DRS_ZFUNC, D3DCMP_EQUAL); + C.r_End (); + + break; + case SE_R2_NORMAL_LQ: // deffer + if (bUseATOC) + { + uber_deffer (C,false,tvs,"base_atoc",oBlend.value,0,true); + C.r_Stencil ( TRUE,D3DCMP_ALWAYS,0xff,0x7f,D3DSTENCILOP_KEEP,D3DSTENCILOP_REPLACE,D3DSTENCILOP_KEEP); + C.r_StencilRef (0x01); + C.r_ColorWriteEnable(false, false, false, false); + // Alpha to coverage. + C.RS.SetRS (XRDX10RS_ALPHATOCOVERAGE, TRUE); + C.r_End (); + } + + uber_deffer (C,false,tvs,"base",oBlend.value,0,true); + C.r_Stencil ( TRUE,D3DCMP_ALWAYS,0xff,0x7f,D3DSTENCILOP_KEEP,D3DSTENCILOP_REPLACE,D3DSTENCILOP_KEEP); + C.r_StencilRef (0x01); + // Need only for ATOC to emulate stencil test + if (bUseATOC) + C.RS.SetRS ( D3DRS_ZFUNC, D3DCMP_EQUAL); + C.r_End (); + break; + case SE_R2_SHADOW: // smap-spot + // TODO: DX10: Use dumb shader for shadowmap since shadows are drawn using hardware PCF + if (oBlend.value) C.r_Pass (tvs_s,"shadow_direct_base_aref", FALSE,TRUE,TRUE,TRUE,D3DBLEND_ZERO,D3DBLEND_ONE,TRUE,200); + else C.r_Pass (tvs_s,"shadow_direct_base", FALSE); + C.r_Sampler ("s_base", C.L_textures[0]); + C.r_ColorWriteEnable (false, false, false, false); + C.r_End (); + break; + } +} #else ////////////////////////////////////////////////////////////////////////// // R3 diff --git a/src/Layers/xrRender/ColorMapManager.cpp b/src/Layers/xrRender/ColorMapManager.cpp index d5dba6ee8c9..75d5720d49d 100644 --- a/src/Layers/xrRender/ColorMapManager.cpp +++ b/src/Layers/xrRender/ColorMapManager.cpp @@ -25,9 +25,14 @@ void ColorMapManager::UpdateTexture(const shared_str& strTexName, int iTex) auto I = m_TexCache.find(strTexName); if (I != m_TexCache.end()) { +#ifdef USE_OGL + GLuint e0 = I->second->surface_get(); + m_CMap[iTex]->surface_set(GL_TEXTURE_2D, e0); +#else ID3DBaseTexture* e0 = I->second->surface_get(); m_CMap[iTex]->surface_set(e0); _RELEASE(e0); +#endif // USE_OGL } else { @@ -36,13 +41,22 @@ void ColorMapManager::UpdateTexture(const shared_str& strTexName, int iTex) m_TexCache.insert(std::make_pair(strTexName, tmp)); +#ifdef USE_OGL + GLuint e0 = tmp->surface_get(); + m_CMap[iTex]->surface_set(GL_TEXTURE_2D, e0); +#else ID3DBaseTexture* e0 = tmp->surface_get(); m_CMap[iTex]->surface_set(e0); _RELEASE(e0); +#endif // USE_OGL } } else { +#ifdef USE_OGL + m_CMap[iTex]->surface_set(GL_TEXTURE_2D, 0); +#else m_CMap[iTex]->surface_set(nullptr); +#endif // USE_OGL } } diff --git a/src/Layers/xrRender/D3DUtils.cpp b/src/Layers/xrRender/D3DUtils.cpp index 83322321958..ee37dc8cab2 100644 --- a/src/Layers/xrRender/D3DUtils.cpp +++ b/src/Layers/xrRender/D3DUtils.cpp @@ -111,7 +111,7 @@ u32 m_ColorSafeRect = 0xffB040B0; void SPrimitiveBuffer::CreateFromData( D3DPRIMITIVETYPE _pt, u32 _p_cnt, u32 FVF, LPVOID vertices, u32 _v_cnt, u16* indices, u32 _i_cnt) { -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: Implement SPrimitiveBuffer::CreateFromData for DX10 // VERIFY(!"SPrimitiveBuffer::CreateFromData not implemented for dx10"); #else // USE_DX10 @@ -150,6 +150,7 @@ void SPrimitiveBuffer::CreateFromData( } void SPrimitiveBuffer::Destroy() { +#ifndef USE_OGL if (pGeom) { HW.stats_manager.decrement_stats_vb(pGeom->vb); @@ -158,6 +159,7 @@ void SPrimitiveBuffer::Destroy() _RELEASE(pGeom->ib); pGeom.destroy(); } +#endif // !USE_OGL } void CDrawUtilities::UpdateGrid(int number_of_cell, float square_size, int subdiv) diff --git a/src/Layers/xrRender/D3DXRenderBase.h b/src/Layers/xrRender/D3DXRenderBase.h index 5ed81e169f1..f02ad5d48e8 100644 --- a/src/Layers/xrRender/D3DXRenderBase.h +++ b/src/Layers/xrRender/D3DXRenderBase.h @@ -49,7 +49,7 @@ class D3DXRenderBase : public IRender, public pureFrame // Runtime structures xr_vector nrmVS; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) xr_vector nrmGS; #endif // USE_DX10 xr_vector nrmPS; @@ -59,7 +59,7 @@ class D3DXRenderBase : public IRender, public pureFrame xr_vector nrmTexturesTemp; xr_vector matVS; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) xr_vector matGS; #endif // USE_DX10 xr_vector matPS; @@ -218,5 +218,7 @@ class D3DXRenderBase : public IRender, public pureFrame ref_shader m_SelectionShader; private: +#ifndef USE_OGL CGammaControl m_Gamma; +#endif // !USE_OGL }; diff --git a/src/Layers/xrRender/Debug/dxPixEventWrapper.h b/src/Layers/xrRender/Debug/dxPixEventWrapper.h index 3e174f9528c..4264ac8a208 100644 --- a/src/Layers/xrRender/Debug/dxPixEventWrapper.h +++ b/src/Layers/xrRender/Debug/dxPixEventWrapper.h @@ -2,7 +2,7 @@ #define dxPixEventWrapper_included #pragma once -#ifdef DEBUG +#if defined(DEBUG) && !defined(USE_OGL) #define PIX_EVENT(Name) dxPixEventWrapper pixEvent##Name(L#Name) diff --git a/src/Layers/xrRender/DetailManager.cpp b/src/Layers/xrRender/DetailManager.cpp index a39b2b13add..4ddcdf0bca5 100644 --- a/src/Layers/xrRender/DetailManager.cpp +++ b/src/Layers/xrRender/DetailManager.cpp @@ -81,8 +81,8 @@ CDetailManager::CDetailManager() : xrc("detail manager") soft_Geom = nullptr; hw_Geom = nullptr; hw_BatchSize = 0; - hw_VB = nullptr; - hw_IB = nullptr; + hw_VB = 0; + hw_IB = 0; m_time_rot_1 = 0; m_time_rot_2 = 0; m_time_pos = 0; diff --git a/src/Layers/xrRender/DetailManager.h b/src/Layers/xrRender/DetailManager.h index 80813281d0a..6730141fa01 100644 --- a/src/Layers/xrRender/DetailManager.h +++ b/src/Layers/xrRender/DetailManager.h @@ -194,8 +194,13 @@ class ECORE_API CDetailManager // Hardware processor ref_geom hw_Geom; u32 hw_BatchSize; +#ifdef USE_OGL + GLuint hw_VB; + GLuint hw_IB; +#else ID3DVertexBuffer* hw_VB; ID3DIndexBuffer* hw_IB; +#endif // USE_OGL ref_constant hwc_consts; ref_constant hwc_wave; ref_constant hwc_wind; @@ -208,7 +213,7 @@ class ECORE_API CDetailManager void hw_Load_Shaders(); void hw_Unload(); void hw_Render(); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) void hw_Render_dump(const Fvector4& consts, const Fvector4& wave, const Fvector4& wind, u32 var_id, u32 lod_id); #else // USE_DX10 void hw_Render_dump(ref_constant array, u32 var_id, u32 lod_id, u32 c_base); diff --git a/src/Layers/xrRender/DetailManager_VS.cpp b/src/Layers/xrRender/DetailManager_VS.cpp index 04df9a9346e..e4db0482bbb 100644 --- a/src/Layers/xrRender/DetailManager_VS.cpp +++ b/src/Layers/xrRender/DetailManager_VS.cpp @@ -9,6 +9,7 @@ #include "xrEngine/Environment.h" #endif #include "Layers/xrRenderDX10/dx10BufferUtils.h" +#include "Layers/xrRenderGL/glBufferUtils.h" const int quant = 16384; const int c_hdr = 10; @@ -58,7 +59,7 @@ void CDetailManager::hw_Load_Geom() u32 vSize = sizeof(vertHW); Msg("* [DETAILS] %d v(%d), %d p", dwVerts, vSize, dwIndices / 3); -#if !defined(USE_DX10) && !defined(USE_DX11) +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) // Determine POOL & USAGE u32 dwUsage = D3DUSAGE_WRITEONLY; @@ -74,7 +75,7 @@ void CDetailManager::hw_Load_Geom() // Fill VB { vertHW* pV; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) vertHW* pVOriginal; pVOriginal = xr_alloc(dwVerts); pV = pVOriginal; @@ -101,7 +102,10 @@ void CDetailManager::hw_Load_Geom() } } } -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + glBufferUtils::CreateVertexBuffer(&hw_VB, pVOriginal, dwVerts * vSize); + xr_free(pVOriginal); +#elif defined(USE_DX10) || defined(USE_DX11) R_CHK(dx10BufferUtils::CreateVertexBuffer(&hw_VB, pVOriginal, dwVerts * vSize)); HW.stats_manager.increment_stats_vb(hw_VB); xr_free(pVOriginal); @@ -113,7 +117,7 @@ void CDetailManager::hw_Load_Geom() // Fill IB { u16* pI; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) u16* pIOriginal; pIOriginal = xr_alloc(dwIndices); pI = pIOriginal; @@ -131,7 +135,10 @@ void CDetailManager::hw_Load_Geom() offset = u16(offset + u16(D.number_vertices)); } } -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + glBufferUtils::CreateIndexBuffer(&hw_IB, pIOriginal, dwIndices * 2); + xr_free(pIOriginal); +#elif defined(USE_DX10) || defined(USE_DX11) R_CHK(dx10BufferUtils::CreateIndexBuffer(&hw_IB, pIOriginal, dwIndices * 2)); HW.stats_manager.increment_stats_ib(hw_IB); xr_free(pIOriginal); @@ -148,13 +155,18 @@ void CDetailManager::hw_Unload() { // Destroy VS/VB/IB hw_Geom.destroy(); +#ifdef USE_OGL + GLuint buffers[] = { hw_IB, hw_VB }; + glDeleteBuffers(2, buffers); +#else HW.stats_manager.decrement_stats_vb(hw_VB); HW.stats_manager.decrement_stats_ib(hw_IB); _RELEASE(hw_IB); _RELEASE(hw_VB); +#endif // USE_OGL } -#if !defined(USE_DX10) && !defined(USE_DX11) +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) void CDetailManager::hw_Load_Shaders() { // Create shader to access constant storage diff --git a/src/Layers/xrRender/DetailModel.cpp b/src/Layers/xrRender/DetailModel.cpp index 9e8b6550fb7..9592828daf1 100644 --- a/src/Layers/xrRender/DetailModel.cpp +++ b/src/Layers/xrRender/DetailModel.cpp @@ -116,12 +116,12 @@ void CDetail::Load(IReader* S) bv_bb.modify(vertices[i].P); bv_bb.getsphere(bv_sphere.P, bv_sphere.R); -#ifndef _EDITOR +#if !defined(_EDITOR) && !defined(USE_OGL) Optimize(); #endif } -#ifndef _EDITOR +#if !defined(_EDITOR) && !defined(USE_OGL) #include "xrstripify.h" void CDetail::Optimize() diff --git a/src/Layers/xrRender/FBasicVisual.cpp b/src/Layers/xrRender/FBasicVisual.cpp index 8f37f53831a..24182194bec 100644 --- a/src/Layers/xrRender/FBasicVisual.cpp +++ b/src/Layers/xrRender/FBasicVisual.cpp @@ -18,8 +18,13 @@ IRender_Mesh::~IRender_Mesh() { +#ifdef USE_OGL + GLuint buffers[] = { p_rm_Vertices, p_rm_Indices }; + glDeleteBuffers(2, buffers); +#else _RELEASE(p_rm_Vertices); _RELEASE(p_rm_Indices); +#endif // USE_OGL } dxRender_Visual::dxRender_Visual() diff --git a/src/Layers/xrRender/FBasicVisual.h b/src/Layers/xrRender/FBasicVisual.h index a3df97ae4fe..882ee5fbd28 100644 --- a/src/Layers/xrRender/FBasicVisual.h +++ b/src/Layers/xrRender/FBasicVisual.h @@ -19,20 +19,28 @@ struct IRender_Mesh ref_geom rm_geom; // verts +#ifdef USE_OGL + GLuint p_rm_Vertices; +#else ID3DVertexBuffer* p_rm_Vertices; +#endif // USE_OGL u32 vBase; u32 vCount; // indices +#ifdef USE_OGL + GLuint p_rm_Indices; +#else ID3DIndexBuffer* p_rm_Indices; +#endif // USE_OGL u32 iBase; u32 iCount; u32 dwPrimitives; IRender_Mesh() { - p_rm_Vertices = nullptr; - p_rm_Indices = nullptr; + p_rm_Vertices = 0; + p_rm_Indices = 0; } virtual ~IRender_Mesh(); diff --git a/src/Layers/xrRender/FSkinned.cpp b/src/Layers/xrRender/FSkinned.cpp index 42c6828fb95..77e6182f974 100644 --- a/src/Layers/xrRender/FSkinned.cpp +++ b/src/Layers/xrRender/FSkinned.cpp @@ -1,15 +1,11 @@ #include "stdafx.h" #pragma hdrstop -#pragma warning(push) -#pragma warning(disable : 4995) -#include -#pragma warning(pop) - #include "xrCore/FMesh.hpp" #include "FSkinned.h" #include "SkeletonX.h" #include "Layers/xrRenderDX10/dx10BufferUtils.h" +#include "Layers/xrRenderGL/glBufferUtils.h" #include "xrEngine/EnnumerateVertices.h" #include "xrCore/xrDebug_macros.h" @@ -359,7 +355,7 @@ void CSkeletonX_PM::Load(const char* N, IReader* data, u32 dwFlags) void* _verts_ = data->pointer(); inherited1::Load(N, data, dwFlags | VLOAD_NOVERTICES); GEnv.Render->shader_option_skinning(-1); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) _DuplicateIndices(N, data); #endif // USE_DX10 vBase = 0; @@ -371,14 +367,14 @@ void CSkeletonX_ST::Load(const char* N, IReader* data, u32 dwFlags) void* _verts_ = data->pointer(); inherited1::Load(N, data, dwFlags | VLOAD_NOVERTICES); GEnv.Render->shader_option_skinning(-1); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) _DuplicateIndices(N, data); #endif // USE_DX10 vBase = 0; _Load_hw(*this, _verts_); } -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) void CSkeletonX_ext::_Load_hw(Fvisual& V, void* _verts_) { @@ -401,7 +397,11 @@ void CSkeletonX_ext::_Load_hw(Fvisual& V, void* _verts_) Vertices1W.create(crc, V.vCount, (vertBoned1W*)_verts_); } +#ifdef USE_OGL + u32 vStride = glBufferUtils::GetDeclVertexSize(dwDecl_01W); +#else u32 vStride = D3DXGetDeclVertexSize(dwDecl_01W, 0); +#endif // USE_OGL VERIFY(vStride == sizeof(vertHW_1W)); //BYTE* bytes = 0; VERIFY(NULL == V.p_rm_Vertices); @@ -434,8 +434,12 @@ void CSkeletonX_ext::_Load_hw(Fvisual& V, void* _verts_) } // R_CHK // (HW.pDevice->CreateVertexBuffer(V.vCount*vStride,dwUsage,0,D3DPOOL_MANAGED,&V.p_rm_Vertices,0)); +#ifdef USE_OGL + glBufferUtils::CreateVertexBuffer(&V.p_rm_Vertices, dstOriginal, V.vCount * vStride); +#else R_CHK(dx10BufferUtils::CreateVertexBuffer(&V.p_rm_Vertices, dstOriginal, V.vCount * vStride)); HW.stats_manager.increment_stats_vb(V.p_rm_Vertices); +#endif xr_free(dstOriginal); V.rm_geom.create(dwDecl_01W, V.p_rm_Vertices, V.p_rm_Indices); @@ -449,7 +453,11 @@ void CSkeletonX_ext::_Load_hw(Fvisual& V, void* _verts_) Vertices2W.create(crc, V.vCount, (vertBoned2W*)_verts_); } +#ifdef USE_OGL + u32 vStride = glBufferUtils::GetDeclVertexSize(dwDecl_2W); +#else u32 vStride = D3DXGetDeclVertexSize(dwDecl_2W, 0); +#endif VERIFY(vStride == sizeof(vertHW_2W)); // BYTE* bytes = 0; VERIFY(NULL == V.p_rm_Vertices); @@ -480,8 +488,12 @@ void CSkeletonX_ext::_Load_hw(Fvisual& V, void* _verts_) dst++; src++; } +#ifdef USE_OGL + glBufferUtils::CreateVertexBuffer(&V.p_rm_Vertices, dstOriginal, V.vCount * vStride); +#else R_CHK(dx10BufferUtils::CreateVertexBuffer(&V.p_rm_Vertices, dstOriginal, V.vCount * vStride)); HW.stats_manager.increment_stats_vb(V.p_rm_Vertices); +#endif xr_free(dstOriginal); V.rm_geom.create(dwDecl_2W, V.p_rm_Vertices, V.p_rm_Indices); @@ -494,8 +506,11 @@ void CSkeletonX_ext::_Load_hw(Fvisual& V, void* _verts_) u32 crc = crc32(_verts_, size); Vertices3W.create(crc, V.vCount, (vertBoned3W*)_verts_); } - +#ifdef USE_OGL + u32 vStride = glBufferUtils::GetDeclVertexSize(dwDecl_3W); +#else u32 vStride = D3DXGetDeclVertexSize(dwDecl_3W, 0); +#endif // USE_OGL VERIFY(vStride == sizeof(vertHW_3W)); //BYTE* bytes = 0; VERIFY(NULL == V.p_rm_Vertices); @@ -529,8 +544,12 @@ void CSkeletonX_ext::_Load_hw(Fvisual& V, void* _verts_) dst++; src++; } +#ifdef USE_OGL + glBufferUtils::CreateVertexBuffer(&V.p_rm_Vertices, dstOriginal, V.vCount * vStride); +#else R_CHK(dx10BufferUtils::CreateVertexBuffer(&V.p_rm_Vertices, dstOriginal, V.vCount * vStride)); HW.stats_manager.increment_stats_vb(V.p_rm_Vertices); +#endif xr_free(dstOriginal); V.rm_geom.create(dwDecl_3W, V.p_rm_Vertices, V.p_rm_Indices); @@ -544,7 +563,11 @@ void CSkeletonX_ext::_Load_hw(Fvisual& V, void* _verts_) Vertices4W.create(crc, V.vCount, (vertBoned4W*)_verts_); } +#ifdef USE_OGL + u32 vStride = glBufferUtils::GetDeclVertexSize(dwDecl_4W); +#else u32 vStride = D3DXGetDeclVertexSize(dwDecl_4W, 0); +#endif VERIFY(vStride == sizeof(vertHW_4W)); //BYTE* bytes = 0; VERIFY(NULL == V.p_rm_Vertices); @@ -577,8 +600,12 @@ void CSkeletonX_ext::_Load_hw(Fvisual& V, void* _verts_) dst++; src++; } +#ifdef USE_OGL + glBufferUtils::CreateVertexBuffer(&V.p_rm_Vertices, dstOriginal, V.vCount * vStride); +#else R_CHK(dx10BufferUtils::CreateVertexBuffer(&V.p_rm_Vertices, dstOriginal, V.vCount * vStride)); HW.stats_manager.increment_stats_vb(V.p_rm_Vertices); +#endif xr_free(dstOriginal); V.rm_geom.create(dwDecl_4W, V.p_rm_Vertices, V.p_rm_Indices); @@ -738,7 +765,7 @@ void CSkeletonX_ext::_CollectBoneFaces(Fvisual* V, u32 iBase, u32 iCount) { u16* indices = nullptr; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) indices = *m_Indices; #else // USE_DX10 R_CHK(V->p_rm_Indices->Lock(0, V->dwPrimitives * 3, (void**)&indices, D3DLOCK_READONLY)); @@ -746,7 +773,7 @@ void CSkeletonX_ext::_CollectBoneFaces(Fvisual* V, u32 iBase, u32 iCount) indices += iBase; -#if !defined(USE_DX10) && !defined(USE_DX11) // Don't use hardware buffers in DX10 since we can't read them +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) // Don't use hardware buffers in DX10 since we can't read them switch (RenderMode) { case RM_SKINNING_SOFT: @@ -820,7 +847,7 @@ void CSkeletonX_ext::_CollectBoneFaces(Fvisual* V, u32 iBase, u32 iCount) R_ASSERT2(0, "not implemented yet"); } -#if !defined(USE_DX10) && !defined(USE_DX11) // Don't use hardware buffers in DX10 since we can't read them +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) // Don't use hardware buffers in DX10 since we can't read them break; case RM_SINGLE: case RM_SKINNING_1B: @@ -1051,12 +1078,12 @@ indices, CBoneData::FacesVec& faces) BOOL CSkeletonX_ext::_PickBone(IKinematics::pick_result& r, float dist, const Fvector& start, const Fvector& dir, Fvisual* V, u16 bone_id, u32 iBase, u32 /*iCount*/) { - VERIFY(Parent && (ChildIDX != u16(-1))); + VERIFY(Parent && ChildIDX != u16(-1)); CBoneData& BD = Parent->LL_GetData(bone_id); CBoneData::FacesVec* faces = &BD.child_faces[ChildIDX]; BOOL result = FALSE; u16* indices = nullptr; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) indices = *m_Indices; #else // USE_DX10 CHK_DX(V->p_rm_Indices->Lock(0, V->dwPrimitives * 3, (void**)&indices, D3DLOCK_READONLY)); @@ -1065,33 +1092,42 @@ BOOL CSkeletonX_ext::_PickBone(IKinematics::pick_result& r, float dist, const Fv { case RM_SKINNING_SOFT: #endif // USE_DX10 - - if (*Vertices1W) - result = _PickBoneSoft1W(r, dist, start, dir, indices + iBase, *faces); - else if (*Vertices2W) - result = _PickBoneSoft2W(r, dist, start, dir, indices + iBase, *faces); - else if (*Vertices3W) - result = _PickBoneSoft3W(r, dist, start, dir, indices + iBase, *faces); - else { - VERIFY(!!(*Vertices4W)); - result = _PickBoneSoft4W(r, dist, start, dir, indices + iBase, *faces); + if (*Vertices1W) + result = _PickBoneSoft1W(r, dist, start, dir, indices + iBase, *faces); + else if (*Vertices2W) + result = _PickBoneSoft2W(r, dist, start, dir, indices + iBase, *faces); + else if (*Vertices3W) + result = _PickBoneSoft3W(r, dist, start, dir, indices + iBase, *faces); + else + { + VERIFY(!!*Vertices4W); + result = _PickBoneSoft4W(r, dist, start, dir, indices + iBase, *faces); + } } - -#if !defined(USE_DX10) && !defined(USE_DX11) - break; +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) + break; case RM_SINGLE: - case RM_SKINNING_1B: result = _PickBoneHW1W(r, dist, start, dir, V, indices + iBase, *faces); break; - case RM_SKINNING_2B: result = _PickBoneHW2W(r, dist, start, dir, V, indices + iBase, *faces); break; - case RM_SKINNING_3B: result = _PickBoneHW3W(r, dist, start, dir, V, indices + iBase, *faces); break; - case RM_SKINNING_4B: result = _PickBoneHW4W(r, dist, start, dir, V, indices + iBase, *faces); break; + case RM_SKINNING_1B: + result = _PickBoneHW1W(r, dist, start, dir, V, indices + iBase, *faces); + break; + case RM_SKINNING_2B: + result = _PickBoneHW2W(r, dist, start, dir, V, indices + iBase, *faces); + break; + case RM_SKINNING_3B: + result = _PickBoneHW3W(r, dist, start, dir, V, indices + iBase, *faces); + break; + case RM_SKINNING_4B: + result = _PickBoneHW4W(r, dist, start, dir, V, indices + iBase, *faces); + break; default: NODEFAULT; } CHK_DX(V->p_rm_Indices->Unlock()); - #endif USE_DX10 - +#endif USE_DX10 + return result; } + BOOL CSkeletonX_ST::PickBone( IKinematics::pick_result& r, float dist, const Fvector& start, const Fvector& dir, u16 bone_id) { @@ -1115,7 +1151,7 @@ void CSkeletonX_PM::EnumBoneVertices(SEnumVerticesCallback& C, u16 bone_id) inherited2::_EnumBoneVertices(C, this, bone_id, iBase + SW.offset, SW.num_tris * 3); } -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) void CSkeletonX_ext::_FillVerticesHW1W(const Fmatrix& view, CSkeletonWallmark& wm, const Fvector& normal, float size, Fvisual* V, u16* indices, CBoneData::FacesVec& faces) @@ -1344,7 +1380,7 @@ void CSkeletonX_ext::_FillVertices(const Fmatrix& view, CSkeletonWallmark& wm, c CBoneData& BD = Parent->LL_GetData(bone_id); CBoneData::FacesVec* faces = &BD.child_faces[ChildIDX]; u16* indices = nullptr; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) indices = *m_Indices; #else // USE_DX10 CHK_DX(V->p_rm_Indices->Lock(0, V->dwPrimitives * 3, (void**)&indices, D3DLOCK_READONLY)); @@ -1361,7 +1397,7 @@ void CSkeletonX_ext::_FillVertices(const Fmatrix& view, CSkeletonWallmark& wm, c VERIFY(!!*Vertices4W); _FillVerticesSoft4W(view, wm, normal, size, indices + iBase, *faces); } -#if !defined(USE_DX10) && !defined(USE_DX11) +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) break; case RM_SINGLE: case RM_SKINNING_1B: _FillVerticesHW1W(view, wm, normal, size, V, indices + iBase, *faces); @@ -1504,47 +1540,57 @@ void TEnumBoneVertices( void CSkeletonX_ext::_EnumBoneVertices(SEnumVerticesCallback& C, Fvisual* V, u16 bone_id, u32 iBase, u32 /*iCount*/) const { - VERIFY(Parent && (ChildIDX != u16(-1))); + VERIFY(Parent && ChildIDX != u16(-1)); CBoneData& BD = Parent->LL_GetData(bone_id); CBoneData::FacesVec* faces = &BD.child_faces[ChildIDX]; u16* indices = nullptr; //R_CHK(V->pIndices->Lock(iBase, iCount, (void**)&indices, D3DLOCK_READONLY)); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) VERIFY(*m_Indices); indices = *m_Indices; #else USE_DX10 - CHK_DX(V->p_rm_Indices->Lock(0, V->dwPrimitives * 3, (void**)&indices, D3DLOCK_READONLY)); - // fill vertices - void* vertices = nullptr; - if (RenderMode != RM_SKINNING_SOFT) - CHK_DX(V->p_rm_Vertices->Lock(V->vBase, V->vCount, (void**)&vertices, D3DLOCK_READONLY)); - switch (RenderMode) - { - case RM_SKINNING_SOFT: -#endif // USE_DX10 - if (*Vertices1W) - TEnumBoneVertices(Vertices1W, indices + iBase, *faces, C); - else if (*Vertices2W) - TEnumBoneVertices(Vertices2W, indices + iBase, *faces, C); - else if (*Vertices3W) - TEnumBoneVertices(Vertices3W, indices + iBase, *faces, C); - else + CHK_DX(V->p_rm_Indices->Lock(0, V->dwPrimitives * 3, (void**)&indices, D3DLOCK_READONLY)); + // fill vertices + void* vertices = nullptr; + if (RenderMode != RM_SKINNING_SOFT) + CHK_DX(V->p_rm_Vertices->Lock(V->vBase, V->vCount, (void**)&vertices, D3DLOCK_READONLY)); + switch (RenderMode) { - VERIFY(!!(*Vertices4W)); - TEnumBoneVertices(Vertices4W, indices + iBase, *faces, C); + case RM_SKINNING_SOFT: +#endif // USE_DX10 + { + if (*Vertices1W) + TEnumBoneVertices(Vertices1W, indices + iBase, *faces, C); + else if (*Vertices2W) + TEnumBoneVertices(Vertices2W, indices + iBase, *faces, C); + else if (*Vertices3W) + TEnumBoneVertices(Vertices3W, indices + iBase, *faces, C); + else + { + VERIFY(!!*Vertices4W); + TEnumBoneVertices(Vertices4W, indices + iBase, *faces, C); + } } -#if !defined(USE_DX10) && !defined(USE_DX11) - break; -case RM_SINGLE: -case RM_SKINNING_1B: TEnumBoneVertices((vertHW_1W*)vertices, indices + iBase, *faces, C); break; -case RM_SKINNING_2B: TEnumBoneVertices((vertHW_2W*)vertices, indices + iBase, *faces, C); break; -case RM_SKINNING_3B: TEnumBoneVertices((vertHW_3W*)vertices, indices + iBase, *faces, C); break; -case RM_SKINNING_4B: TEnumBoneVertices((vertHW_4W*)vertices, indices + iBase, *faces, C); break; -default: NODEFAULT; -} -if (RenderMode != RM_SKINNING_SOFT) - CHK_DX(V->p_rm_Vertices->Unlock()); -CHK_DX(V->p_rm_Indices->Unlock()); +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) + break; + case RM_SINGLE: + case RM_SKINNING_1B: + TEnumBoneVertices((vertHW_1W*)vertices, indices + iBase, *faces, C); + break; + case RM_SKINNING_2B: + TEnumBoneVertices((vertHW_2W*)vertices, indices + iBase, *faces, C); + break; + case RM_SKINNING_3B: + TEnumBoneVertices((vertHW_3W*)vertices, indices + iBase, *faces, C); + break; + case RM_SKINNING_4B: + TEnumBoneVertices((vertHW_4W*)vertices, indices + iBase, *faces, C); + break; + default: NODEFAULT; + } + if (RenderMode != RM_SKINNING_SOFT) + CHK_DX(V->p_rm_Vertices->Unlock()); + CHK_DX(V->p_rm_Indices->Unlock()); #endif // USE_DX10 } diff --git a/src/Layers/xrRender/FTreeVisual.cpp b/src/Layers/xrRender/FTreeVisual.cpp index 91c490abc45..ccba18dc711 100644 --- a/src/Layers/xrRender/FTreeVisual.cpp +++ b/src/Layers/xrRender/FTreeVisual.cpp @@ -37,7 +37,9 @@ void FTreeVisual::Load(const char* N, IReader* data, u32 dwFlags) VERIFY(NULL == p_rm_Vertices); p_rm_Vertices = RImplementation.getVB(ID); +#ifndef USE_OGL p_rm_Vertices->AddRef(); +#endif // !USE_OGL // indices dwPrimitives = 0; @@ -48,7 +50,9 @@ void FTreeVisual::Load(const char* N, IReader* data, u32 dwFlags) VERIFY(NULL == p_rm_Indices); p_rm_Indices = RImplementation.getIB(ID); +#ifndef USE_OGL p_rm_Indices->AddRef(); +#endif // !USE_OGL } // load tree-def @@ -160,15 +164,19 @@ void FTreeVisual::Copy(dxRender_Visual* pSrc) PCOPY(rm_geom); PCOPY(p_rm_Vertices); +#ifndef USE_OGL if (p_rm_Vertices) p_rm_Vertices->AddRef(); +#endif // !USE_OGL PCOPY(vBase); PCOPY(vCount); PCOPY(p_rm_Indices); +#ifndef USE_OGL if (p_rm_Indices) p_rm_Indices->AddRef(); +#endif // !USE_OGL PCOPY(iBase); PCOPY(iCount); diff --git a/src/Layers/xrRender/FVisual.cpp b/src/Layers/xrRender/FVisual.cpp index e8a3acd0158..454b282cdf4 100644 --- a/src/Layers/xrRender/FVisual.cpp +++ b/src/Layers/xrRender/FVisual.cpp @@ -1,14 +1,10 @@ #include "stdafx.h" #pragma hdrstop -#pragma warning(push) -#pragma warning(disable : 4995) -#include -#pragma warning(pop) - #include "xrCore/FMesh.hpp" #include "FVisual.h" #include "Layers/xrRenderDX10/dx10BufferUtils.h" +#include "Layers/xrRenderGL/glBufferUtils.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction @@ -17,8 +13,10 @@ Fvisual::Fvisual() : dxRender_Visual() { m_fast = nullptr; } Fvisual::~Fvisual() { +#ifndef USE_OGL HW.stats_manager.decrement_stats_vb(p_rm_Vertices); HW.stats_manager.decrement_stats_ib(p_rm_Indices); +#endif xr_delete(m_fast); } @@ -27,7 +25,7 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags) { dxRender_Visual::Load(N, data, dwFlags); - D3DVERTEXELEMENT9 dcl[MAX_FVF_DECL_SIZE]; + u32 fvf = 0; D3DVERTEXELEMENT9* vFormat = nullptr; dwPrimitives = 0; BOOL loaded_v = false; @@ -43,7 +41,10 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags) VERIFY(NULL == p_rm_Vertices); p_rm_Vertices = RImplementation.getVB(ID); +#ifndef USE_OGL p_rm_Vertices->AddRef(); +#endif + vFormat = RImplementation.getVB_Format(ID); loaded_v = true; @@ -55,9 +56,11 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags) VERIFY(NULL == p_rm_Indices); p_rm_Indices = RImplementation.getIB(ID); +#ifndef USE_OGL p_rm_Indices->AddRef(); #endif -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#endif +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) // check for fast-vertices if (data->find_chunk(OGF_FASTPATH)) { @@ -75,7 +78,9 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags) VERIFY(NULL == m_fast->p_rm_Vertices); m_fast->p_rm_Vertices = RImplementation.getVB(ID, true); +#ifndef USE_OGL m_fast->p_rm_Vertices->AddRef(); +#endif fmt = RImplementation.getVB_Format(ID, true); // indices @@ -86,12 +91,13 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags) VERIFY(NULL == m_fast->p_rm_Indices); m_fast->p_rm_Indices = RImplementation.getIB(ID, true); +#ifndef USE_OGL m_fast->p_rm_Indices->AddRef(); - +#endif // geom m_fast->rm_geom.create(fmt, m_fast->p_rm_Vertices, m_fast->p_rm_Indices); } -#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) } // read vertices @@ -106,7 +112,9 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags) vCount = data->r_u32(); VERIFY(NULL == p_rm_Vertices); p_rm_Vertices = RImplementation.getVB(ID); +#ifndef USE_OGL p_rm_Vertices->AddRef(); +#endif vFormat = RImplementation.getVB_Format(ID); #endif } @@ -114,13 +122,18 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags) { R_ASSERT(data->find_chunk(OGF_VERTICES)); vBase = 0; - u32 fvf = data->r_u32(); - CHK_DX(D3DXDeclaratorFromFVF(fvf, dcl)); - vFormat = dcl; + fvf = data->r_u32(); vCount = data->r_u32(); +#ifdef USE_OGL + u32 vStride = glBufferUtils::GetFVFVertexSize(fvf); +#else u32 vStride = D3DXGetFVFVertexSize(fvf); +#endif -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + VERIFY(NULL == p_rm_Vertices); + glBufferUtils::CreateVertexBuffer(&p_rm_Vertices, data->pointer(), vCount * vStride); +#elif defined(USE_DX10) || defined(USE_DX11) VERIFY(NULL == p_rm_Vertices); R_CHK(dx10BufferUtils::CreateVertexBuffer(&p_rm_Vertices, data->pointer(), vCount * vStride)); HW.stats_manager.increment_stats_vb(p_rm_Vertices); @@ -152,7 +165,9 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags) dwPrimitives = iCount / 3; VERIFY(NULL == p_rm_Indices); p_rm_Indices = RImplementation.getIB(ID); +#ifndef USE_OGL p_rm_Indices->AddRef(); +#endif #endif } else @@ -162,7 +177,10 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags) iCount = data->r_u32(); dwPrimitives = iCount / 3; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + VERIFY(NULL == p_rm_Indices); + glBufferUtils::CreateIndexBuffer(&p_rm_Indices, data->pointer(), iCount * 2); +#elif defined(USE_DX10) || defined(USE_DX11) //BOOL bSoft = HW.Caps.geometry.bSoftware || (dwFlags&VLOAD_FORCESOFTWARE); // indices are read in model-wallmarks code //u32 dwUsage = /*D3DUSAGE_WRITEONLY |*/ (bSoft?D3DUSAGE_SOFTWAREPROCESSING:0); @@ -196,13 +214,15 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags) if (dwFlags & VLOAD_NOVERTICES) return; + else if (fvf) + rm_geom.create(fvf, p_rm_Vertices, p_rm_Indices); else rm_geom.create(vFormat, p_rm_Vertices, p_rm_Indices); } void Fvisual::Render(float) { -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER==R_GL) if (m_fast && RImplementation.phase == CRender::PHASE_SMAP && !RCache.is_TessEnabled()) { RCache.set_Geometry(m_fast->rm_geom); @@ -215,11 +235,11 @@ void Fvisual::Render(float) RCache.Render(D3DPT_TRIANGLELIST, vBase, 0, vCount, iBase, dwPrimitives); RCache.stat.r.s_static.add(vCount); } -#else // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#else // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) RCache.set_Geometry(rm_geom); RCache.Render(D3DPT_TRIANGLELIST, vBase, 0, vCount, iBase, dwPrimitives); RCache.stat.r.s_static.add(vCount); -#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) } #define PCOPY(a) a = pFrom->a @@ -232,14 +252,18 @@ void Fvisual::Copy(dxRender_Visual* pSrc) PCOPY(rm_geom); PCOPY(p_rm_Vertices); +#ifndef USE_OGL if (p_rm_Vertices) p_rm_Vertices->AddRef(); +#endif // !USE_OGL PCOPY(vBase); PCOPY(vCount); PCOPY(p_rm_Indices); +#ifndef USE_OGL if (p_rm_Indices) p_rm_Indices->AddRef(); +#endif // !USE_OGL PCOPY(iBase); PCOPY(iCount); PCOPY(dwPrimitives); diff --git a/src/Layers/xrRender/HW.h b/src/Layers/xrRender/HW.h index 4ba323330ba..205a467b592 100644 --- a/src/Layers/xrRender/HW.h +++ b/src/Layers/xrRender/HW.h @@ -9,7 +9,7 @@ #include "HWCaps.h" #include "xrCore/ModuleLookup.hpp" -#ifndef _MAYA_EXPORT +#if !defined(_MAYA_EXPORT) && !defined(USE_OGL) #include "stats_manager.h" #endif @@ -24,25 +24,30 @@ class CHW CHW(); ~CHW(); +#ifndef USE_OGL void CreateD3D(); void DestroyD3D(); +#endif // !USE_OGL + void CreateDevice(HWND hw, bool move_window); void DestroyDevice(); void Reset(HWND hw); +#ifndef USE_OGL void selectResolution(u32& dwWidth, u32& dwHeight, BOOL bWindowed); D3DFORMAT selectDepthStencil(D3DFORMAT); u32 selectPresentInterval(); u32 selectGPU(); u32 selectRefresh(u32 dwWidth, u32 dwHeight, D3DFORMAT fmt); - void updateWindowProps(HWND hw); BOOL support(D3DFORMAT fmt, DWORD type, DWORD usage); +#endif // !USE_OGL + void updateWindowProps(HWND hw); #ifdef DEBUG -#if defined(USE_DX10) || defined(USE_DX11) - void Validate(void){}; +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) + void Validate(void) {}; #else // USE_DX10 void Validate(void) { @@ -55,7 +60,22 @@ class CHW #endif // Variables section -#if defined(USE_DX11) // USE_DX10 +#if defined(USE_OGL) + CHW* pDevice; + CHW* pContext; + CHW* m_pSwapChain; + GLuint pBaseRT; + GLuint pBaseZB; + GLuint pPP; + GLuint pFB; + GLuint pCFB; + + CHWCaps Caps; + + HWND m_hWnd; + HDC m_hDC; + HGLRC m_hRC; +#elif defined(USE_DX11) public: IDXGIAdapter* m_pAdapter; // pD3D equivalent ID3D11Device* pDevice; // combine with DX9 pDevice via typedef @@ -105,17 +125,26 @@ class CHW D3DPRESENT_PARAMETERS DevPP; #endif // USE_DX10 -#ifndef _MAYA_EXPORT +#if !defined(_MAYA_EXPORT) && !defined(USE_OGL) stats_manager stats_manager; #endif -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) void UpdateViews(); +#endif +#if defined(USE_DX10) || defined(USE_DX11) DXGI_RATIONAL selectRefresh(u32 dwWidth, u32 dwHeight, DXGI_FORMAT fmt); virtual void OnAppActivate(); virtual void OnAppDeactivate(); #endif // USE_DX10 +#ifdef USE_OGL + // TODO: OGL: Implement this into a compatibility layer? + void ClearRenderTargetView(GLuint pRenderTargetView, const FLOAT ColorRGBA[4]); + void ClearDepthStencilView(GLuint pDepthStencilView, UINT ClearFlags, FLOAT Depth, UINT8 Stencil); + HRESULT Present(UINT SyncInterval, UINT Flags); +#endif // USE_OGL + int maxRefreshRate; //ECO_RENDER add private: diff --git a/src/Layers/xrRender/HWCaps.cpp b/src/Layers/xrRender/HWCaps.cpp index c1c3b0eea56..ee6ea6571f2 100644 --- a/src/Layers/xrRender/HWCaps.cpp +++ b/src/Layers/xrRender/HWCaps.cpp @@ -4,14 +4,14 @@ #include "hwcaps.h" #include "hw.h" -#ifndef _EDITOR +#if !defined(_EDITOR) && !defined(USE_OGL) #include #include #endif namespace { -#ifndef _EDITOR +#if !defined(_EDITOR) && !defined(USE_OGL) u32 GetNVGpuNum() { NvLogicalGpuHandle logicalGPUs[NVAPI_MAX_LOGICAL_GPUS]; @@ -114,7 +114,7 @@ u32 GetGpuNum() { return 1; } #endif } -#if !defined(USE_DX10) && !defined(USE_DX11) +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) void CHWCaps::Update() { D3DCAPS9 caps; diff --git a/src/Layers/xrRender/Light_DB.cpp b/src/Layers/xrRender/Light_DB.cpp index 92354a0ea89..46ade890f26 100644 --- a/src/Layers/xrRender/Light_DB.cpp +++ b/src/Layers/xrRender/Light_DB.cpp @@ -183,7 +183,7 @@ void CLight_DB::add_light(light* L) } #endif -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) void CLight_DB::add_light(light* L) { if (Device.dwFrame == L->frame_render) @@ -195,7 +195,7 @@ void CLight_DB::add_light(light* L) return; L->Export(package); } -#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) void CLight_DB::Update() { diff --git a/src/Layers/xrRender/Light_Package.cpp b/src/Layers/xrRender/Light_Package.cpp index 7a240bdda3d..2c577b29444 100644 --- a/src/Layers/xrRender/Light_Package.cpp +++ b/src/Layers/xrRender/Light_Package.cpp @@ -8,7 +8,7 @@ void light_Package::clear() v_shadowed.clear(); } -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) IC bool pred_light_cmp(light* _1, light* _2) { if (_1->vis.pending) @@ -34,4 +34,4 @@ void light_Package::sort() std::stable_sort(v_spot.begin(), v_spot.end(), pred_light_cmp); std::stable_sort(v_shadowed.begin(), v_shadowed.end(), pred_light_cmp); } -#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) diff --git a/src/Layers/xrRenderPC_R2/Light_Render_Direct.cpp b/src/Layers/xrRender/Light_Render_Direct.cpp similarity index 100% rename from src/Layers/xrRenderPC_R2/Light_Render_Direct.cpp rename to src/Layers/xrRender/Light_Render_Direct.cpp diff --git a/src/Layers/xrRenderPC_R2/Light_Render_Direct.h b/src/Layers/xrRender/Light_Render_Direct.h similarity index 100% rename from src/Layers/xrRenderPC_R2/Light_Render_Direct.h rename to src/Layers/xrRender/Light_Render_Direct.h diff --git a/src/Layers/xrRenderPC_R3/Light_Render_Direct_ComputeXFS.cpp b/src/Layers/xrRender/Light_Render_Direct_ComputeXFS.cpp similarity index 100% rename from src/Layers/xrRenderPC_R3/Light_Render_Direct_ComputeXFS.cpp rename to src/Layers/xrRender/Light_Render_Direct_ComputeXFS.cpp diff --git a/src/Layers/xrRender/ModelPool.cpp b/src/Layers/xrRender/ModelPool.cpp index 05a44f4bd37..408cd75e14a 100644 --- a/src/Layers/xrRender/ModelPool.cpp +++ b/src/Layers/xrRender/ModelPool.cpp @@ -484,7 +484,22 @@ void CModelPool::memory_stats(u32& vb_mem_video, u32& vb_mem_system, u32& ib_mem if (vis_ptr == nullptr) continue; -#if !defined(USE_DX10) && !defined(USE_DX11) +#if defined(USE_OGL) + GLint IB_size; + GLint VB_size; + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vis_ptr->m_fast->p_rm_Indices); + CHK_GL(glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &IB_size)); + + ib_mem_video += IB_size; + ib_mem_system += IB_size; + + glBindBuffer(GL_ARRAY_BUFFER, vis_ptr->m_fast->p_rm_Vertices); + CHK_GL(glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &VB_size)); + + vb_mem_video += VB_size; + vb_mem_system += VB_size; +#elif !defined(USE_DX10) && !defined(USE_DX11) D3DINDEXBUFFER_DESC IB_desc; D3DVERTEXBUFFER_DESC VB_desc; diff --git a/src/Layers/xrRender/QueryHelper.h b/src/Layers/xrRender/QueryHelper.h index 2748245d00f..710d21b2007 100644 --- a/src/Layers/xrRender/QueryHelper.h +++ b/src/Layers/xrRender/QueryHelper.h @@ -3,26 +3,64 @@ #pragma once // Interface -IC HRESULT CreateQuery(ID3DQuery** ppQuery, D3DQUERYTYPE Type); +#ifdef USE_OGL +IC HRESULT CreateQuery(GLuint* pQuery); +IC HRESULT GetData(GLuint query, void* pData, UINT DataSize); +IC HRESULT BeginQuery(GLuint query); +IC HRESULT EndQuery(GLuint query); +IC HRESULT ReleaseQuery(GLuint pQuery); +#else +IC HRESULT CreateQuery(ID3DQuery** ppQuery); IC HRESULT GetData(ID3DQuery* pQuery, void* pData, UINT DataSize); IC HRESULT BeginQuery(ID3DQuery* pQuery); IC HRESULT EndQuery(ID3DQuery* pQuery); +IC HRESULT ReleaseQuery(ID3DQuery *pQuery); +#endif // Implementation -#if defined(USE_DX11) +#if defined(USE_OGL) -IC HRESULT CreateQuery(ID3DQuery** ppQuery, D3DQUERYTYPE Type) +IC HRESULT CreateQuery(GLuint* pQuery) { - D3D_QUERY_DESC desc; - desc.MiscFlags = 0; + glGenQueries(1, pQuery); + return S_OK; +} + +IC HRESULT GetData(GLuint query, void* pData, UINT DataSize) +{ + if (DataSize == sizeof(GLint64)) + CHK_GL(glGetQueryObjecti64v(query, GL_QUERY_RESULT, (GLint64*)pData)); + else + CHK_GL(glGetQueryObjectiv(query, GL_QUERY_RESULT, (GLint*)pData)); + return S_OK; +} - switch (Type) - { - case D3DQUERYTYPE_OCCLUSION: desc.Query = D3D_QUERY_OCCLUSION; break; - default: VERIFY(!"No default."); - } +IC HRESULT BeginQuery(GLuint query) +{ + CHK_GL(glBeginQuery(GL_SAMPLES_PASSED, query)); + return S_OK; +} + +IC HRESULT EndQuery(GLuint query) +{ + CHK_GL(glEndQuery(GL_SAMPLES_PASSED)); + return S_OK; +} + +IC HRESULT ReleaseQuery(GLuint query) +{ + CHK_GL(glDeleteQueries(1, &query)); + return S_OK; +} +#elif defined(USE_DX11) + +IC HRESULT CreateQuery(ID3DQuery** ppQuery) +{ + D3D_QUERY_DESC desc; + desc.MiscFlags = 0; + desc.Query = D3D_QUERY_OCCLUSION; return HW.pDevice->CreateQuery(&desc, ppQuery); } @@ -44,19 +82,19 @@ IC HRESULT EndQuery(ID3DQuery* pQuery) return S_OK; } +IC HRESULT ReleaseQuery(ID3DQuery* pQuery) +{ + _RELEASE(pQuery); + return S_OK; +} + #elif defined(USE_DX10) -IC HRESULT CreateQuery(ID3DQuery** ppQuery, D3DQUERYTYPE Type) +IC HRESULT CreateQuery(ID3DQuery** ppQuery) { D3D_QUERY_DESC desc; desc.MiscFlags = 0; - - switch (Type) - { - case D3DQUERYTYPE_OCCLUSION: desc.Query = D3D_QUERY_OCCLUSION; break; - default: VERIFY(!"No default."); - } - + desc.Query = D3D_QUERY_OCCLUSION; return HW.pDevice->CreateQuery(&desc, ppQuery); } @@ -78,9 +116,15 @@ IC HRESULT EndQuery(ID3DQuery* pQuery) return S_OK; } +IC HRESULT ReleaseQuery(ID3DQuery* pQuery) +{ + _RELEASE(pQuery); + return S_OK; +} + #else // USE_DX10 -IC HRESULT CreateQuery(ID3DQuery** ppQuery, D3DQUERYTYPE Type) { return HW.pDevice->CreateQuery(Type, ppQuery); } +IC HRESULT CreateQuery(ID3DQuery** ppQuery) { return HW.pDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, ppQuery); } IC HRESULT GetData(ID3DQuery* pQuery, void* pData, UINT DataSize) { return pQuery->GetData(pData, DataSize, D3DGETDATA_FLUSH); @@ -89,6 +133,12 @@ IC HRESULT GetData(ID3DQuery* pQuery, void* pData, UINT DataSize) IC HRESULT BeginQuery(ID3DQuery* pQuery) { return pQuery->Issue(D3DISSUE_BEGIN); } IC HRESULT EndQuery(ID3DQuery* pQuery) { return pQuery->Issue(D3DISSUE_END); } +IC HRESULT ReleaseQuery(ID3DQuery* pQuery) +{ + _RELEASE(pQuery); + return S_OK; +} + #endif // USE_DX10 -#endif // QueryHelper_included +#endif // QueryHelper_included diff --git a/src/Layers/xrRender/R_Backend.cpp b/src/Layers/xrRender/R_Backend.cpp index bc3ee459dee..49b719198c7 100644 --- a/src/Layers/xrRender/R_Backend.cpp +++ b/src/Layers/xrRender/R_Backend.cpp @@ -6,7 +6,43 @@ CBackend RCache; // Create Quad-IB -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + +// Igor: is used to test bug with rain, particles corruption +void CBackend::RestoreQuadIBData() +{ + // Not implemented +} + +void CBackend::CreateQuadIB() +{ + const u32 dwTriCount = 4 * 1024; + const u32 dwIdxCount = dwTriCount * 2 * 3; + u16 IndexBuffer[dwIdxCount]; + u16* Indices = IndexBuffer; + GLenum dwUsage = GL_STATIC_DRAW; + + int Cnt = 0; + int ICnt = 0; + for (int i = 0; istate); } -#if defined(USE_DX10) || defined(USE_DX11) + + ICF void set_States(SState* _state); + ICF void set_States(ref_state& _state) { set_States(&*_state); } + +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) ICF void set_Format(SDeclaration* _decl); -#else // USE_DX10 +#else // USE_DX10 ICF void set_Format(IDirect3DVertexDeclaration9* _decl); -#endif // USE_DX10 +#endif // USE_DX10 +#ifdef USE_OGL + ICF void set_PS(GLuint _ps, LPCSTR _n = 0); +#else ICF void set_PS(ID3DPixelShader* _ps, LPCSTR _n = nullptr); +#endif // USE_OGL ICF void set_PS(ref_ps& _ps) { set_PS(_ps->ps, _ps->cName.c_str()); } -#if defined(USE_DX10) || defined(USE_DX11) - ICF void set_GS(ID3DGeometryShader* _gs, LPCSTR _n = 0); + +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) +#ifdef USE_OGL + ICF void set_GS(GLuint _gs, LPCSTR _n = 0); +#else + ICF void set_GS(ID3DGeometryShader* _gs, LPCSTR _n = nullptr); +#endif // USE_OGL ICF void set_GS(ref_gs& _gs) { set_GS(_gs->gs, _gs->cName.c_str()); } -#ifdef USE_DX11 - ICF void set_HS(ID3D11HullShader* _hs, LPCSTR _n = 0); + +# ifdef USE_DX11 + ICF void set_HS(ID3D11HullShader* _hs, LPCSTR _n = nullptr); ICF void set_HS(ref_hs& _hs) { set_HS(_hs->sh, _hs->cName.c_str()); } - ICF void set_DS(ID3D11DomainShader* _ds, LPCSTR _n = 0); + + ICF void set_DS(ID3D11DomainShader* _ds, LPCSTR _n = nullptr); ICF void set_DS(ref_ds& _ds) { set_DS(_ds->sh, _ds->cName.c_str()); } - ICF void set_CS(ID3D11ComputeShader* _cs, LPCSTR _n = 0); + + ICF void set_CS(ID3D11ComputeShader* _cs, LPCSTR _n = nullptr); ICF void set_CS(ref_cs& _cs) { set_CS(_cs->sh, _cs->cName.c_str()); } -#endif +# endif -#endif // USE_DX10 +#endif // USE_DX10 #ifdef USE_DX11 ICF bool is_TessEnabled(); @@ -315,24 +348,33 @@ class ECORE_API CBackend ICF void set_VS(SVS* _vs); protected: // In DX10 we need input shader signature which is stored in ref_vs -#endif // USE_DX10 +#endif // USE_DX10 +#ifdef USE_OGL + ICF void set_VS(GLuint _vs, LPCSTR _n = 0); +#else ICF void set_VS(ID3DVertexShader* _vs, LPCSTR _n = nullptr); +#endif // USE_OGL #if defined(USE_DX10) || defined(USE_DX11) public: -#endif // USE_DX10 - +#endif // USE_DX10 +#ifdef USE_OGL + ICF void set_Vertices(GLuint _vb, u32 _vb_stride); + ICF void set_Indices(GLuint _ib); +#else ICF void set_Vertices(ID3DVertexBuffer* _vb, u32 _vb_stride); ICF void set_Indices(ID3DIndexBuffer* _ib); +#endif // USE_OGL ICF void set_Geometry(SGeometry* _geom); ICF void set_Geometry(ref_geom& _geom) { set_Geometry(&*_geom); } IC void set_Stencil(u32 _enable, u32 _func = D3DCMP_ALWAYS, u32 _ref = 0x00, u32 _mask = 0x00, - u32 _writemask = 0x00, u32 _fail = D3DSTENCILOP_KEEP, u32 _pass = D3DSTENCILOP_KEEP, - u32 _zfail = D3DSTENCILOP_KEEP); + u32 _writemask = 0x00, u32 _fail = D3DSTENCILOP_KEEP, u32 _pass = D3DSTENCILOP_KEEP, + u32 _zfail = D3DSTENCILOP_KEEP); IC void set_Z(u32 _enable); IC void set_ZFunc(u32 _func); IC void set_AlphaRef(u32 _value); - IC void set_ColorWriteEnable(u32 _mask = D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | - D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA); + IC void set_ColorWriteEnable( + u32 _mask = D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | + D3DCOLORWRITEENABLE_ALPHA); IC void set_CullMode(u32 _mode); u32 get_CullMode() { return cull_mode; } void set_ClipPlanes(u32 _enable, Fplane* _planes = nullptr, u32 count = 0); @@ -344,15 +386,14 @@ class ECORE_API CBackend { if (ctable) return ctable->get(n); - else - return nullptr; + return nullptr; } + ICF ref_constant get_c(shared_str& n) { if (ctable) return ctable->get(n); - else - return nullptr; + return nullptr; } // constants - direct (fast) @@ -361,16 +402,19 @@ class ECORE_API CBackend if (C) constants.set(C, A); } + ICF void set_c(R_constant* C, const Fvector4& A) { if (C) constants.set(C, A); } + ICF void set_c(R_constant* C, float x, float y, float z, float w) { if (C) constants.set(C, x, y, z, w); } + ICF void set_ca(R_constant* C, u32 e, const Fmatrix& A) { if (C) @@ -386,18 +430,21 @@ class ECORE_API CBackend if (C) constants.seta(C, e, x, y, z, w); } -#if defined(USE_DX10) || defined(USE_DX11) + +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) ICF void set_c(R_constant* C, float A) { if (C) constants.set(C, A); } + ICF void set_c(R_constant* C, int A) { if (C) constants.set(C, A); } -#endif // USE_DX10 +#endif // USE_DX10 + // constants - LPCSTR (slow) ICF void set_c(LPCSTR n, const Fmatrix& A) @@ -405,43 +452,50 @@ class ECORE_API CBackend if (ctable) set_c(&*ctable->get(n), A); } + ICF void set_c(LPCSTR n, const Fvector4& A) { if (ctable) set_c(&*ctable->get(n), A); } + ICF void set_c(LPCSTR n, float x, float y, float z, float w) { if (ctable) set_c(&*ctable->get(n), x, y, z, w); } + ICF void set_ca(LPCSTR n, u32 e, const Fmatrix& A) { if (ctable) set_ca(&*ctable->get(n), e, A); } + ICF void set_ca(LPCSTR n, u32 e, const Fvector4& A) { if (ctable) set_ca(&*ctable->get(n), e, A); } + ICF void set_ca(LPCSTR n, u32 e, float x, float y, float z, float w) { if (ctable) set_ca(&*ctable->get(n), e, x, y, z, w); } -#if defined(USE_DX10) || defined(USE_DX11) + +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) ICF void set_c(LPCSTR n, float A) { if (ctable) set_c(&*ctable->get(n), A); } + ICF void set_c(LPCSTR n, int A) { if (ctable) set_c(&*ctable->get(n), A); } -#endif // USE_DX10 +#endif // USE_DX10 // constants - shared_str (average) ICF void set_c(shared_str& n, const Fmatrix& A) @@ -449,43 +503,50 @@ class ECORE_API CBackend if (ctable) set_c(&*ctable->get(n), A); } + ICF void set_c(shared_str& n, const Fvector4& A) { if (ctable) set_c(&*ctable->get(n), A); } + ICF void set_c(shared_str& n, float x, float y, float z, float w) { if (ctable) set_c(&*ctable->get(n), x, y, z, w); } + ICF void set_ca(shared_str& n, u32 e, const Fmatrix& A) { if (ctable) set_ca(&*ctable->get(n), e, A); } + ICF void set_ca(shared_str& n, u32 e, const Fvector4& A) { if (ctable) set_ca(&*ctable->get(n), e, A); } + ICF void set_ca(shared_str& n, u32 e, float x, float y, float z, float w) { if (ctable) set_ca(&*ctable->get(n), e, x, y, z, w); } -#if defined(USE_DX10) || defined(USE_DX11) + +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) ICF void set_c(shared_str& n, float A) { if (ctable) set_c(&*ctable->get(n), A); } + ICF void set_c(shared_str& n, int A) { if (ctable) set_c(&*ctable->get(n), A); } -#endif // USE_DX10 +#endif // USE_DX10 ICF void Render(D3DPRIMITIVETYPE T, u32 baseV, u32 startV, u32 countV, u32 startI, u32 PC); ICF void Render(D3DPRIMITIVETYPE T, u32 startV, u32 PC); @@ -505,18 +566,21 @@ class ECORE_API CBackend // Debug render void dbg_DP(D3DPRIMITIVETYPE pt, ref_geom geom, u32 vBase, u32 pc); void dbg_DIP(D3DPRIMITIVETYPE pt, ref_geom geom, u32 baseV, u32 startV, u32 countV, u32 startI, u32 PC); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: Implement this. IC void dbg_SetRS(D3DRENDERSTATETYPE p1, u32 p2) { VERIFY(!"Not implemented"); } IC void dbg_SetSS(u32 sampler, D3DSAMPLERSTATETYPE type, u32 value) { VERIFY(!"Not implemented"); } -#else // USE_DX10 - void dbg_SetRS(D3DRENDERSTATETYPE p1, u32 p2) { CHK_DX(HW.pDevice->SetRenderState(p1, p2)); } +#else // USE_DX10 + void dbg_SetRS(D3DRENDERSTATETYPE p1, u32 p2) + { + CHK_DX(HW.pDevice->SetRenderState(p1, p2)); + } void dbg_SetSS(u32 sampler, D3DSAMPLERSTATETYPE type, u32 value) { CHK_DX(HW.pDevice->SetSamplerState(sampler, type, value)); } -#endif // USE_DX10 +#endif // USE_DX10 #ifdef DEBUG void dbg_Draw(D3DPRIMITIVETYPE T, FVF::L* pVerts, int vcnt, u16* pIdx, int pcnt); void dbg_Draw(D3DPRIMITIVETYPE T, FVF::L* pVerts, int pcnt); @@ -529,6 +593,7 @@ class ECORE_API CBackend TM.translate(T); dbg_DrawOBB(TM, half_dim, C); } + void dbg_DrawOBB(Fmatrix& T, Fvector& half_dim, u32 C); void dbg_DrawTRI(Fmatrix& T, Fvector* p, u32 C) { dbg_DrawTRI(T, p[0], p[1], p[2], C); } void dbg_DrawTRI(Fmatrix& T, Fvector& p1, Fvector& p2, Fvector& p3, u32 C); @@ -537,6 +602,7 @@ class ECORE_API CBackend #endif CBackend() { Invalidate(); }; + #if defined(USE_DX10) || defined(USE_DX11) private: // DirectX 10 internal functionality @@ -551,7 +617,7 @@ class ECORE_API CBackend ID3DBlob* m_pInputSignature; bool m_bChangedRTorZB; -#endif // USE_DX10 +#endif // USE_DX10 }; #pragma warning(pop) diff --git a/src/Layers/xrRender/R_Backend_DBG.cpp b/src/Layers/xrRender/R_Backend_DBG.cpp index 46caf6ffe59..06a17c88368 100644 --- a/src/Layers/xrRender/R_Backend_DBG.cpp +++ b/src/Layers/xrRender/R_Backend_DBG.cpp @@ -17,7 +17,7 @@ void CBackend::dbg_DIP(D3DPRIMITIVETYPE pt, ref_geom geom, u32 baseV, u32 startV void CBackend::dbg_Draw(D3DPRIMITIVETYPE T, FVF::L* pVerts, int vcnt, u16* pIdx, int pcnt) { -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: implement // VERIFY(!"CBackend::dbg_Draw not implemented."); #else // USE_DX10 @@ -28,7 +28,7 @@ void CBackend::dbg_Draw(D3DPRIMITIVETYPE T, FVF::L* pVerts, int vcnt, u16* pIdx, } void CBackend::dbg_Draw(D3DPRIMITIVETYPE T, FVF::L* pVerts, int pcnt) { -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: implement // VERIFY(!"CBackend::dbg_Draw not implemented."); #else // USE_DX10 @@ -116,7 +116,7 @@ void CBackend::dbg_DrawEllipse(Fmatrix& T, u32 C) -0.9239f, 0.0000f, -0.3827f, -0.9239f, 0.1464f, -0.3536f, -0.9239f, 0.2706f, -0.2706f, -0.9239f, 0.3536f, -0.1464f, -0.9239f, 0.3827f, 0.0000f, -0.9239f, 0.3536f, 0.1464f, -0.9239f, 0.2706f, 0.2706f, -0.9239f, 0.1464f, 0.3536f, -0.9239f, 0.0000f, 0.0000f, -1.0000f}; -#if !defined(USE_DX10) && !defined(USE_DX11) +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) u16 gFaces[224 * 3] = {0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0, 6, 7, 0, 7, 8, 0, 8, 9, 0, 9, 10, 0, 10, 11, 0, 11, 12, 0, 12, 13, 0, 13, 14, 0, 14, 15, 0, 15, 16, 0, 16, 1, 1, 17, 18, 1, 18, 2, 2, 18, 19, 2, 19, 3, 3, 19, 20, 3, 20, 4, 4, 20, 21, 4, 21, 5, 5, 21, 22, 5, 22, 6, 6, 22, 23, 6, 23, 7, 7, 23, 24, 7, 24, 8, 8, 24, 25, @@ -154,7 +154,7 @@ void CBackend::dbg_DrawEllipse(Fmatrix& T, u32 C) set_xform_world(T); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: implement // VERIFY(!"CBackend::dbg_Draw not implemented."); // dbg_Draw(D3DPT_TRIANGLELIST,verts,vcnt,gFaces,224); diff --git a/src/Layers/xrRender/R_Backend_Runtime.cpp b/src/Layers/xrRender/R_Backend_Runtime.cpp index eeabe628784..8c34ad923b0 100644 --- a/src/Layers/xrRender/R_Backend_Runtime.cpp +++ b/src/Layers/xrRender/R_Backend_Runtime.cpp @@ -17,7 +17,9 @@ void CBackend::OnFrameEnd() { if (!GEnv.isDedicatedServer) { -#if defined(USE_DX10) || defined(USE_DX11) +#ifdef USE_OGL + Invalidate(); +#elif defined(USE_DX10) || defined(USE_DX11) HW.pContext->ClearState(); Invalidate(); #else // USE_DX10 @@ -54,20 +56,20 @@ void CBackend::OnFrameBegin() void CBackend::Invalidate() { - pRT[0] = nullptr; - pRT[1] = nullptr; - pRT[2] = nullptr; - pRT[3] = nullptr; - pZB = nullptr; + pRT[0] = 0; + pRT[1] = 0; + pRT[2] = 0; + pRT[3] = 0; + pZB = 0; decl = nullptr; - vb = nullptr; - ib = nullptr; + vb = 0; + ib = 0; vb_stride = 0; state = nullptr; - ps = nullptr; - vs = nullptr; + ps = 0; + vs = 0; DX10_ONLY(gs = NULL); #ifdef USE_DX11 hs = 0; @@ -120,21 +122,21 @@ void CBackend::Invalidate() StateManager.UnmapConstants(); SRVSManager.ResetDeviceState(); - for (u32 gs_it = 0; gs_it < mtMaxGeometryShaderTextures;) + for (u32 gs_it = 0; gs_it < CTexture::mtMaxGeometryShaderTextures;) textures_gs[gs_it++] = 0; #ifdef USE_DX11 - for (u32 hs_it = 0; hs_it < mtMaxHullShaderTextures;) + for (u32 hs_it = 0; hs_it < CTexture::mtMaxHullShaderTextures;) textures_hs[hs_it++] = 0; - for (u32 ds_it = 0; ds_it < mtMaxDomainShaderTextures;) + for (u32 ds_it = 0; ds_it < CTexture::mtMaxDomainShaderTextures;) textures_ds[ds_it++] = 0; - for (u32 cs_it = 0; cs_it < mtMaxComputeShaderTextures;) + for (u32 cs_it = 0; cs_it < CTexture::mtMaxComputeShaderTextures;) textures_cs[cs_it++] = 0; #endif #endif // USE_DX10 - for (u32 ps_it = 0; ps_it < mtMaxPixelShaderTextures;) + for (u32 ps_it = 0; ps_it < CTexture::mtMaxPixelShaderTextures;) textures_ps[ps_it++] = nullptr; - for (u32 vs_it = 0; vs_it < mtMaxVertexShaderTextures;) + for (u32 vs_it = 0; vs_it < CTexture::mtMaxVertexShaderTextures;) textures_vs[vs_it++] = nullptr; #ifdef _EDITOR for (u32 m_it = 0; m_it < 8;) @@ -144,7 +146,8 @@ void CBackend::Invalidate() void CBackend::set_ClipPlanes(u32 _enable, Fplane* _planes /*=NULL */, u32 count /* =0*/) { -#if defined(USE_DX10) || defined(USE_DX11) + +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: Implement in the corresponding vertex shaders // Use this to set up location, were shader setup code will get data // VERIFY(!"CBackend::set_ClipPlanes not implemented!"); @@ -188,7 +191,7 @@ void CBackend::set_ClipPlanes(u32 _enable, Fmatrix* _xform /*=NULL */, u32 fmask return; if (!_enable) { -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: Implement in the corresponding vertex shaders // Use this to set up location, were shader setup code will get data // VERIFY(!"CBackend::set_ClipPlanes not implemented!"); @@ -231,7 +234,7 @@ void CBackend::set_Textures(STextureList* _T) if (load_id < CTexture::rstVertex) { // Set up pixel shader resources - VERIFY(load_id < mtMaxPixelShaderTextures); + VERIFY(load_id < CTexture::mtMaxPixelShaderTextures); // ordinary pixel surface if ((int)load_id > _last_ps) _last_ps = load_id; @@ -255,7 +258,7 @@ void CBackend::set_Textures(STextureList* _T) #endif // UDE_DX10 { // Set up pixel shader resources - VERIFY(load_id < CTexture::rstVertex + mtMaxVertexShaderTextures); + VERIFY(load_id < CTexture::rstVertex + CTexture::mtMaxVertexShaderTextures); // vertex only //d-map or vertex u32 load_id_remapped = load_id - CTexture::rstVertex; @@ -279,7 +282,7 @@ void CBackend::set_Textures(STextureList* _T) else if (load_id < CTexture::rstHull) { // Set up pixel shader resources - VERIFY(load_id < CTexture::rstGeometry + mtMaxGeometryShaderTextures); + VERIFY(load_id < CTexture::rstGeometry + CTexture::mtMaxGeometryShaderTextures); // vertex only //d-map or vertex u32 load_id_remapped = load_id - CTexture::rstGeometry; @@ -303,7 +306,7 @@ void CBackend::set_Textures(STextureList* _T) else if (load_id < CTexture::rstDomain) { // Set up pixel shader resources - VERIFY(load_id < CTexture::rstHull + mtMaxHullShaderTextures); + VERIFY(load_id < CTexture::rstHull + CTexture::mtMaxHullShaderTextures); // vertex only //d-map or vertex u32 load_id_remapped = load_id - CTexture::rstHull; @@ -326,7 +329,7 @@ void CBackend::set_Textures(STextureList* _T) else if (load_id < CTexture::rstCompute) { // Set up pixel shader resources - VERIFY(load_id < CTexture::rstDomain + mtMaxDomainShaderTextures); + VERIFY(load_id < CTexture::rstDomain + CTexture::mtMaxDomainShaderTextures); // vertex only //d-map or vertex u32 load_id_remapped = load_id - CTexture::rstDomain; @@ -349,7 +352,7 @@ void CBackend::set_Textures(STextureList* _T) else if (load_id < CTexture::rstInvalid) { // Set up pixel shader resources - VERIFY(load_id < CTexture::rstCompute + mtMaxComputeShaderTextures); + VERIFY(load_id < CTexture::rstCompute + CTexture::mtMaxComputeShaderTextures); // vertex only //d-map or vertex u32 load_id_remapped = load_id - CTexture::rstCompute; @@ -376,13 +379,17 @@ void CBackend::set_Textures(STextureList* _T) } // clear remaining stages (PS) - for (++_last_ps; _last_ps < mtMaxPixelShaderTextures; _last_ps++) + for (++_last_ps; _last_ps < CTexture::mtMaxPixelShaderTextures; _last_ps++) { if (!textures_ps[_last_ps]) continue; textures_ps[_last_ps] = nullptr; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + CHK_GL(glActiveTexture(GL_TEXTURE0 + _last_ps)); + CHK_GL(glBindTexture(GL_TEXTURE_2D, 0)); + CHK_GL(glBindTexture(GL_TEXTURE_CUBE_MAP, 0)); +#elif defined(USE_DX10) || defined(USE_DX11) // TODO: DX10: Optimise: set all resources at once ID3DShaderResourceView* pRes = 0; // HW.pDevice->PSSetShaderResources(_last_ps, 1, &pRes); @@ -392,13 +399,17 @@ void CBackend::set_Textures(STextureList* _T) #endif // USE_DX10 } // clear remaining stages (VS) - for (++_last_vs; _last_vs < mtMaxVertexShaderTextures; _last_vs++) + for (++_last_vs; _last_vs < CTexture::mtMaxVertexShaderTextures; _last_vs++) { if (!textures_vs[_last_vs]) continue; textures_vs[_last_vs] = nullptr; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + CHK_GL(glActiveTexture(GL_TEXTURE0 + CTexture::rstVertex + _last_vs)); + CHK_GL(glBindTexture(GL_TEXTURE_2D, 0)); + CHK_GL(glBindTexture(GL_TEXTURE_CUBE_MAP, 0)); +#elif defined(USE_DX10) || defined(USE_DX11) // TODO: DX10: Optimise: set all resources at once ID3DShaderResourceView* pRes = 0; // HW.pDevice->VSSetShaderResources(_last_vs, 1, &pRes); @@ -410,7 +421,7 @@ void CBackend::set_Textures(STextureList* _T) #if defined(USE_DX10) || defined(USE_DX11) // clear remaining stages (VS) - for (++_last_gs; _last_gs < mtMaxGeometryShaderTextures; _last_gs++) + for (++_last_gs; _last_gs < CTexture::mtMaxGeometryShaderTextures; _last_gs++) { if (!textures_gs[_last_gs]) continue; @@ -423,7 +434,7 @@ void CBackend::set_Textures(STextureList* _T) SRVSManager.SetGSResource(_last_gs, pRes); } #ifdef USE_DX11 - for (++_last_hs; _last_hs < mtMaxHullShaderTextures; _last_hs++) + for (++_last_hs; _last_hs < CTexture::mtMaxHullShaderTextures; _last_hs++) { if (!textures_hs[_last_hs]) continue; @@ -434,7 +445,7 @@ void CBackend::set_Textures(STextureList* _T) ID3DShaderResourceView* pRes = 0; SRVSManager.SetHSResource(_last_hs, pRes); } - for (++_last_ds; _last_ds < mtMaxDomainShaderTextures; _last_ds++) + for (++_last_ds; _last_ds < CTexture::mtMaxDomainShaderTextures; _last_ds++) { if (!textures_ds[_last_ds]) continue; @@ -445,7 +456,7 @@ void CBackend::set_Textures(STextureList* _T) ID3DShaderResourceView* pRes = 0; SRVSManager.SetDSResource(_last_ds, pRes); } - for (++_last_cs; _last_cs < mtMaxComputeShaderTextures; _last_cs++) + for (++_last_cs; _last_cs < CTexture::mtMaxComputeShaderTextures; _last_cs++) { if (!textures_cs[_last_cs]) continue; diff --git a/src/Layers/xrRender/R_Backend_Runtime.h b/src/Layers/xrRender/R_Backend_Runtime.h index 4068942108f..a0f2dc52978 100644 --- a/src/Layers/xrRender/R_Backend_Runtime.h +++ b/src/Layers/xrRender/R_Backend_Runtime.h @@ -7,7 +7,10 @@ #include "sh_constant.h" #include "sh_rt.h" -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) +#include "Layers/xrRenderGL/glR_Backend_Runtime.h" +#include "Layers/xrRenderGL/glState.h" +#elif defined(USE_DX10) || defined(USE_DX11) #include "Layers/xrRenderDX10/dx10R_Backend_Runtime.h" #include "Layers/xrRenderDX10/StateManager/dx10State.h" #else // USE_DX10 @@ -56,27 +59,43 @@ IC void CBackend::set_xform_project(const Fmatrix& M) { xforms.set_P(M); } IC const Fmatrix& CBackend::get_xform_world() { return xforms.get_W(); } IC const Fmatrix& CBackend::get_xform_view() { return xforms.get_V(); } IC const Fmatrix& CBackend::get_xform_project() { return xforms.get_P(); } +#ifdef USE_OGL +IC GLuint CBackend::get_RT(u32 ID) +#else IC ID3DRenderTargetView* CBackend::get_RT(u32 ID) +#endif // USE_OGL { VERIFY((ID >= 0) && (ID < 4)); return pRT[ID]; } -IC ID3DDepthStencilView* CBackend::get_ZB() { return pZB; } -ICF void CBackend::set_States(ID3DState* _state) +#ifdef USE_OGL +IC GLuint CBackend::get_ZB() +#else +IC ID3DDepthStencilView* CBackend::get_ZB() +#endif // USE_OGL +{ + return pZB; +} +ICF void CBackend::set_States(SState* _state) { // DX10 Manages states using it's own algorithm. Don't mess with it. -#if !defined(USE_DX10) && !defined(USE_DX11) - if (state != _state) +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) + if (state != _state->state) #endif // USE_DX10 { PGO(Msg("PGO:state_block")); #ifdef DEBUG stat.states++; #endif +#ifdef USE_OGL state = _state; + state->state.Apply(); +#else + state = _state->state; state->Apply(); +#endif // USE_OGL } } diff --git a/src/Layers/xrRender/R_DStreams.cpp b/src/Layers/xrRender/R_DStreams.cpp index 46dff05037c..d21d445ff14 100644 --- a/src/Layers/xrRender/R_DStreams.cpp +++ b/src/Layers/xrRender/R_DStreams.cpp @@ -14,7 +14,13 @@ void _VertexStream::Create() RImplementation.Resources->Evict(); mSize = rsDVB_Size * 1024; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined (USE_OGL) + glGenBuffers(1, &pVB); + R_ASSERT(pVB); + + glBindBuffer(GL_ARRAY_BUFFER, pVB); + CHK_GL(glBufferData(GL_ARRAY_BUFFER, mSize, nullptr, GL_DYNAMIC_DRAW)); +#elif defined(USE_DX10) || defined(USE_DX11) D3D_BUFFER_DESC bufferDesc; bufferDesc.ByteWidth = mSize; bufferDesc.Usage = D3D_USAGE_DYNAMIC; @@ -39,8 +45,13 @@ void _VertexStream::Create() void _VertexStream::Destroy() { +#ifdef USE_OGL + if (pVB) + glDeleteBuffers(1, &pVB); +#else HW.stats_manager.decrement_stats_vb(pVB); _RELEASE(pVB); +#endif // USE_OGL _clear(); } @@ -67,6 +78,9 @@ void* _VertexStream::Lock(u32 vl_Count, u32 Stride, u32& vOffset) // Check if there is need to flush and perform lock BYTE* pData = nullptr; +#ifdef USE_OGL + glBindBuffer(GL_ARRAY_BUFFER, pVB); +#endif // USE_OGL if ((vl_Count + vl_mPosition) >= vl_mSize) { // FLUSH-LOCK @@ -74,7 +88,9 @@ void* _VertexStream::Lock(u32 vl_Count, u32 Stride, u32& vOffset) vOffset = 0; mDiscardID++; -#if defined(USE_DX11) +#if defined (USE_OGL) + CHK_GL(pData = (BYTE*)glMapBufferRange(GL_ARRAY_BUFFER, mPosition, bytes_need, LOCKFLAGS_FLUSH)); +#elif defined(USE_DX11) HW.pContext->Map(pVB, 0, D3D_MAP_WRITE_DISCARD, 0, &MappedSubRes); pData = (BYTE*)MappedSubRes.pData; pData += vOffset; @@ -98,7 +114,9 @@ void* _VertexStream::Lock(u32 vl_Count, u32 Stride, u32& vOffset) mPosition = vl_mPosition * Stride; vOffset = vl_mPosition; -#if defined(USE_DX11) +#if defined(USE_OGL) + CHK_GL(pData = (BYTE*)glMapBufferRange(GL_ARRAY_BUFFER, mPosition, bytes_need, LOCKFLAGS_APPEND)); +#elif defined(USE_DX11) HW.pContext->Map(pVB, 0, D3D_MAP_WRITE_NO_OVERWRITE, 0, &MappedSubRes); pData = (BYTE*)MappedSubRes.pData; pData += vOffset * Stride; @@ -132,7 +150,10 @@ void _VertexStream::Unlock(u32 Count, u32 Stride) VERIFY(pVB); -#if defined(USE_DX11) +#if defined(USE_OGL) + glBindBuffer(GL_ARRAY_BUFFER, pVB); + CHK_GL(glUnmapBuffer(GL_ARRAY_BUFFER)); +#elif defined(USE_DX11) HW.pContext->Unmap(pVB, 0); #elif defined(USE_DX10) pVB->Unmap(); @@ -155,7 +176,7 @@ void _VertexStream::reset_end() _VertexStream::_VertexStream() { _clear(); }; void _VertexStream::_clear() { - pVB = nullptr; + pVB = 0; mSize = 0; mPosition = 0; mDiscardID = 0; @@ -172,7 +193,13 @@ void _IndexStream::Create() mSize = rsDIB_Size * 1024; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + glGenBuffers(1, &pIB); + R_ASSERT(pIB); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pIB); + CHK_GL(glBufferData(GL_ELEMENT_ARRAY_BUFFER, mSize, nullptr, GL_DYNAMIC_DRAW)); +#elif defined(USE_DX10) || defined(USE_DX11) D3D_BUFFER_DESC bufferDesc; bufferDesc.ByteWidth = mSize; bufferDesc.Usage = D3D_USAGE_DYNAMIC; @@ -197,8 +224,13 @@ void _IndexStream::Create() void _IndexStream::Destroy() { +#ifdef USE_OGL + if (pIB) + glDeleteBuffers(1, &pIB); +#else HW.stats_manager.decrement_stats_ib(pIB); _RELEASE(pIB); +#endif // USE_OGL _clear(); } @@ -224,7 +256,10 @@ u16* _IndexStream::Lock(u32 Count, u32& vOffset) dwFlags = LOCKFLAGS_FLUSH; // discard it's contens mDiscardID++; } -#if defined(USE_DX11) +#if defined(USE_OGL) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pIB); + CHK_GL(pLockedData = (BYTE*)glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, mPosition * 2, Count * 2, dwFlags)); +#elif defined(USE_DX11) D3D_MAP MapMode = (dwFlags == LOCKFLAGS_APPEND) ? D3D_MAP_WRITE_NO_OVERWRITE : D3D_MAP_WRITE_DISCARD; HW.pContext->Map(pIB, 0, MapMode, 0, &MappedSubRes); pLockedData = (BYTE*)MappedSubRes.pData; @@ -249,7 +284,10 @@ void _IndexStream::Unlock(u32 RealCount) PGO(Msg("PGO:IB_UNLOCK:%d", RealCount)); mPosition += RealCount; VERIFY(pIB); -#if defined(USE_DX11) +#if defined(USE_OGL) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pIB); + CHK_GL(glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER)); +#elif defined(USE_DX11) HW.pContext->Unmap(pIB, 0); #elif defined(USE_DX10) pIB->Unmap(); diff --git a/src/Layers/xrRender/R_DStreams.h b/src/Layers/xrRender/R_DStreams.h index 16fcb424060..fc3d86fef66 100644 --- a/src/Layers/xrRender/R_DStreams.h +++ b/src/Layers/xrRender/R_DStreams.h @@ -2,21 +2,37 @@ #define r_DStreamsH #pragma once +#ifdef USE_OGL +enum +{ + LOCKFLAGS_FLUSH = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT, + LOCKFLAGS_APPEND = GL_MAP_WRITE_BIT // TODO: Implement buffer object appending using glBufferSubData +}; +#else enum { LOCKFLAGS_FLUSH = D3DLOCK_DISCARD, LOCKFLAGS_APPEND = D3DLOCK_NOOVERWRITE }; +#endif // USE_OGL class ECORE_API _VertexStream { private: +#ifdef USE_OGL + GLuint pVB; +#else ID3DVertexBuffer* pVB; +#endif // USE_OGL u32 mSize; // size in bytes u32 mPosition; // position in bytes u32 mDiscardID; // ID of discard - usually for caching public: +#ifdef USE_OGL + GLuint old_pVB; +#else ID3DVertexBuffer* old_pVB; +#endif // USE_OGL #ifdef DEBUG u32 dbg_lock; #endif @@ -29,7 +45,11 @@ class ECORE_API _VertexStream void reset_begin(); void reset_end(); +#ifdef USE_OGL + IC GLuint Buffer() { return pVB; } +#else ID3DVertexBuffer* Buffer() { return pVB; } +#endif // USE_OGL u32 DiscardID() { return mDiscardID; } void Flush() { mPosition = mSize; } void* Lock(u32 vl_Count, u32 Stride, u32& vOffset); @@ -42,18 +62,26 @@ class ECORE_API _VertexStream class ECORE_API _IndexStream { private: +#ifdef USE_OGL + GLuint pIB; +#else ID3DIndexBuffer* pIB; +#endif // USE_OGL u32 mSize; // real size (usually mCount, aligned on 512b boundary) u32 mPosition; u32 mDiscardID; public: +#ifdef USE_OGL + GLuint old_pIB; +#else ID3DIndexBuffer* old_pIB; +#endif // USE_OGL private: void _clear() { - pIB = nullptr; + pIB = 0; mSize = 0; mPosition = 0; mDiscardID = 0; @@ -65,7 +93,11 @@ class ECORE_API _IndexStream void reset_begin(); void reset_end(); +#ifdef USE_OGL + IC GLuint Buffer() { return pIB; } +#else ID3DIndexBuffer* Buffer() { return pIB; } +#endif // USE_OGL u32 DiscardID() { return mDiscardID; } void Flush() { mPosition = mSize; } u16* Lock(u32 Count, u32& vOffset); diff --git a/src/Layers/xrRender/ResourceManager.cpp b/src/Layers/xrRender/ResourceManager.cpp index 028811f1c5e..67597f69556 100644 --- a/src/Layers/xrRender/ResourceManager.cpp +++ b/src/Layers/xrRender/ResourceManager.cpp @@ -474,9 +474,9 @@ void CResourceManager::_DumpMemoryUsage() void CResourceManager::Evict() { // TODO: DX10: check if we really need this method -#if !defined(USE_DX10) && !defined(USE_DX11) +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) CHK_DX(HW.pDevice->EvictManagedResources()); -#endif // USE_DX10 +#endif } /* BOOL CResourceManager::_GetDetailTexture(LPCSTR Name,LPCSTR& T, R_constant_setup* &CS) diff --git a/src/Layers/xrRender/ResourceManager.h b/src/Layers/xrRender/ResourceManager.h index fb0c9859f1d..7e2b9b94290 100644 --- a/src/Layers/xrRender/ResourceManager.h +++ b/src/Layers/xrRender/ResourceManager.h @@ -37,7 +37,7 @@ class ECORE_API CResourceManager using map_RT = xr_map; // DX10 cut DEFINE_MAP_PRED(const char*,CRTC*, map_RTC, map_RTCIt, str_pred); using map_VS = xr_map; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) using map_GS = xr_map; #endif // USE_DX10 #ifdef USE_DX11 @@ -59,7 +59,7 @@ class ECORE_API CResourceManager // DX10 cut map_RTC m_rtargets_c; map_VS m_vs; map_PS m_ps; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) map_GS m_gs; #endif // USE_DX10 map_TD m_td; @@ -149,7 +149,7 @@ class ECORE_API CResourceManager // DX10 cut CRTC* _CreateRTC (LPCSTR Name, u32 size, D3DFORMAT f); // DX10 cut void _DeleteRTC (const CRTC* RT ); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) SGS* _CreateGS(LPCSTR Name); void _DeleteGS(const SGS* GS); #endif // USE_DX10 @@ -178,6 +178,9 @@ class ECORE_API CResourceManager SState* _CreateState(SimulatorStates& Code); void _DeleteState(const SState* SB); +#ifdef USE_OGL + SDeclaration* _CreateDecl (u32 FVF); +#endif // USE_OGL SDeclaration* _CreateDecl(D3DVERTEXELEMENT9* dcl); void _DeleteDecl(const SDeclaration* dcl); @@ -219,8 +222,13 @@ class ECORE_API CResourceManager v_constant_setup.push_back(std::make_pair(shared_str(name), s)); } +#ifdef USE_OGL + SGeometry* CreateGeom(D3DVERTEXELEMENT9* decl, GLuint vb, GLuint ib); + SGeometry* CreateGeom(u32 FVF, GLuint vb, GLuint ib); +#else SGeometry* CreateGeom(D3DVERTEXELEMENT9* decl, ID3DVertexBuffer* vb, ID3DIndexBuffer* ib); SGeometry* CreateGeom(u32 FVF, ID3DVertexBuffer* vb, ID3DIndexBuffer* ib); +#endif // USE_OGL void DeleteGeom(const SGeometry* VS); void DeferredLoad(BOOL E) { bDeferredLoad = E; } void DeferredUpload(); diff --git a/src/Layers/xrRender/ResourceManager_Reset.cpp b/src/Layers/xrRender/ResourceManager_Reset.cpp index 726d0e95fa9..72c5c7f2082 100644 --- a/src/Layers/xrRender/ResourceManager_Reset.cpp +++ b/src/Layers/xrRender/ResourceManager_Reset.cpp @@ -15,7 +15,11 @@ void CResourceManager::reset_begin() // destroy state-blocks for (u32 _it = 0; _it < v_states.size(); _it++) +#ifdef USE_OGL + v_states[_it]->state.Release(); +#else _RELEASE(v_states[_it]->state); +#endif // USE_OGL // destroy RTs for (auto rt_it = m_rtargets.begin(); rt_it != m_rtargets.end(); rt_it++) @@ -25,8 +29,12 @@ void CResourceManager::reset_begin() // destroy DStreams RCache.old_QuadIB = RCache.QuadIB; +#ifdef USE_OGL + glDeleteBuffers(1, &RCache.QuadIB); +#else HW.stats_manager.decrement_stats_ib(RCache.QuadIB); _RELEASE(RCache.QuadIB); +#endif // USE_OGL RCache.Index.reset_begin(); RCache.Vertex.reset_begin(); @@ -89,7 +97,9 @@ void CResourceManager::reset_end() // create state-blocks { for (u32 _it = 0; _it < v_states.size(); _it++) -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + v_states[_it]->state_code.record(v_states[_it]->state); +#elif defined(USE_DX10) || defined(USE_DX11) v_states[_it]->state = ID3DState::Create(v_states[_it]->state_code); #else // USE_DX10 v_states[_it]->state = v_states[_it]->state_code.record(); diff --git a/src/Layers/xrRender/SH_Atomic.cpp b/src/Layers/xrRender/SH_Atomic.cpp index 7dd4ef37406..36b069e623b 100644 --- a/src/Layers/xrRender/SH_Atomic.cpp +++ b/src/Layers/xrRender/SH_Atomic.cpp @@ -28,38 +28,48 @@ /////////////////////////////////////////////////////////////////////// // SVS -SVS::SVS() : vs(nullptr) +SVS::SVS() : vs(0) #if defined(USE_DX10) || defined(USE_DX11) // ,signature(0) -#endif // USE_DX10 -{ - ; -} +#endif // USE_DX10 +{} SVS::~SVS() { RImplementation.Resources->_DeleteVS(this); #if defined(USE_DX10) || defined(USE_DX11) -//_RELEASE(signature); -// Now it is release automatically -#endif // USE_DX10 + //_RELEASE(signature); + // Now it is release automatically +#endif //USE_DX10 +#ifdef USE_OGL + CHK_GL(glDeleteProgram(vs)); +#else _RELEASE(vs); +#endif // USE_OGL } /////////////////////////////////////////////////////////////////////// -// SPS +// SPS SPS::~SPS() { +#ifdef USE_OGL + CHK_GL(glDeleteProgram(ps)); +#else _RELEASE(ps); +#endif // USE_OGL RImplementation.Resources->_DeletePS(this); } -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) /////////////////////////////////////////////////////////////////////// -// SGS +// SGS SGS::~SGS() { +#ifdef USE_OGL + CHK_GL(glDeleteProgram(gs)); +#else _RELEASE(gs); +#endif // USE_OGL RImplementation.Resources->_DeleteGS(this); } @@ -69,43 +79,50 @@ SHS::~SHS() _RELEASE(sh); RImplementation.Resources->_DeleteHS(this); } + SDS::~SDS() { _RELEASE(sh); RImplementation.Resources->_DeleteDS(this); } + SCS::~SCS() { _RELEASE(sh); RImplementation.Resources->_DeleteCS(this); } #endif +#endif // USE_DX10 +#if defined(USE_DX10) || defined(USE_DX11) /////////////////////////////////////////////////////////////////////// -// SInputSignature +// SInputSignature SInputSignature::SInputSignature(ID3DBlob* pBlob) { VERIFY(pBlob); signature = pBlob; signature->AddRef(); }; + SInputSignature::~SInputSignature() { _RELEASE(signature); RImplementation.Resources->_DeleteInputSignature(this); } -#endif // USE_DX10 +#endif // USE_DX10 /////////////////////////////////////////////////////////////////////// -// SState +// SState SState::~SState() { +#ifndef USE_OGL _RELEASE(state); +#endif // !USE_OGL RImplementation.Resources->_DeleteState(this); } /////////////////////////////////////////////////////////////////////// -// SDeclaration +// SDeclaration SDeclaration::~SDeclaration() { RImplementation.Resources->_DeleteDecl(this); @@ -114,11 +131,15 @@ SDeclaration::~SDeclaration() iLayout = vs_to_layout.begin(); for (; iLayout != vs_to_layout.end(); ++iLayout) { - // Release vertex layout + // Release vertex layout _RELEASE(iLayout->second); } -#else // USE_DX10 - // Release vertex layout +#else // USE_DX10 + // Release vertex layout +#ifdef USE_OGL + glDeleteBuffers(1, &dcl); +#else _RELEASE(dcl); -#endif // USE_DX10 +#endif // USE_OGL +#endif // USE_DX10 } diff --git a/src/Layers/xrRender/SH_Atomic.h b/src/Layers/xrRender/SH_Atomic.h index 98348f20846..806d352b0d5 100644 --- a/src/Layers/xrRender/SH_Atomic.h +++ b/src/Layers/xrRender/SH_Atomic.h @@ -3,7 +3,9 @@ #pragma once #include "xrCore/xr_resource.h" #include "tss_def.h" -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) +#include "Layers/xrRenderGL/glState.h" +#elif defined(USE_DX10) || defined(USE_DX11) #include "Layers/xrRenderDX10/StateManager/dx10State.h" #endif // USE_DX10 @@ -24,7 +26,11 @@ typedef resptr_core> ref_input_sig ////////////////////////////////////////////////////////////////////////// struct ECORE_API SVS : public xr_resource_named { +#ifdef USE_OGL + GLuint vs; +#else ID3DVertexShader* vs; +#endif R_constant_table constants; #if defined(USE_DX10) || defined(USE_DX11) ref_input_sign signature; @@ -37,17 +43,25 @@ typedef resptr_core> ref_vs; ////////////////////////////////////////////////////////////////////////// struct ECORE_API SPS : public xr_resource_named { +#ifdef USE_OGL + GLuint ps; +#else ID3DPixelShader* ps; +#endif R_constant_table constants; ~SPS(); }; typedef resptr_core> ref_ps; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) ////////////////////////////////////////////////////////////////////////// struct ECORE_API SGS : public xr_resource_named { +#ifdef USE_OGL + GLuint gs; +#else ID3DGeometryShader* gs; +#endif R_constant_table constants; ~SGS(); }; @@ -85,7 +99,11 @@ typedef resptr_core> ref_cs; ////////////////////////////////////////////////////////////////////////// struct ECORE_API SState : public xr_resource_flagged { +#ifdef USE_OGL + glState state; +#else ID3DState* state; +#endif SimulatorStates state_code; ~SState(); }; @@ -94,7 +112,10 @@ typedef resptr_core> ref_state; ////////////////////////////////////////////////////////////////////////// struct ECORE_API SDeclaration : public xr_resource_flagged { -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + u32 FVF; + GLuint dcl; +#elif defined(USE_DX10) || defined(USE_DX11) // Maps input signature to input layout xr_map vs_to_layout; xr_vector dx10_dcl_code; diff --git a/src/Layers/xrRender/SH_RT.h b/src/Layers/xrRender/SH_RT.h index 132d213f5a2..f03a384af44 100644 --- a/src/Layers/xrRender/SH_RT.h +++ b/src/Layers/xrRender/SH_RT.h @@ -18,8 +18,14 @@ class CRT : public xr_resource_named void reset_end(); BOOL valid() { return !!pTexture; } public: +#ifdef USE_OGL + GLuint pRT; + GLuint pZRT; + GLenum target; +#else ID3DTexture2D* pSurface; ID3DRenderTargetView* pRT; +#endif // USE_OGL #if defined(USE_DX10) || defined(USE_DX11) ID3DDepthStencilView* pZRT; diff --git a/src/Layers/xrRender/SH_Texture.cpp b/src/Layers/xrRender/SH_Texture.cpp index ad8b2ec2742..8a700a610b6 100644 --- a/src/Layers/xrRender/SH_Texture.cpp +++ b/src/Layers/xrRender/SH_Texture.cpp @@ -327,6 +327,8 @@ void CTexture::desc_update() { ID3DTexture2D* T = (ID3DTexture2D*)pSurface; R_CHK(T->GetLevelDesc(0, &desc)); + m_width = desc.Width; + m_height = desc.Height; } } diff --git a/src/Layers/xrRender/SH_Texture.h b/src/Layers/xrRender/SH_Texture.h index e07f123fdaf..953125b5d9c 100644 --- a/src/Layers/xrRender/SH_Texture.h +++ b/src/Layers/xrRender/SH_Texture.h @@ -10,11 +10,55 @@ class CTheoraSurface; class ECORE_API CTexture : public xr_resource_named { public: +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) + enum MaxTextures + { + // Actually these values are 128 + mtMaxPixelShaderTextures = 16, + mtMaxVertexShaderTextures = 4, + mtMaxGeometryShaderTextures = 16, +# ifdef USE_DX11 + mtMaxHullShaderTextures = 16, + mtMaxDomainShaderTextures = 16, + mtMaxComputeShaderTextures = 16, +# endif + mtMaxCombinedShaderTextures = + mtMaxPixelShaderTextures + + mtMaxVertexShaderTextures + + mtMaxGeometryShaderTextures +# ifdef USE_DX11 + + mtMaxHullShaderTextures + + mtMaxDomainShaderTextures + + mtMaxComputeShaderTextures +# endif + }; +#else // USE_DX10 + enum MaxTextures + { + mtMaxPixelShaderTextures = 16, + mtMaxVertexShaderTextures = 4, + mtMaxCombinedShaderTextures = + mtMaxPixelShaderTextures + + mtMaxVertexShaderTextures + }; +#endif // USE_DX10 + +#ifdef USE_OGL + // Since OGL doesn't differentiate between stages, + // distance between enum values should be the max for that stage. + enum ResourceShaderType + { + rstPixel = 0, // Default texture offset + rstVertex = rstPixel + mtMaxPixelShaderTextures, + rstGeometry = rstVertex + mtMaxVertexShaderTextures, + }; +#else // Since DX10 allows up to 128 unique textures, // distance between enum values should be at leas 128 enum ResourceShaderType // Don't change this since it's hardware-dependent { - rstPixel = 0, // Default texture offset + rstPixel = 0, + // Default texture offset rstVertex = D3DVERTEXTEXTURESAMPLER0, rstGeometry = rstVertex + 256, rstHull = rstGeometry + 256, @@ -22,6 +66,7 @@ class ECORE_API CTexture : public xr_resource_named rstCompute = rstDomain + 256, rstInvalid = rstCompute + 256 }; +#endif // USE_OGL public: void __stdcall apply_load(u32 stage); @@ -34,23 +79,29 @@ class ECORE_API CTexture : public xr_resource_named void Load(); void PostLoad(); void Unload(void); - // void Apply (u32 dwStage); + // void Apply(u32 dwStage); +#ifdef USE_OGL + void surface_set(GLenum target, GLuint surf); + GLuint surface_get(); +#else void surface_set(ID3DBaseTexture* surf); ID3DBaseTexture* surface_get(); +#endif // USE_OGL + BOOL isUser() { return flags.bUser; } u32 get_Width() { desc_enshure(); - return desc.Width; + return m_width; } u32 get_Height() { desc_enshure(); - return desc.Height; + return m_height; } void video_Sync(u32 _time) { m_play_time = _time; } @@ -64,7 +115,7 @@ class ECORE_API CTexture : public xr_resource_named #if defined(USE_DX10) || defined(USE_DX11) ID3DShaderResourceView* get_SRView() { return m_pSRView; } -#endif // USE_DX10 +#endif // USE_DX10 private: BOOL desc_valid() { return pSurface == desc_cache; } @@ -74,15 +125,16 @@ class ECORE_API CTexture : public xr_resource_named if (!desc_valid()) desc_update(); } + void desc_update(); #if defined(USE_DX10) || defined(USE_DX11) void Apply(u32 dwStage); void ProcessStaging(); D3D_USAGE GetUsage(); -#endif // USE_DX10 +#endif // USE_DX10 // Class data -public: // Public class members (must be encapsulated furthur) +public: // Public class members (must be encapsulated further) struct { u32 bLoaded : 1; @@ -91,8 +143,9 @@ class ECORE_API CTexture : public xr_resource_named u32 MemoryUsage : 28; #if defined(USE_DX10) || defined(USE_DX11) u32 bLoadedAsStaging : 1; -#endif // USE_DX10 +#endif // USE_DX10 } flags; + fastdelegate::FastDelegate1 bind; CAviPlayerCustom* pAVI; @@ -107,20 +160,35 @@ class ECORE_API CTexture : public xr_resource_named }; private: +#ifdef USE_OGL + GLuint pSurface; + GLuint pBuffer; + // Sequence data + xr_vector seqDATA; + // Description + GLint m_width; + GLint m_height; + GLuint desc_cache; + GLenum desc; +#else ID3DBaseTexture* pSurface; // Sequence data xr_vector seqDATA; // Description + u32 m_width; + u32 m_height; ID3DBaseTexture* desc_cache; D3D_TEXTURE2D_DESC desc; +#endif // USE_OGL #if defined(USE_DX10) || defined(USE_DX11) ID3DShaderResourceView* m_pSRView; // Sequence view data xr_vector m_seqSRView; -#endif // USE_DX10 +#endif // USE_DX10 }; + struct resptrcode_texture : public resptr_base { void create(LPCSTR _name); @@ -128,6 +196,7 @@ struct resptrcode_texture : public resptr_base shared_str bump_get() { return _get()->m_bumpmap; } bool bump_exist() { return 0 != bump_get().size(); } }; + typedef resptr_core ref_texture; #endif diff --git a/src/Layers/xrRender/Shader.cpp b/src/Layers/xrRender/Shader.cpp index 2f16fb099ac..c519c7e09e5 100644 --- a/src/Layers/xrRender/Shader.cpp +++ b/src/Layers/xrRender/Shader.cpp @@ -26,11 +26,19 @@ void resptrcode_shader::create(IBlender* B, LPCSTR s_shader, LPCSTR s_textures, } ////////////////////////////////////////////////////////////////////////// +#ifdef USE_OGL +void resptrcode_geom::create(u32 FVF, GLuint vb, GLuint ib) +#else void resptrcode_geom::create(u32 FVF, ID3DVertexBuffer* vb, ID3DIndexBuffer* ib) +#endif // USE_OGL { _set(RImplementation.Resources->CreateGeom(FVF, vb, ib)); } +#ifdef USE_OGL +void resptrcode_geom::create(D3DVERTEXELEMENT9* decl, GLuint vb, GLuint ib) +#else void resptrcode_geom::create(D3DVERTEXELEMENT9* decl, ID3DVertexBuffer* vb, ID3DIndexBuffer* ib) +#endif // USE_OGL { _set(RImplementation.Resources->CreateGeom(decl, vb, ib)); } @@ -46,7 +54,7 @@ BOOL SPass::equal(const SPass& other) return FALSE; if (vs != other.vs) return FALSE; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) if (gs != other.gs) return FALSE; #ifdef USE_DX11 diff --git a/src/Layers/xrRender/Shader.h b/src/Layers/xrRender/Shader.h index e8f809cbedb..c5190c2eb07 100644 --- a/src/Layers/xrRender/Shader.h +++ b/src/Layers/xrRender/Shader.h @@ -65,16 +65,26 @@ typedef resptr_core> ref_constant_list struct ECORE_API SGeometry : public xr_resource_flagged { ref_declaration dcl; +#ifdef USE_OGL + GLuint vb; + GLuint ib; +#else ID3DVertexBuffer* vb; ID3DIndexBuffer* ib; +#endif u32 vb_stride; ~SGeometry(); }; struct ECORE_API resptrcode_geom : public resptr_base { +#ifdef USE_OGL + void create(D3DVERTEXELEMENT9* decl, GLuint vb, GLuint ib); + void create(u32 FVF, GLuint vb, GLuint ib); +#else void create(D3DVERTEXELEMENT9* decl, ID3DVertexBuffer* vb, ID3DIndexBuffer* ib); void create(u32 FVF, ID3DVertexBuffer* vb, ID3DIndexBuffer* ib); +#endif // USE_OGL void destroy() { _set(nullptr); } u32 stride() const { return _get()->vb_stride; } }; @@ -86,9 +96,8 @@ struct ECORE_API SPass : public xr_resource_flagged { ref_state state; // Generic state, like Z-Buffering, samplers, etc ref_ps ps; // may be NULL = FFP, in that case "state" must contain TSS setup - // may be NULL = FFP, in that case "state" must contain RS setup, *and* FVF-compatible declaration must be used - ref_vs vs; -#if defined(USE_DX10) || defined(USE_DX11) + ref_vs vs; // may be NULL = FFP, in that case "state" must contain RS setup, *and* FVF-compatible declaration must be used +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) ref_gs gs; // may be NULL = don't use geometry shader at all #ifdef USE_DX11 ref_hs hs; // may be NULL = don't use hull shader at all diff --git a/src/Layers/xrRender/SkeletonX.cpp b/src/Layers/xrRender/SkeletonX.cpp index f94433d35db..55e69f6b32f 100644 --- a/src/Layers/xrRender/SkeletonX.cpp +++ b/src/Layers/xrRender/SkeletonX.cpp @@ -678,7 +678,7 @@ void CSkeletonX::_FillVerticesSoft4W(const Fmatrix& view, CSkeletonWallmark& wm, } } -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) void CSkeletonX::_DuplicateIndices(const char* N, IReader* data) { // We will have trouble with container since don't know were to take readable indices diff --git a/src/Layers/xrRender/SkeletonX.h b/src/Layers/xrRender/SkeletonX.h index 7d2ed1f715f..dc9a03805e7 100644 --- a/src/Layers/xrRender/SkeletonX.h +++ b/src/Layers/xrRender/SkeletonX.h @@ -124,7 +124,7 @@ class CSkeletonX virtual void FillVertices( const Fmatrix& view, CSkeletonWallmark& wm, const Fvector& normal, float size, u16 bone_id) = 0; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) protected: void _DuplicateIndices(const char* N, IReader* data); @@ -156,7 +156,7 @@ BOOL pick_bone(T_buffer vertices, CKinematics* Parent, IKinematics::pick_result& return FALSE; } -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) template BOOL pick_bone(CKinematics* Parent, IKinematics::pick_result& r, float dist, const Fvector& S, const Fvector& D, Fvisual* V, u16* indices, CBoneData::FacesVec& faces) diff --git a/src/Layers/xrRender/WallmarksEngine.cpp b/src/Layers/xrRender/WallmarksEngine.cpp index 7ed26281cb0..a95e184d920 100644 --- a/src/Layers/xrRender/WallmarksEngine.cpp +++ b/src/Layers/xrRender/WallmarksEngine.cpp @@ -58,7 +58,7 @@ CWallmarksEngine::CWallmarksEngine() { static_pool.reserve(256); marks.reserve(256); - hGeom.create(FVF::F_LIT, RCache.Vertex.Buffer(), nullptr); + hGeom.create(FVF::F_LIT, RCache.Vertex.Buffer(), 0); } CWallmarksEngine::~CWallmarksEngine() diff --git a/src/Layers/xrRender/blenders/Blender_Recorder.cpp b/src/Layers/xrRender/blenders/Blender_Recorder.cpp index 48c5e150a57..6728e8541fb 100644 --- a/src/Layers/xrRender/blenders/Blender_Recorder.cpp +++ b/src/Layers/xrRender/blenders/Blender_Recorder.cpp @@ -178,7 +178,7 @@ void CBlender_Compile::PassEnd() proto.vs = RImplementation.Resources->_CreateVS(pass_vs); ctable.merge(&proto.ps->constants); ctable.merge(&proto.vs->constants); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) proto.gs = RImplementation.Resources->_CreateGS(pass_gs); ctable.merge(&proto.gs->constants); #ifdef USE_DX11 diff --git a/src/Layers/xrRender/blenders/Blender_Recorder.h b/src/Layers/xrRender/blenders/Blender_Recorder.h index 1643054b957..44c612bad35 100644 --- a/src/Layers/xrRender/blenders/Blender_Recorder.h +++ b/src/Layers/xrRender/blenders/Blender_Recorder.h @@ -53,7 +53,7 @@ class CBlender_Compile string128 pass_vs; string128 pass_ps; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) string128 pass_gs; #ifdef USE_DX11 string128 pass_hs; @@ -63,6 +63,7 @@ class CBlender_Compile #endif // USE_DX10 u32 BC(BOOL v) { return v ? 0x01 : 0; } + public: CSimulator& R() { return RS; } void SetParams(int iPriority, bool bStrictB2F); @@ -142,7 +143,7 @@ class CBlender_Compile void r_Pass(LPCSTR vs, LPCSTR ps, bool bFog, BOOL bZtest = TRUE, BOOL bZwrite = TRUE, BOOL bABlend = FALSE, D3DBLEND abSRC = D3DBLEND_ONE, D3DBLEND abDST = D3DBLEND_ZERO, BOOL aTest = FALSE, u32 aRef = 0); void r_Constant(LPCSTR name, R_constant_setup* s); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) void r_Pass(LPCSTR vs, LPCSTR gs, LPCSTR ps, bool bFog, BOOL bZtest = TRUE, BOOL bZwrite = TRUE, BOOL bABlend = FALSE, D3DBLEND abSRC = D3DBLEND_ONE, D3DBLEND abDST = D3DBLEND_ZERO, BOOL aTest = FALSE, u32 aRef = 0); @@ -156,7 +157,9 @@ class CBlender_Compile u32 Fail = D3DSTENCILOP_KEEP, u32 Pass = D3DSTENCILOP_KEEP, u32 ZFail = D3DSTENCILOP_KEEP); void r_StencilRef(u32 Ref); void r_CullMode(D3DCULL Mode); +#endif +#if defined(USE_DX10) || defined(USE_DX11) void r_dx10Texture(LPCSTR ResourceName, LPCSTR texture); void r_dx10Texture(LPCSTR ResourceName, shared_str texture) { @@ -175,6 +178,12 @@ class CBlender_Compile void r_Sampler_clf(LPCSTR name, LPCSTR texture, bool b_ps1x_ProjectiveDivide = false); void r_Sampler_clw(LPCSTR name, LPCSTR texture, bool b_ps1x_ProjectiveDivide = false); #endif // USE_DX10 + +#ifdef USE_OGL + void i_Comparison(u32 s, u32 func); + void r_Sampler_cmp(pcstr name, pcstr texture, bool b_ps1x_ProjectiveDivide = false); +#endif // USE_OGL + void r_ColorWriteEnable(bool cR = true, bool cG = true, bool cB = true, bool cA = true); void r_End(); diff --git a/src/Layers/xrRender/dxApplicationRender.cpp b/src/Layers/xrRender/dxApplicationRender.cpp index 75721ad6492..601bc2734a5 100644 --- a/src/Layers/xrRender/dxApplicationRender.cpp +++ b/src/Layers/xrRender/dxApplicationRender.cpp @@ -13,7 +13,7 @@ void dxApplicationRender::LoadBegin() sh_progress.create("hud\\default", "ui\\ui_actor_loadgame_screen"); hLevelLogo_Add.create("hud\\default", "ui\\ui_actor_widescreen_sidepanels.dds"); - ll_hGeom2.create(FVF::F_TL, RCache.Vertex.Buffer(), nullptr); + ll_hGeom2.create(FVF::F_TL, RCache.Vertex.Buffer(), 0); } void dxApplicationRender::destroy_loading_shaders() @@ -28,14 +28,14 @@ u32 calc_progress_color(u32, u32, int, int); void dxApplicationRender::load_draw_internal(CApplication& owner) { -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: remove this??? RImplementation.rmNormal(); RCache.set_RT(HW.pBaseRT); RCache.set_ZB(HW.pBaseZB); #endif // USE_DX10 -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) FLOAT ColorRGBA[4] = {0.0f, 0.0f, 0.0f, 0.0f}; HW.pContext->ClearRenderTargetView(RCache.get_RT(), ColorRGBA); #else // USE_DX10 @@ -47,7 +47,7 @@ void dxApplicationRender::load_draw_internal(CApplication& owner) return; } -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: remove this // FLOAT ColorRGBA[4] = {0.0f, 0.0f, 1.0f, 0.0f}; // HW.pContext->ClearRenderTargetView( RCache.get_RT(), ColorRGBA); diff --git a/src/Layers/xrRender/dxConsoleRender.cpp b/src/Layers/xrRender/dxConsoleRender.cpp index 839a4b3e902..fd575369f0e 100644 --- a/src/Layers/xrRender/dxConsoleRender.cpp +++ b/src/Layers/xrRender/dxConsoleRender.cpp @@ -18,7 +18,7 @@ void dxConsoleRender::OnRender(bool bGame) if (bGame) R.y2 /= 2; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) u32 vOffset = 0; // TODO: DX10: Implement console background clearing for DX10 FVF::TL* verts = (FVF::TL*)RCache.Vertex.Lock(4, m_Geom->vb_stride, vOffset); diff --git a/src/Layers/xrRender/dxConsoleRender.h b/src/Layers/xrRender/dxConsoleRender.h index c553d0effb1..40f114500a7 100644 --- a/src/Layers/xrRender/dxConsoleRender.h +++ b/src/Layers/xrRender/dxConsoleRender.h @@ -13,7 +13,7 @@ class dxConsoleRender : public IConsoleRender virtual void OnRender(bool bGame); private: -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) ref_shader m_Shader; ref_geom m_Geom; #endif diff --git a/src/Layers/xrRender/dxDebugRender.cpp b/src/Layers/xrRender/dxDebugRender.cpp index ee68814140e..465349dd3a8 100644 --- a/src/Layers/xrRender/dxDebugRender.cpp +++ b/src/Layers/xrRender/dxDebugRender.cpp @@ -92,7 +92,7 @@ void dxDebugRender::CacheSetXformWorld(const Fmatrix& M) { RCache.set_xform_worl void dxDebugRender::CacheSetCullMode(CullMode m) { RCache.set_CullMode(CULL_NONE + m); } void dxDebugRender::SetAmbient(u32 colour) { -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: Check if need this for DX10 VERIFY(!"Not implemented for DX10"); #else // USE_DX10 diff --git a/src/Layers/xrRender/dxEnvironmentRender.cpp b/src/Layers/xrRender/dxEnvironmentRender.cpp index ab2a3266f52..5c8ceb01386 100644 --- a/src/Layers/xrRender/dxEnvironmentRender.cpp +++ b/src/Layers/xrRender/dxEnvironmentRender.cpp @@ -157,6 +157,13 @@ void dxEnvironmentRender::OnFrame(CEnvironment& env) } //. Setup skybox textures, somewhat ugly +#ifdef USE_OGL + GLuint e0 = mixRen.sky_r_textures[0].second->surface_get(); + GLuint e1 = mixRen.sky_r_textures[1].second->surface_get(); + + tsky0->surface_set(GL_TEXTURE_CUBE_MAP, e0); + tsky1->surface_set(GL_TEXTURE_CUBE_MAP, e1); +#else ID3DBaseTexture* e0 = mixRen.sky_r_textures[0].second->surface_get(); ID3DBaseTexture* e1 = mixRen.sky_r_textures[1].second->surface_get(); @@ -164,9 +171,10 @@ void dxEnvironmentRender::OnFrame(CEnvironment& env) _RELEASE(e0); tsky1->surface_set(e1); _RELEASE(e1); +#endif // USE_OGL // ******************** Environment params (setting) -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: Implement environment parameters setting for DX10 (if necessary) #else // USE_DX10 @@ -307,8 +315,13 @@ void dxEnvironmentRender::OnDeviceCreate() void dxEnvironmentRender::OnDeviceDestroy() { +#ifdef USE_OGL + tsky0->surface_set(GL_TEXTURE_CUBE_MAP, 0); + tsky1->surface_set(GL_TEXTURE_CUBE_MAP, 0); +#else tsky0->surface_set(nullptr); tsky1->surface_set(nullptr); +#endif // USE_OGL sh_2sky.destroy(); sh_2geom.destroy(); diff --git a/src/Layers/xrRender/light.cpp b/src/Layers/xrRender/light.cpp index 2e839cb3885..323250e8ec2 100644 --- a/src/Layers/xrRender/light.cpp +++ b/src/Layers/xrRender/light.cpp @@ -27,7 +27,7 @@ light::light(void) : SpatialBase(g_SpatialSpace) frame_render = 0; -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) ZeroMemory(omnipart, sizeof(omnipart)); s_spot = NULL; s_point = NULL; @@ -36,26 +36,26 @@ light::light(void) : SpatialBase(g_SpatialSpace) vis.query_order = 0; vis.visible = true; vis.pending = false; -#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) } light::~light() { -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) for (int f = 0; f < 6; f++) xr_delete(omnipart[f]); -#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) set_active(false); // remove from Lights_LastFrame -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) for (u32 it = 0; it < RImplementation.Lights_LastFrame.size(); it++) if (this == RImplementation.Lights_LastFrame[it]) RImplementation.Lights_LastFrame[it] = 0; -#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) } -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) void light::set_texture(LPCSTR name) { if ((0 == name) || (0 == name[0])) @@ -74,9 +74,9 @@ void light::set_texture(LPCSTR name) // strconcat(sizeof(temp),temp,"_nomsaa",name); s_spot.create(RImplementation.Target->b_accum_spot, temp, name); -#if (RENDER != R_R3) && (RENDER != R_R4) +#if (RENDER != R_R3) && (RENDER != R_R4) && (RENDER != R_GL) s_volumetric.create("accum_volumetric", name); -#else // (RENDER!=R_R3) && (RENDER!=R_R4) +#else // (RENDER!=R_R3) && (RENDER!=R_R4) && (RENDER!=R_GL) s_volumetric.create("accum_volumetric_nomsaa", name); if (RImplementation.o.dx10_msaa) { @@ -93,7 +93,7 @@ void light::set_texture(LPCSTR name) strconcat(sizeof(temp), temp, "r2\\accum_volumetric_", name), name); } } -#endif // (RENDER!=R_R3) || (RENDER!=R_R4) +#endif // (RENDER!=R_R3) || (RENDER!=R_R4) || (RENDER!=R_GL) } #endif @@ -226,7 +226,7 @@ vis_data& light::get_homdata() Fvector light::spatial_sector_point() { return position; } ////////////////////////////////////////////////////////////////////////// -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) // Xforms void light::xform_calc() { @@ -348,7 +348,7 @@ void light::Export(light_Package& package) L->s_point = s_point; // Holger - do we need to export msaa stuff as well ? -#if (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) if (RImplementation.o.dx10_msaa) { int bound = 1; @@ -363,7 +363,7 @@ void light::Export(light_Package& package) // L->s_volumetric_msaa[i] = s_volumetric_msaa[i]; } } -#endif // (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) // Igor: add volumetric support L->set_volumetric(flags.bVolumetric); @@ -396,7 +396,7 @@ void light::set_attenuation_params(float a0, float a1, float a2, float fo) falloff = fo; } -#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) extern float r_ssaGLOD_start, r_ssaGLOD_end; extern float ps_r2_slight_fade; diff --git a/src/Layers/xrRender/light.h b/src/Layers/xrRender/light.h index b2e3ab587b8..ca3a8bda968 100644 --- a/src/Layers/xrRender/light.h +++ b/src/Layers/xrRender/light.h @@ -3,11 +3,11 @@ #include "xrCDB/ISpatial.h" -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER==R_GL) #include "light_package.h" #include "light_smapvis.h" #include "light_GI.h" -#endif //(RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#endif //(RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) class light : public IRender_Light, public SpatialBase { @@ -36,7 +36,7 @@ class light : public IRender_Light, public SpatialBase float m_volumetric_intensity; float m_volumetric_distance; -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) float falloff; // precalc to make light equal to zero at light range float attenuation0; // Constant attenuation float attenuation1; // Linear attenuation @@ -52,11 +52,11 @@ class light : public IRender_Light, public SpatialBase ref_shader s_point; ref_shader s_volumetric; -#if (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) ref_shader s_spot_msaa[8]; ref_shader s_point_msaa[8]; ref_shader s_volumetric_msaa[8]; -#endif // (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) u32 m_xform_frame; Fmatrix m_xform; @@ -98,7 +98,7 @@ class light : public IRender_Light, public SpatialBase BOOL transluent; } S; } X; -#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) public: virtual void set_type(LT type) { flags.type = type; } @@ -124,14 +124,14 @@ class light : public IRender_Light, public SpatialBase virtual IRender_Light* dcast_Light() { return this; } vis_data& get_homdata(); -#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL) void gi_generate(); void xform_calc(); void vis_prepare(); void vis_update(); void Export(light_Package& dest); void set_attenuation_params(float a0, float a1, float a2, float fo); -#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) +#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL) float get_LOD(); diff --git a/src/Layers/xrRenderPC_R2/light_GI.cpp b/src/Layers/xrRender/light_GI.cpp similarity index 100% rename from src/Layers/xrRenderPC_R2/light_GI.cpp rename to src/Layers/xrRender/light_GI.cpp diff --git a/src/Layers/xrRenderPC_R2/light_gi.h b/src/Layers/xrRender/light_gi.h similarity index 100% rename from src/Layers/xrRenderPC_R2/light_gi.h rename to src/Layers/xrRender/light_gi.h diff --git a/src/Layers/xrRenderPC_R2/light_smapvis.cpp b/src/Layers/xrRender/light_smapvis.cpp similarity index 100% rename from src/Layers/xrRenderPC_R2/light_smapvis.cpp rename to src/Layers/xrRender/light_smapvis.cpp diff --git a/src/Layers/xrRenderPC_R2/light_smapvis.h b/src/Layers/xrRender/light_smapvis.h similarity index 100% rename from src/Layers/xrRenderPC_R2/light_smapvis.h rename to src/Layers/xrRender/light_smapvis.h diff --git a/src/Layers/xrRenderPC_R2/light_vis.cpp b/src/Layers/xrRender/light_vis.cpp similarity index 100% rename from src/Layers/xrRenderPC_R2/light_vis.cpp rename to src/Layers/xrRender/light_vis.cpp diff --git a/src/Layers/xrRender/r__dsgraph_build.cpp b/src/Layers/xrRender/r__dsgraph_build.cpp index fea2a4ff405..d428c9f9dde 100644 --- a/src/Layers/xrRender/r__dsgraph_build.cpp +++ b/src/Layers/xrRender/r__dsgraph_build.cpp @@ -166,7 +166,11 @@ void D3DXRenderBase::r_dsgraph_insert_dynamic(dxRender_Visual* pVisual, Fvector& auto &pass = *sh->passes[iPass]; auto &map = mapMatrixPasses[sh->flags.iPriority / 2][iPass]; -#if defined(USE_DX10) || defined(USE_DX11) +#ifdef USE_OGL + auto &Nvs = map[pass.vs->vs]; + auto &Ngs = Nvs[pass.gs->gs]; + auto &Nps = Ngs[pass.ps->ps]; +#elif defined(USE_DX10) || defined(USE_DX11) auto &Nvs = map[&*pass.vs]; auto &Ngs = Nvs[pass.gs->gs]; auto &Nps = Ngs[pass.ps->ps]; @@ -183,7 +187,7 @@ void D3DXRenderBase::r_dsgraph_insert_dynamic(dxRender_Visual* pVisual, Fvector& #else auto &Ncs = Nps[pass.constants._get()]; #endif - auto &Nstate = Ncs[pass.state->state]; + auto &Nstate = Ncs[&*pass.state]; auto &Ntex = Nstate[pass.T._get()]; Ntex.push_back(item); @@ -206,7 +210,7 @@ void D3DXRenderBase::r_dsgraph_insert_dynamic(dxRender_Visual* pVisual, Fvector& { Nps.ssa = SSA; #endif -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) if (SSA > Ngs.ssa) { Ngs.ssa = SSA; @@ -215,7 +219,7 @@ void D3DXRenderBase::r_dsgraph_insert_dynamic(dxRender_Visual* pVisual, Fvector& { Nvs.ssa = SSA; } -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) } #endif } @@ -326,7 +330,11 @@ void D3DXRenderBase::r_dsgraph_insert_static(dxRender_Visual* pVisual) auto &pass = *sh->passes[iPass]; auto &map = mapNormalPasses[sh->flags.iPriority / 2][iPass]; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + auto &Nvs = map[pass.vs->vs]; + auto &Ngs = Nvs[pass.gs->gs]; + auto &Nps = Ngs[pass.ps->ps]; +#elif defined(USE_DX10) || defined(USE_DX11) auto &Nvs = map[&*pass.vs]; auto &Ngs = Nvs[pass.gs->gs]; auto &Nps = Ngs[pass.ps->ps]; @@ -343,7 +351,8 @@ void D3DXRenderBase::r_dsgraph_insert_static(dxRender_Visual* pVisual) #else auto &Ncs = Nps[pass.constants._get()]; #endif - auto &Nstate = Ncs[pass.state->state]; + //auto &Nstate = Ncs[pass.state->state]; + auto &Nstate = Ncs[&*pass.state]; auto &Ntex = Nstate[pass.T._get()]; Ntex.push_back(item); @@ -784,10 +793,34 @@ D3DXRenderBase::D3DXRenderBase() } void D3DXRenderBase::Copy(IRender& _in) { *this = *(D3DXRenderBase*)&_in; } -void D3DXRenderBase::setGamma(float fGamma) { m_Gamma.Gamma(fGamma); } -void D3DXRenderBase::setBrightness(float fGamma) { m_Gamma.Brightness(fGamma); } -void D3DXRenderBase::setContrast(float fGamma) { m_Gamma.Contrast(fGamma); } -void D3DXRenderBase::updateGamma() { m_Gamma.Update(); } +void D3DXRenderBase::setGamma(float fGamma) +{ +#ifndef USE_OGL + m_Gamma.Gamma(fGamma); +#endif +} + +void D3DXRenderBase::setBrightness(float fGamma) +{ +#ifndef USE_OGL + m_Gamma.Brightness(fGamma); +#endif +} + +void D3DXRenderBase::setContrast(float fGamma) +{ +#ifndef USE_OGL + m_Gamma.Contrast(fGamma); +#endif +} + +void D3DXRenderBase::updateGamma() +{ +#ifndef USE_OGL + m_Gamma.Update(); +#endif +} + void D3DXRenderBase::OnDeviceDestroy(bool bKeepTextures) { m_WireShader.destroy(); @@ -805,7 +838,7 @@ void D3DXRenderBase::DestroyHW() void D3DXRenderBase::Reset(HWND hWnd, u32& dwWidth, u32& dwHeight, float& fWidth_2, float& fHeight_2) { -#ifdef DEBUG +#if defined(DEBUG) && !defined(USE_OGL) _SHOW_REF("*ref -CRenderDevice::ResetTotal: DeviceREF:", HW.pDevice); #endif // DEBUG @@ -813,7 +846,10 @@ void D3DXRenderBase::Reset(HWND hWnd, u32& dwWidth, u32& dwHeight, float& fWidth Memory.mem_compact(); HW.Reset(hWnd); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + dwWidth = psCurrentVidMode[0]; + dwHeight = psCurrentVidMode[1]; +#elif defined(USE_DX10) || defined(USE_DX11) dwWidth = HW.m_ChainDesc.BufferDesc.Width; dwHeight = HW.m_ChainDesc.BufferDesc.Height; #else // USE_DX10 @@ -825,15 +861,15 @@ void D3DXRenderBase::Reset(HWND hWnd, u32& dwWidth, u32& dwHeight, float& fWidth fHeight_2 = float(dwHeight / 2); Resources->reset_end(); -#ifdef DEBUG +#if defined(DEBUG) && !defined(USE_OGL) _SHOW_REF("*ref +CRenderDevice::ResetTotal: DeviceREF:", HW.pDevice); -#endif // DEBUG +#endif } void D3DXRenderBase::SetupStates() { HW.Caps.Update(); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: Implement Resetting of render states into default mode // VERIFY(!"D3DXRenderBase::SetupStates not implemented."); #else // USE_DX10 @@ -883,7 +919,9 @@ void D3DXRenderBase::OnDeviceCreate(const char* shName) { // Signal everyone - device created RCache.OnDeviceCreate(); +#ifndef USE_OGL m_Gamma.Update(); +#endif Resources->OnDeviceCreate(shName); create(); if (!GEnv.isDedicatedServer) @@ -897,7 +935,10 @@ void D3DXRenderBase::OnDeviceCreate(const char* shName) void D3DXRenderBase::Create(HWND hWnd, u32& dwWidth, u32& dwHeight, float& fWidth_2, float& fHeight_2, bool move_window) { HW.CreateDevice(hWnd, move_window); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + dwWidth = psCurrentVidMode[0]; + dwHeight = psCurrentVidMode[1]; +#elif defined(USE_DX10) || defined(USE_DX11) dwWidth = HW.m_ChainDesc.BufferDesc.Width; dwHeight = HW.m_ChainDesc.BufferDesc.Height; #else @@ -918,7 +959,7 @@ void D3DXRenderBase::SetupGPU(bool bForceGPU_SW, bool bForceGPU_NonPure, bool bF void D3DXRenderBase::overdrawBegin() { -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: Implement overdrawBegin VERIFY(!"D3DXRenderBase::overdrawBegin not implemented."); #else @@ -940,7 +981,7 @@ void D3DXRenderBase::overdrawBegin() void D3DXRenderBase::overdrawEnd() { -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: Implement overdrawEnd VERIFY(!"D3DXRenderBase::overdrawBegin not implemented."); #else @@ -985,7 +1026,7 @@ void D3DXRenderBase::ResourcesDumpMemoryUsage() { Resources->_DumpMemoryUsage(); DeviceState D3DXRenderBase::GetDeviceState() { HW.Validate(); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: Implement GetDeviceState // TODO: DX10: Implement DXGI_PRESENT_TEST testing // VERIFY(!"D3DXRenderBase::overdrawBegin not implemented."); @@ -1008,7 +1049,7 @@ bool D3DXRenderBase::GetForceGPU_REF() { return HW.Caps.bForceGPU_REF; } u32 D3DXRenderBase::GetCacheStatPolys() { return RCache.stat.polys; } void D3DXRenderBase::Begin() { -#if !defined(USE_DX10) && !defined(USE_DX11) +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) CHK_DX(HW.pDevice->BeginScene()); #endif RCache.OnFrameBegin(); @@ -1020,7 +1061,7 @@ void D3DXRenderBase::Begin() void D3DXRenderBase::Clear() { -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) HW.pContext->ClearDepthStencilView(RCache.get_ZB(), D3D_CLEAR_DEPTH | D3D_CLEAR_STENCIL, 1.0f, 0); if (psDeviceFlags.test(rsClearBB)) { @@ -1043,7 +1084,7 @@ void D3DXRenderBase::End() RCache.OnFrameEnd(); Memory.dbg_check(); DoAsyncScreenshot(); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) bool bUseVSync = psDeviceFlags.is(rsFullscreen) && psDeviceFlags.test(rsVSync); //xxx: weird tearing glitches when VSync turned on for windowed mode in DX10\11 HW.m_pSwapChain->Present(bUseVSync ? 1 : 0, 0); #else @@ -1055,7 +1096,7 @@ void D3DXRenderBase::End() void D3DXRenderBase::ResourcesDestroyNecessaryTextures() { Resources->DestroyNecessaryTextures(); } void D3DXRenderBase::ClearTarget() { -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) FLOAT ColorRGBA[4] = {0.0f, 0.0f, 0.0f, 0.0f}; HW.pContext->ClearRenderTargetView(RCache.get_RT(), ColorRGBA); #else diff --git a/src/Layers/xrRender/r__dsgraph_render.cpp b/src/Layers/xrRender/r__dsgraph_render.cpp index 281c2c59c12..4e9f9a61929 100644 --- a/src/Layers/xrRender/r__dsgraph_render.cpp +++ b/src/Layers/xrRender/r__dsgraph_render.cpp @@ -129,7 +129,7 @@ void D3DXRenderBase::r_dsgraph_render_graph(u32 _priority) { RCache.set_VS(vs_it->first); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // GS setup mapNormalGS& gs = vs_it->second; gs.ssa = 0; @@ -215,7 +215,7 @@ void D3DXRenderBase::r_dsgraph_render_graph(u32 _priority) } nrmPS.clear(); ps.clear(); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) } nrmGS.clear(); gs.clear(); @@ -241,7 +241,7 @@ void D3DXRenderBase::r_dsgraph_render_graph(u32 _priority) { RCache.set_VS(vs_id->first); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) mapMatrixGS& gs = vs_id->second; gs.ssa = 0; @@ -330,7 +330,7 @@ void D3DXRenderBase::r_dsgraph_render_graph(u32 _priority) } matPS.clear(); ps.clear(); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) } matGS.clear(); gs.clear(); @@ -429,7 +429,7 @@ void D3DXRenderBase::r_dsgraph_render_hud_ui() const ref_rt rt_null; RCache.set_RT(0, 1); RCache.set_RT(0, 2); -#if (RENDER == R_R3) || (RENDER == R_R4) +#if (RENDER == R_R3) || (RENDER == R_R4) || (RENDER==R_GL) if (!RImplementation.o.dx10_msaa) { if (RImplementation.o.albedo_wo) diff --git a/src/Layers/xrRender/r__dsgraph_types.h b/src/Layers/xrRender/r__dsgraph_types.h index 48cf02b71ee..f10b5c828fa 100644 --- a/src/Layers/xrRender/r__dsgraph_types.h +++ b/src/Layers/xrRender/r__dsgraph_types.h @@ -32,16 +32,23 @@ struct _LodItem dxRender_Visual* pVisual; }; -using ps_type = ID3DPixelShader *; -#if defined(USE_DX10) || defined(USE_DX11) // DX10 and DX11 needs shader signature to properly bind geometry to shader +using state_type = SState*; +#ifndef USE_OGL +using ps_type = ID3DPixelShader*; +#if defined(USE_DX10) || defined(USE_DX11) // DX10 and DX11 needs shader signature to properly bind geometry to shader using vs_type = SVS*; -using gs_type = ID3DGeometryShader *; +using gs_type = ID3DGeometryShader*; #else -using vs_type = ID3DVertexShader *; +using vs_type = ID3DVertexShader*; #endif #ifdef USE_DX11 -using hs_type = ID3D11HullShader *; -using ds_type = ID3D11DomainShader *; +using hs_type = ID3D11HullShader*; +using ds_type = ID3D11DomainShader*; +#endif +#else +using vs_type = GLuint; +using ps_type = GLuint; +using gs_type = GLuint; #endif // NORMAL @@ -57,7 +64,7 @@ struct mapNormalTextures : public xr_unordered_map +struct mapNormalStates : public xr_unordered_map { float ssa; }; @@ -86,7 +93,7 @@ struct mapNormalPS : public xr_unordered_map }; #endif -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) struct mapNormalGS : public xr_unordered_map { float ssa; @@ -113,7 +120,7 @@ struct mapMatrixTextures : public xr_unordered_map +struct mapMatrixStates : public xr_unordered_map { float ssa; }; @@ -142,7 +149,7 @@ struct mapMatrixPS : public xr_unordered_map }; #endif -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) struct mapMatrixGS : public xr_unordered_map { float ssa; diff --git a/src/Layers/xrRender/r__occlusion.cpp b/src/Layers/xrRender/r__occlusion.cpp index d1b5a09db39..c737b7e387a 100644 --- a/src/Layers/xrRender/r__occlusion.cpp +++ b/src/Layers/xrRender/r__occlusion.cpp @@ -14,7 +14,7 @@ void R_occlusion::occq_create(u32 limit) { _Q q; q.order = it; - if (FAILED(CreateQuery(&q.Q, D3DQUERYTYPE_OCCLUSION))) + if (FAILED(CreateQuery(&q.Q))) break; pool.push_back(q); } @@ -24,18 +24,19 @@ void R_occlusion::occq_destroy() { while (!used.empty()) { - _RELEASE(used.back().Q); + ReleaseQuery(used.back().Q); used.pop_back(); } while (!pool.empty()) { - _RELEASE(pool.back().Q); + ReleaseQuery(pool.back().Q); pool.pop_back(); } used.clear(); pool.clear(); fids.clear(); } + u32 R_occlusion::occq_begin(u32& ID) { if (!enabled) @@ -115,8 +116,10 @@ R_occlusion::occq_result R_occlusion::occq_get(u32& ID) } } RImplementation.BasicStats.Wait.End(); +#ifndef USE_OGL if (hr == D3DERR_DEVICELOST) fragments = 0xffffffff; +#endif if (0 == fragments) RImplementation.BasicStats.OcclusionCulled++; diff --git a/src/Layers/xrRender/r__occlusion.h b/src/Layers/xrRender/r__occlusion.h index 69fffa9c55b..50e6f2bc699 100644 --- a/src/Layers/xrRender/r__occlusion.h +++ b/src/Layers/xrRender/r__occlusion.h @@ -18,7 +18,11 @@ class R_occlusion struct _Q { u32 order; +#ifdef USE_OGL + GLuint Q; +#else ID3DQuery* Q; +#endif }; static const u32 iInvalidHandle = 0xFFFFFFFF; diff --git a/src/Layers/xrRender/r__screenshot.cpp b/src/Layers/xrRender/r__screenshot.cpp index fa9e1767e4a..2cbc7c4b5d2 100644 --- a/src/Layers/xrRender/r__screenshot.cpp +++ b/src/Layers/xrRender/r__screenshot.cpp @@ -4,7 +4,7 @@ #include "xrEngine/xrImage_Resampler.h" #if defined(USE_DX10) || defined(USE_DX11) #include "d3dx10tex.h" -#endif // USE_DX10 +#endif // USE_DX10 using namespace XRay::Media; @@ -17,6 +17,7 @@ IC u32 convert(float c) C = 255; return C; } + IC void MouseRayFromPoint(Fvector& direction, int x, int y, Fmatrix& m_CamMat) { int halfwidth = Device.dwWidth / 2; @@ -40,7 +41,13 @@ IC void MouseRayFromPoint(Fvector& direction, int x, int y, Fmatrix& m_CamMat) #define SM_FOR_SEND_WIDTH 640 #define SM_FOR_SEND_HEIGHT 480 -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) +void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* memory_writer) +{ + // TODO: OGL: Implement screenshot feature. + VERIFY(!"CRender::ScreenshotImpl not implemented."); +} +#elif defined(USE_DX10) || defined(USE_DX11) void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* memory_writer) { ID3DResource* pSrcTexture; @@ -67,7 +74,7 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me desc.BindFlags = D3D10_BIND_SHADER_RESOURCE; CHK_DX(HW.pDevice->CreateTexture2D(&desc, NULL, &pSrcSmallTexture)); -// D3DX10_TEXTURE_LOAD_INFO *pLoadInfo + //D3DX10_TEXTURE_LOAD_INFO* pLoadInfo #ifdef USE_DX11 CHK_DX(D3DX11LoadTextureFromTexture(HW.pContext, pSrcTexture, NULL, pSrcSmallTexture)); @@ -76,12 +83,12 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me #endif // save (logical & physical) - ID3DBlob* saved = 0; + ID3DBlob* saved = nullptr; #ifdef USE_DX11 HRESULT hr = D3DX11SaveTextureToMemory(HW.pContext, pSrcSmallTexture, D3DX11_IFF_DDS, &saved, 0); #else HRESULT hr = D3DX10SaveTextureToMemory(pSrcSmallTexture, D3DX10_IFF_DDS, &saved, 0); -// HRESULT hr = D3DXSaveTextureToFileInMemory (&saved,D3DXIFF_DDS,texture,0); + //HRESULT hr = D3DXSaveTextureToFileInMemory(&saved, D3DXIFF_DDS, texture, 0); #endif if (hr == D3D_OK) { @@ -114,7 +121,7 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me desc.BindFlags = D3D_BIND_SHADER_RESOURCE; CHK_DX(HW.pDevice->CreateTexture2D(&desc, NULL, &pSrcSmallTexture)); -// D3DX10_TEXTURE_LOAD_INFO *pLoadInfo + //D3DX10_TEXTURE_LOAD_INFO* pLoadInfo #ifdef USE_DX11 CHK_DX(D3DX11LoadTextureFromTexture(HW.pContext, pSrcTexture, NULL, pSrcSmallTexture)); @@ -122,12 +129,12 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me CHK_DX(D3DX10LoadTextureFromTexture(pSrcTexture, NULL, pSrcSmallTexture)); #endif // save (logical & physical) - ID3DBlob* saved = 0; + ID3DBlob* saved = nullptr; #ifdef USE_DX11 HRESULT hr = D3DX11SaveTextureToMemory(HW.pContext, pSrcSmallTexture, D3DX11_IFF_DDS, &saved, 0); #else HRESULT hr = D3DX10SaveTextureToMemory(pSrcSmallTexture, D3DX10_IFF_DDS, &saved, 0); -// HRESULT hr = D3DXSaveTextureToFileInMemory (&saved,D3DXIFF_DDS,texture,0); + //HRESULT hr = D3DXSaveTextureToFileInMemory(&saved, D3DXIFF_DDS, texture, 0); #endif if (hr == D3D_OK) { @@ -150,14 +157,14 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me // cleanup _RELEASE(pSrcSmallTexture); } - break; + break; case IRender::SM_NORMAL: { string64 t_stemp; string_path buf; - xr_sprintf(buf, sizeof(buf), "ss_%s_%s_(%s).jpg", Core.UserName, timestamp(t_stemp), - (g_pGameLevel) ? g_pGameLevel->name().c_str() : "mainmenu"); - ID3DBlob* saved = 0; + xr_sprintf(buf, sizeof buf, "ss_%s_%s_(%s).jpg", Core.UserName, timestamp(t_stemp), + g_pGameLevel ? g_pGameLevel->name().c_str() : "mainmenu"); + ID3DBlob* saved = nullptr; #ifdef USE_DX11 CHK_DX(D3DX11SaveTextureToMemory(HW.pContext, pSrcTexture, D3DX11_IFF_JPG, &saved, 0)); #else @@ -171,14 +178,14 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me if (strstr(Core.Params, "-ss_tga")) { // hq - xr_sprintf(buf, sizeof(buf), "ssq_%s_%s_(%s).tga", Core.UserName, timestamp(t_stemp), - (g_pGameLevel) ? g_pGameLevel->name().c_str() : "mainmenu"); - ID3DBlob* saved = 0; + xr_sprintf(buf, sizeof buf, "ssq_%s_%s_(%s).tga", Core.UserName, timestamp(t_stemp), + g_pGameLevel ? g_pGameLevel->name().c_str() : "mainmenu"); + ID3DBlob* saved = nullptr; #ifdef USE_DX11 CHK_DX(D3DX11SaveTextureToMemory(HW.pContext, pSrcTexture, D3DX11_IFF_BMP, &saved, 0)); #else CHK_DX(D3DX10SaveTextureToMemory(pSrcTexture, D3DX10_IFF_BMP, &saved, 0)); -// CHK_DX (D3DXSaveSurfaceToFileInMemory (&saved,D3DXIFF_TGA,pFB,0,0)); + //CHK_DX(D3DXSaveSurfaceToFileInMemory(&saved, D3DXIFF_TGA, pFB, 0, 0)); #endif IWriter* fs = FS.w_open("$screenshots$", buf); R_ASSERT(fs); @@ -187,7 +194,7 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me _RELEASE(saved); } } - break; + break; case IRender::SM_FOR_LEVELMAP: case IRender::SM_FOR_CUBEMAP: { @@ -223,44 +230,32 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me FS.w_close (fs); */ } - break; + break; } _RELEASE(pSrcTexture); } -#else // USE_DX10 +#else // USE_DX10 void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* memory_writer) { if (!Device.b_is_Ready) return; - if ((psDeviceFlags.test(rsFullscreen)) == 0) - { - if (name && FS.exist(name)) - FS.file_delete(nullptr, name); - - Log("~ Can't capture screen while in windowed mode..."); - return; - } - // Create temp-surface IDirect3DSurface9* pFB; D3DLOCKED_RECT D; HRESULT hr; hr = HW.pDevice->CreateOffscreenPlainSurface( - Device.dwWidth, Device.dwHeight, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &pFB, nullptr); - if (hr != D3D_OK) + Device.dwWidth, Device.dwHeight, HW.DevPP.BackBufferFormat, D3DPOOL_SYSTEMMEM, &pFB, nullptr); + if (FAILED(hr)) return; - - hr = HW.pDevice->GetFrontBufferData(0, pFB); - if (hr != D3D_OK) - return; - + hr = HW.pDevice->GetRenderTargetData(HW.pBaseRT, pFB); + if (FAILED(hr)) + goto _end_; hr = pFB->LockRect(&D, nullptr, D3DLOCK_NOSYSLOCK); - if (hr != D3D_OK) - return; - + if (FAILED(hr)) + goto _end_; // Image processing (gamma-correct) u32* pPixel = (u32*)D.pBits; u32* pEnd = pPixel + (Device.dwWidth * Device.dwHeight); @@ -283,7 +278,7 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me } */ - // Kill alpha + // Kill alpha for (; pPixel != pEnd; pPixel++) { u32 p = *pPixel; @@ -335,7 +330,7 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me // cleanup _RELEASE(texture); } - break; + break; case IRender::SM_FOR_MPSENDING: { // texture @@ -383,13 +378,13 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me // cleanup _RELEASE(texture); } - break; + break; case IRender::SM_NORMAL: { string64 t_stemp; string_path buf; - xr_sprintf(buf, sizeof(buf), "ss_%s_%s_(%s).jpg", Core.UserName, timestamp(t_stemp), - (g_pGameLevel) ? g_pGameLevel->name().c_str() : "mainmenu"); + xr_sprintf(buf, sizeof buf, "ss_%s_%s_(%s).jpg", Core.UserName, timestamp(t_stemp), + g_pGameLevel ? g_pGameLevel->name().c_str() : "mainmenu"); ID3DBlob* saved = nullptr; CHK_DX(D3DXSaveSurfaceToFileInMemory(&saved, D3DXIFF_JPG, pFB, nullptr, nullptr)); IWriter* fs = FS.w_open("$screenshots$", buf); @@ -400,7 +395,7 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me if (strstr(Core.Params, "-ss_tga")) { // hq xr_sprintf(buf, sizeof(buf), "ssq_%s_%s_(%s).tga", Core.UserName, timestamp(t_stemp), - (g_pGameLevel) ? g_pGameLevel->name().c_str() : "mainmenu"); + (g_pGameLevel) ? g_pGameLevel->name().c_str() : "mainmenu"); ID3DBlob* saved = nullptr; CHK_DX(D3DXSaveSurfaceToFileInMemory(&saved, D3DXIFF_TGA, pFB, nullptr, nullptr)); IWriter* fs = FS.w_open("$screenshots$", buf); @@ -410,18 +405,18 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me _RELEASE(saved); } } - break; + break; case IRender::SM_FOR_LEVELMAP: case IRender::SM_FOR_CUBEMAP: { - // string64 t_stemp; + // string64 t_stemp; string_path buf; VERIFY(name); strconcat(sizeof(buf), buf, name, ".tga"); IWriter* fs = FS.w_open("$screenshots$", buf); R_ASSERT(fs); - // TODO: DX10: This is totally incorrect but mimics - // original behavior. Fix later. + // TODO: DX10: This is totally incorrect but mimics + // original behavior. Fix later. hr = pFB->LockRect(&D, nullptr, D3DLOCK_NOSYSLOCK); if (hr != D3D_OK) return; @@ -431,22 +426,21 @@ void CRender::ScreenshotImpl(ScreenshotMode mode, LPCSTR name, CMemoryWriter* me // save u32* data = (u32*)xr_malloc(Device.dwHeight * Device.dwHeight * 4); - imf_Process( - data, Device.dwHeight, Device.dwHeight, (u32*)D.pBits, Device.dwWidth, Device.dwHeight, imf_lanczos3); + imf_Process(data, Device.dwHeight, Device.dwHeight, (u32*)D.pBits, Device.dwWidth, Device.dwHeight, imf_lanczos3); Image img; img.Create(u16(Device.dwHeight), u16(Device.dwHeight), data, ImageFormat::RGBA8); img.SaveTGA(*fs, true); xr_free(data); FS.w_close(fs); } - break; + break; } _end_: _RELEASE(pFB); } -#endif // USE_DX10 +#endif // USE_DX10 void CRender::Screenshot(ScreenshotMode mode, LPCSTR name) { ScreenshotImpl(mode, name, nullptr); } void CRender::Screenshot(ScreenshotMode mode, CMemoryWriter& memory_writer) @@ -465,13 +459,21 @@ void CRender::ScreenshotAsyncBegin() m_bMakeAsyncSS = true; } -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + +void CRender::ScreenshotAsyncEnd(CMemoryWriter &memory_writer) +{ + // TODO: OGL: Implement screenshot feature. + VERIFY(!"CRender::ScreenshotAsyncEnd not implemented."); +} + +#elif defined(USE_DX10) || defined(USE_DX11) void CRender::ScreenshotAsyncEnd(CMemoryWriter& memory_writer) { VERIFY(!m_bMakeAsyncSS); - // Don't own. No need to release. + // Don't own. No need to release. ID3DTexture2D* pTex = Target->t_ss_async; D3D_MAPPED_TEXTURE2D MappedData; @@ -486,7 +488,7 @@ void CRender::ScreenshotAsyncEnd(CMemoryWriter& memory_writer) u32* pPixel = (u32*)MappedData.pData; u32* pEnd = pPixel + (Device.dwWidth * Device.dwHeight); - // Kill alpha and swap r and b. + // Kill alpha and swap r and b. for (; pPixel != pEnd; pPixel++) { u32 p = *pPixel; @@ -505,7 +507,7 @@ void CRender::ScreenshotAsyncEnd(CMemoryWriter& memory_writer) #endif } -#else // USE_DX10 +#else // USE_DX10 void CRender::ScreenshotAsyncEnd(CMemoryWriter& memory_writer) { @@ -527,17 +529,17 @@ void CRender::ScreenshotAsyncEnd(CMemoryWriter& memory_writer) #if RENDER == R_R1 u32 rtWidth = Target->get_rtwidth(); u32 rtHeight = Target->get_rtheight(); -#else // RENDER != R_R1 +#else // RENDER != R_R1 u32 rtWidth = Device.dwWidth; u32 rtHeight = Device.dwHeight; -#endif // RENDER != R_R1 +#endif // RENDER != R_R1 // Image processing (gamma-correct) u32* pPixel = (u32*)D.pBits; u32* pOrigin = pPixel; u32* pEnd = pPixel + (rtWidth * rtHeight); -// Kill alpha + // Kill alpha #if RENDER != R_R1 if (Target->rt_Color->fmt == D3DFMT_A16B16G16R16F) { @@ -562,7 +564,7 @@ void CRender::ScreenshotAsyncEnd(CMemoryWriter& memory_writer) } } else -#endif // RENDER != R_R1 +#endif // RENDER != R_R1 { for (; pPixel != pEnd; pPixel++) { @@ -580,6 +582,6 @@ void CRender::ScreenshotAsyncEnd(CMemoryWriter& memory_writer) hr = pFB->UnlockRect(); } -#endif // USE_DX10 +#endif // USE_DX10 void DoAsyncScreenshot() { RImplementation.Target->DoAsyncScreenshot(); } diff --git a/src/Layers/xrRender/r__sector_traversal.cpp b/src/Layers/xrRender/r__sector_traversal.cpp index 795ec90cef8..99c36685e51 100644 --- a/src/Layers/xrRender/r__sector_traversal.cpp +++ b/src/Layers/xrRender/r__sector_traversal.cpp @@ -57,7 +57,7 @@ void CPortalTraverser::fade_portal(CPortal* _p, float ssa) { f_portals.push_back void CPortalTraverser::initialize() { f_shader.create("portal"); - f_geom.create(FVF::F_L, RCache.Vertex.Buffer(), nullptr); + f_geom.create(FVF::F_L, RCache.Vertex.Buffer(), 0); } void CPortalTraverser::destroy() { diff --git a/src/Layers/xrRender/r_constants.cpp b/src/Layers/xrRender/r_constants.cpp index 38d2e0532da..3a2806a5282 100644 --- a/src/Layers/xrRender/r_constants.cpp +++ b/src/Layers/xrRender/r_constants.cpp @@ -1,11 +1,6 @@ #include "stdafx.h" #pragma hdrstop -#pragma warning(push) -#pragma warning(disable : 4995) -#include -#pragma warning(pop) - #include "ResourceManager.h" #include "xrCore/xrPool.h" #include "r_constants.h" @@ -44,7 +39,7 @@ ref_constant R_constant_table::get(shared_str& S) return nullptr; } -#if !defined(USE_DX10) && !defined(USE_DX11) +#if !defined(USE_DX10) && !defined(USE_DX11) && !defined(USE_OGL) BOOL R_constant_table::parse(void* _desc, u32 destination) { D3DXSHADER_CONSTANTTABLE* desc = (D3DXSHADER_CONSTANTTABLE*)_desc; @@ -194,7 +189,7 @@ void R_constant_table::merge(R_constant_table* T) C->type = src->type; C->ps = src->ps; C->vs = src->vs; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) C->gs = src->gs; #ifdef USE_DX11 C->hs = src->hs; @@ -216,6 +211,10 @@ void R_constant_table::merge(R_constant_table* T) R_constant_load& dL = C->get_load(src->destination); dL.index = sL.index; dL.cls = sL.cls; +#ifdef USE_OGL + dL.location = sL.location; + dL.program = sL.program; +#endif // USE_OGL } } diff --git a/src/Layers/xrRender/r_constants.h b/src/Layers/xrRender/r_constants.h index ead4ac26009..8b6d9db25e8 100644 --- a/src/Layers/xrRender/r_constants.h +++ b/src/Layers/xrRender/r_constants.h @@ -72,9 +72,23 @@ struct ECORE_API R_constant_load u16 index; // linear index (pixel) u16 cls; // element class - R_constant_load() : index(u16(-1)), cls(u16(-1)){}; +#ifdef USE_OGL + GLuint location; + GLuint program; - BOOL equal(R_constant_load& C) { return (index == C.index) && (cls == C.cls); } + R_constant_load() : index(u16(-1)), cls(u16(-1)), location(0), program(0) {}; +#else + R_constant_load() : index(u16(-1)), cls(u16(-1)) {}; +#endif // USE_OGL + + BOOL equal(R_constant_load& C) + { +#ifdef USE_OGL + return (index == C.index) && (cls == C.cls) && (location == C.location) && (program == C.program); +#else + return (index == C.index) && (cls == C.cls); +#endif // USE_OGL + } }; struct ECORE_API R_constant : public xr_resource @@ -85,7 +99,7 @@ struct ECORE_API R_constant : public xr_resource R_constant_load ps; R_constant_load vs; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) R_constant_load gs; #ifdef USE_DX11 R_constant_load hs; @@ -105,7 +119,7 @@ struct ECORE_API R_constant : public xr_resource { case RC_dest_vertex: return vs; case RC_dest_pixel: return ps; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) case RC_dest_geometry: return gs; #ifdef USE_DX11 case RC_dest_hull: return hs; diff --git a/src/Layers/xrRender/r_constants_cache.h b/src/Layers/xrRender/r_constants_cache.h index 0ce5b6c8e74..7c0499bfcc3 100644 --- a/src/Layers/xrRender/r_constants_cache.h +++ b/src/Layers/xrRender/r_constants_cache.h @@ -4,7 +4,9 @@ #include "r_constants.h" -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) +#include "Layers/xrRenderGL/glr_constants_cache.h" +#elif defined(USE_DX10) || defined(USE_DX11) #include "Layers/xrRenderDX10/dx10r_constants_cache.h" #else // USE_DX10 #include "Layers/xrRenderDX9/dx9r_constants_cache.h" diff --git a/src/Layers/xrRender/tss.h b/src/Layers/xrRender/tss.h index 7331939de1e..3a1ebc7b30f 100644 --- a/src/Layers/xrRender/tss.h +++ b/src/Layers/xrRender/tss.h @@ -4,7 +4,7 @@ #include "tss_def.h" -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) enum XRDX10SAMPLERSTATETYPE { XRDX10SAMP_ANISOTROPICFILTER = 256, diff --git a/src/Layers/xrRender/tss_def.cpp b/src/Layers/xrRender/tss_def.cpp index ec8f1adb292..195773eee64 100644 --- a/src/Layers/xrRender/tss_def.cpp +++ b/src/Layers/xrRender/tss_def.cpp @@ -3,6 +3,22 @@ #include "tss_def.h" +#ifdef USE_OGL +#include "../xrRenderGL/glState.h" +void SimulatorStates::record(glState& state) +{ + for (u32 it = 0; it < States.size(); it++) + { + State& S = States[it]; + switch (S.type) + { + case 0: state.UpdateRenderState(S.v1, S.v2); break; + //case 1: VERIFY(!"Texture environment not supported"); break; + case 2: state.UpdateSamplerState(S.v1, S.v2, S.v3); break; + } +} +} +#else IDirect3DStateBlock9* SimulatorStates::record() { // TODO: DX10: Implement equivalent for SimulatorStates::record for DX10 @@ -31,6 +47,7 @@ IDirect3DStateBlock9* SimulatorStates::record() return SB; #endif // USE_DX10 } +#endif // USE_OGL void SimulatorStates::set_RS(u32 a, u32 b) { diff --git a/src/Layers/xrRender/tss_def.h b/src/Layers/xrRender/tss_def.h index f3174d77b05..7bb049c293f 100644 --- a/src/Layers/xrRender/tss_def.h +++ b/src/Layers/xrRender/tss_def.h @@ -45,7 +45,11 @@ class SimulatorStates void set_SAMP(u32 a, u32 b, u32 c); BOOL equal(SimulatorStates& S); void clear(); +#ifdef USE_OGL + void record(glState& state); +#else IDirect3DStateBlock9* record(); +#endif #if defined(USE_DX10) || defined(USE_DX11) void UpdateState(dx10State& state) const; void UpdateDesc(D3D_RASTERIZER_DESC& desc) const; diff --git a/src/Layers/xrRender/xrD3DDefs.h b/src/Layers/xrRender/xrD3DDefs.h index f977991946c..6b37e8812a2 100644 --- a/src/Layers/xrRender/xrD3DDefs.h +++ b/src/Layers/xrRender/xrD3DDefs.h @@ -2,7 +2,32 @@ #ifndef xrD3DDefs_included #define xrD3DDefs_included -#if defined(USE_DX11) || defined(USE_DX10) +#if defined(USE_OGL) + +// TODO: Get rid of D3D types. +#include + +class glState; + +typedef enum D3D_CLEAR_FLAG { + D3D_CLEAR_DEPTH = 0x1L, + D3D_CLEAR_STENCIL = 0x2L +} D3D_CLEAR_FLAG; + +typedef enum D3D_COMPARISON_FUNC { + D3D_COMPARISON_NEVER = GL_NEVER, + D3D_COMPARISON_LESS = GL_LESS, + D3D_COMPARISON_EQUAL = GL_EQUAL, + D3D_COMPARISON_LESS_EQUAL = GL_LEQUAL, + D3D_COMPARISON_GREATER = GL_GREATER, + D3D_COMPARISON_NOT_EQUAL = GL_NOTEQUAL, + D3D_COMPARISON_GREATER_EQUAL = GL_GEQUAL, + D3D_COMPARISON_ALWAYS = GL_ALWAYS +} D3D_COMPARISON_FUNC; + +#define DX10_ONLY(expr) do {} while (0) + +#elif defined(USE_DX11) || defined(USE_DX10) #include "Layers/xrRenderDX10/DXCommonTypes.h" #else // USE_DX10 diff --git a/src/Layers/xrRender/xrRender_console.cpp b/src/Layers/xrRender/xrRender_console.cpp index 9fafa6eb319..ce558d38299 100644 --- a/src/Layers/xrRender/xrRender_console.cpp +++ b/src/Layers/xrRender/xrRender_console.cpp @@ -14,14 +14,14 @@ xr_token qsun_shafts_token[] = {{"st_opt_off", 0}, {"st_opt_low", 1}, {"st_opt_m u32 ps_r_ssao = 3; xr_token qssao_token[] = {{"st_opt_off", 0}, {"st_opt_low", 1}, {"st_opt_medium", 2}, {"st_opt_high", 3}, -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) {"st_opt_ultra", 4}, #endif {nullptr, 0}}; u32 ps_r_sun_quality = 1; // = 0; xr_token qsun_quality_token[] = {{"st_opt_low", 0}, {"st_opt_medium", 1}, {"st_opt_high", 2}, -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) {"st_opt_ultra", 3}, {"st_opt_extreme", 4}, #endif // USE_DX10 {nullptr, 0}}; @@ -245,9 +245,11 @@ class CCC_tf_Aniso : public CCC_Integer return; int val = *value; clamp(val, 1, 16); -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_OGL) + // TODO: OGL: Implement aniso filtering. +#elif defined(USE_DX10) || defined(USE_DX11) SSManager.SetMaxAnisotropy(val); -#else // USE_DX10 +#else for (u32 i = 0; i < HW.Caps.raster.dwStages; i++) CHK_DX(HW.pDevice->SetSamplerState(i, D3DSAMP_MAXANISOTROPY, val)); #endif // USE_DX10 @@ -272,7 +274,7 @@ class CCC_tf_MipBias : public CCC_Float if (nullptr == HW.pDevice) return; -#if defined(USE_DX10) || defined(USE_DX11) +#if defined(USE_DX10) || defined(USE_DX11) || defined(USE_OGL) // TODO: DX10: Implement mip bias control //VERIFY(!"apply not implmemented."); #else // USE_DX10 @@ -437,11 +439,12 @@ class CCC_Preset : public CCC_Token class CCC_memory_stats : public IConsole_Command { -protected: public: CCC_memory_stats(LPCSTR N) : IConsole_Command(N) { bEmptyArgsHandled = true; }; virtual void Execute(LPCSTR /*args*/) { + // TODO: OGL: Implement memory usage statistics. +#ifndef USE_OGL u32 m_base = 0; u32 c_base = 0; u32 m_lmaps = 0; @@ -482,10 +485,11 @@ class CCC_memory_stats : public IConsole_Command Msg("\nTotal \t \t %f \t %f \t %f ", vb_video + ib_video + rt_video, textures_managed + vb_managed + ib_managed + rt_managed, vb_system + ib_system + rt_system); +#endif // USE_OGL } }; -#if RENDER != R_R1 +#if RENDER != R_R1 && RENDER != R_GL #include "r__pixel_calculator.h" class CCC_BuildSSA : public IConsole_Command { @@ -667,7 +671,7 @@ void xrRender_initconsole() // Igor: just to test bug with rain/particles corruption CMD1(CCC_RestoreQuadIBData, "r_restore_quad_ib_data"); #ifdef DEBUG -#if RENDER != R_R1 +#if RENDER != R_R1 && RENDER != R_GL CMD1(CCC_BuildSSA, "build_ssa"); #endif CMD4(CCC_Integer, "r__lsleep_frames", &ps_r__LightSleepFrames, 4, 30); diff --git a/src/Layers/xrRenderDX10/Blender_Recorder_R3.cpp b/src/Layers/xrRenderDX10/Blender_Recorder_R3.cpp index f8e128aebe5..1f5842e2679 100644 --- a/src/Layers/xrRenderDX10/Blender_Recorder_R3.cpp +++ b/src/Layers/xrRenderDX10/Blender_Recorder_R3.cpp @@ -160,7 +160,7 @@ u32 CBlender_Compile::r_dx10Sampler(LPCSTR ResourceName) i_dx10Address(stage, D3DTADDRESS_CLAMP); i_dx10Filter(stage, D3DTEXF_LINEAR, D3DTEXF_NONE, D3DTEXF_LINEAR); RS.SetSAMP(stage, XRDX10SAMP_COMPARISONFILTER, TRUE); - RS.SetSAMP(stage, XRDX10SAMP_COMPARISONFUNC, D3D_COMPARISON_LESS_EQUAL); + RS.SetSAMP(stage, XRDX10SAMP_COMPARISONFUNC, (u32)D3D_COMPARISON_LESS_EQUAL); } if (0 == xr_strcmp(ResourceName, "smp_jitter")) @@ -173,7 +173,7 @@ u32 CBlender_Compile::r_dx10Sampler(LPCSTR ResourceName) } void CBlender_Compile::r_Pass(LPCSTR _vs, LPCSTR _gs, LPCSTR _ps, bool bFog, BOOL bZtest, BOOL bZwrite, BOOL bABlend, - D3DBLEND abSRC, D3DBLEND abDST, BOOL aTest, u32 aRef) + D3DBLEND abSRC, D3DBLEND abDST, BOOL aTest, u32 aRef) { RS.Invalidate(); ctable.clear(); diff --git a/src/Layers/xrRenderDX10/StateManager/dx10ShaderResourceStateCache.cpp b/src/Layers/xrRenderDX10/StateManager/dx10ShaderResourceStateCache.cpp index 8818798fed1..4893af2a657 100644 --- a/src/Layers/xrRenderDX10/StateManager/dx10ShaderResourceStateCache.cpp +++ b/src/Layers/xrRenderDX10/StateManager/dx10ShaderResourceStateCache.cpp @@ -95,7 +95,7 @@ void dx10ShaderResourceStateCache::Apply() void dx10ShaderResourceStateCache::SetPSResource(u32 uiSlot, ID3DShaderResourceView* pRes) { - VERIFY(uiSlot < CBackend::mtMaxPixelShaderTextures); + VERIFY(uiSlot < CTexture::mtMaxPixelShaderTextures); if (m_PSViews[uiSlot] != pRes) { @@ -116,7 +116,7 @@ void dx10ShaderResourceStateCache::SetPSResource(u32 uiSlot, ID3DShaderResourceV void dx10ShaderResourceStateCache::SetGSResource(u32 uiSlot, ID3DShaderResourceView* pRes) { - VERIFY(uiSlot < CBackend::mtMaxGeometryShaderTextures); + VERIFY(uiSlot < CTexture::mtMaxGeometryShaderTextures); if (m_GSViews[uiSlot] != pRes) { @@ -137,7 +137,7 @@ void dx10ShaderResourceStateCache::SetGSResource(u32 uiSlot, ID3DShaderResourceV void dx10ShaderResourceStateCache::SetVSResource(u32 uiSlot, ID3DShaderResourceView* pRes) { - VERIFY(uiSlot < CBackend::mtMaxVertexShaderTextures); + VERIFY(uiSlot < CTexture::mtMaxVertexShaderTextures); if (m_VSViews[uiSlot] != pRes) { @@ -159,7 +159,7 @@ void dx10ShaderResourceStateCache::SetVSResource(u32 uiSlot, ID3DShaderResourceV #ifdef USE_DX11 void dx10ShaderResourceStateCache::SetHSResource(u32 uiSlot, ID3DShaderResourceView* pRes) { - VERIFY(uiSlot < CBackend::mtMaxHullShaderTextures); + VERIFY(uiSlot < CTexture::mtMaxHullShaderTextures); if (m_HSViews[uiSlot] != pRes) { @@ -180,7 +180,7 @@ void dx10ShaderResourceStateCache::SetHSResource(u32 uiSlot, ID3DShaderResourceV void dx10ShaderResourceStateCache::SetDSResource(u32 uiSlot, ID3DShaderResourceView* pRes) { - VERIFY(uiSlot < CBackend::mtMaxHullShaderTextures); + VERIFY(uiSlot < CTexture::mtMaxHullShaderTextures); if (m_DSViews[uiSlot] != pRes) { @@ -201,7 +201,7 @@ void dx10ShaderResourceStateCache::SetDSResource(u32 uiSlot, ID3DShaderResourceV void dx10ShaderResourceStateCache::SetCSResource(u32 uiSlot, ID3DShaderResourceView* pRes) { - VERIFY(uiSlot < CBackend::mtMaxComputeShaderTextures); + VERIFY(uiSlot < CTexture::mtMaxComputeShaderTextures); if (m_CSViews[uiSlot] != pRes) { diff --git a/src/Layers/xrRenderDX10/StateManager/dx10ShaderResourceStateCache.h b/src/Layers/xrRenderDX10/StateManager/dx10ShaderResourceStateCache.h index e1d16696be3..4573868f496 100644 --- a/src/Layers/xrRenderDX10/StateManager/dx10ShaderResourceStateCache.h +++ b/src/Layers/xrRenderDX10/StateManager/dx10ShaderResourceStateCache.h @@ -21,13 +21,13 @@ class dx10ShaderResourceStateCache #endif private: - ID3DShaderResourceView* m_PSViews[CBackend::mtMaxPixelShaderTextures]; - ID3DShaderResourceView* m_GSViews[CBackend::mtMaxGeometryShaderTextures]; - ID3DShaderResourceView* m_VSViews[CBackend::mtMaxVertexShaderTextures]; + ID3DShaderResourceView* m_PSViews[CTexture::mtMaxPixelShaderTextures]; + ID3DShaderResourceView* m_GSViews[CTexture::mtMaxGeometryShaderTextures]; + ID3DShaderResourceView* m_VSViews[CTexture::mtMaxVertexShaderTextures]; #ifdef USE_DX11 - ID3DShaderResourceView* m_HSViews[CBackend::mtMaxHullShaderTextures]; - ID3DShaderResourceView* m_DSViews[CBackend::mtMaxDomainShaderTextures]; - ID3DShaderResourceView* m_CSViews[CBackend::mtMaxComputeShaderTextures]; + ID3DShaderResourceView* m_HSViews[CTexture::mtMaxHullShaderTextures]; + ID3DShaderResourceView* m_DSViews[CTexture::mtMaxDomainShaderTextures]; + ID3DShaderResourceView* m_CSViews[CTexture::mtMaxComputeShaderTextures]; #endif u32 m_uiMinPSView; diff --git a/src/Layers/xrRenderPC_R3/dx10MinMaxSMBlender.cpp b/src/Layers/xrRenderDX10/dx10MinMaxSMBlender.cpp similarity index 100% rename from src/Layers/xrRenderPC_R3/dx10MinMaxSMBlender.cpp rename to src/Layers/xrRenderDX10/dx10MinMaxSMBlender.cpp diff --git a/src/Layers/xrRenderPC_R3/dx10MinMaxSMBlender.h b/src/Layers/xrRenderDX10/dx10MinMaxSMBlender.h similarity index 100% rename from src/Layers/xrRenderPC_R3/dx10MinMaxSMBlender.h rename to src/Layers/xrRenderDX10/dx10MinMaxSMBlender.h diff --git a/src/Layers/xrRenderDX10/dx10SH_Texture.cpp b/src/Layers/xrRenderDX10/dx10SH_Texture.cpp index 32ec768cdf5..9635e0d9e0a 100644 --- a/src/Layers/xrRenderDX10/dx10SH_Texture.cpp +++ b/src/Layers/xrRenderDX10/dx10SH_Texture.cpp @@ -601,6 +601,8 @@ void CTexture::desc_update() { ID3DTexture2D* T = (ID3DTexture2D*)pSurface; T->GetDesc(&desc); + m_width = desc.Width; + m_height = desc.Height; } } } diff --git a/src/Layers/xrRenderPC_GL/gl_R_render.cpp b/src/Layers/xrRenderPC_GL/gl_R_render.cpp index aa4665432a9..147cc5b8a7e 100644 --- a/src/Layers/xrRenderPC_GL/gl_R_render.cpp +++ b/src/Layers/xrRenderPC_GL/gl_R_render.cpp @@ -338,7 +338,7 @@ void CRender::Render () { PIX_EVENT(DEFER_TEST_LIGHT_VIS); // perform tests - u32 count = 0; + auto count = 0; light_Package& LP = Lights.package; // stats @@ -350,7 +350,7 @@ void CRender::Render () count = _max (count,LP.v_point.size()); count = _max (count,LP.v_spot.size()); count = _max (count,LP.v_shadowed.size()); - for (u32 it=0; itvis_prepare (); diff --git a/src/Layers/xrRenderPC_GL/gl_loader.cpp b/src/Layers/xrRenderPC_GL/gl_loader.cpp index 12f85a3a793..18137911952 100644 --- a/src/Layers/xrRenderPC_GL/gl_loader.cpp +++ b/src/Layers/xrRenderPC_GL/gl_loader.cpp @@ -26,7 +26,7 @@ void CRender::level_Load(IReader* fs) IReader* chunk; // Shaders -// g_pGamePersistent->LoadTitle ("st_loading_shaders"); + g_pGamePersistent->SetLoadStageTitle ("st_loading_shaders"); g_pGamePersistent->LoadTitle (); { chunk = fs->open_chunk (fsL_SHADERS); @@ -54,7 +54,7 @@ void CRender::level_Load(IReader* fs) if (!GEnv.isDedicatedServer) { // VB,IB,SWI -// g_pGamePersistent->LoadTitle("st_loading_geometry"); + g_pGamePersistent->SetLoadStageTitle("st_loading_geometry"); g_pGamePersistent->LoadTitle(); { CStreamReader *geom = FS.rs_open("$level$","level.geom"); @@ -73,20 +73,20 @@ void CRender::level_Load(IReader* fs) } // Visuals -// g_pGamePersistent->LoadTitle("st_loading_spatial_db"); + g_pGamePersistent->SetLoadStageTitle("st_loading_spatial_db"); g_pGamePersistent->LoadTitle(); chunk = fs->open_chunk(fsL_VISUALS); LoadVisuals (chunk); chunk->close (); // Details -// g_pGamePersistent->LoadTitle("st_loading_details"); + g_pGamePersistent->SetLoadStageTitle("st_loading_details"); g_pGamePersistent->LoadTitle(); Details->Load (); } // Sectors -// g_pGamePersistent->LoadTitle("st_loading_sectors_portals"); + g_pGamePersistent->SetLoadStageTitle("st_loading_sectors_portals"); g_pGamePersistent->LoadTitle(); LoadSectors (fs); @@ -94,7 +94,8 @@ void CRender::level_Load(IReader* fs) HOM.Load (); // Lights - // pApp->LoadTitle ("Loading lights..."); + g_pGamePersistent->SetLoadStageTitle("st_loading_lights"); + g_pGamePersistent->LoadTitle(); LoadLights (fs); // End diff --git a/src/Layers/xrRenderPC_GL/rgl.h b/src/Layers/xrRenderPC_GL/rgl.h index 7275ea07981..f9e8ec969d6 100644 --- a/src/Layers/xrRenderPC_GL/rgl.h +++ b/src/Layers/xrRenderPC_GL/rgl.h @@ -171,7 +171,7 @@ class CRender : public D3DXRenderBase light_Package LP_normal; light_Package LP_pending; - xr_vector > main_coarse_structure; + xr_vector main_coarse_structure; shared_str c_sbase ; shared_str c_lmaterial ; diff --git a/src/Layers/xrRenderPC_GL/xrRender_GL.cpp b/src/Layers/xrRenderPC_GL/xrRender_GL.cpp index 0d36c8ad6e4..aa5846fa994 100644 --- a/src/Layers/xrRenderPC_GL/xrRender_GL.cpp +++ b/src/Layers/xrRenderPC_GL/xrRender_GL.cpp @@ -7,7 +7,7 @@ #pragma comment(lib, "xrEngine.lib") -extern "C" void XR_EXPORT SetupEnv() +void SetupEnvRGL() { GEnv.Render = &RImplementation; GEnv.RenderFactory = &RenderFactoryImpl; @@ -18,3 +18,25 @@ extern "C" void XR_EXPORT SetupEnv() #endif xrRender_initconsole(); } + +bool SupportsOpenGLRendering() +{ + // XXX: do a real check + return true; +} + +// This must not be optimized by compiler +static const volatile class GEnvHelper +{ +public: + GEnvHelper() + { + GEnv.CheckRGL = SupportsOpenGLRendering; + GEnv.SetupRGL = SetupEnvRGL; + } + ~GEnvHelper() + { + GEnv.SetupRGL = nullptr; + GEnv.SetupRGL = nullptr; + } +} helper; diff --git a/src/Layers/xrRenderPC_GL/xrRender_GL.vcxproj b/src/Layers/xrRenderPC_GL/xrRender_GL.vcxproj index 0c4a08d5166..5155af2bcf4 100644 --- a/src/Layers/xrRenderPC_GL/xrRender_GL.vcxproj +++ b/src/Layers/xrRenderPC_GL/xrRender_GL.vcxproj @@ -5,14 +5,26 @@ Debug Win32 + + Debug + x64 + Mixed Win32 + + Mixed + x64 + Release Win32 + + Release + x64 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6} @@ -25,149 +37,103 @@ v141 MultiByte + + DynamicLibrary + v141 + MultiByte + DynamicLibrary v141 MultiByte true + + DynamicLibrary + v141 + MultiByte + true + DynamicLibrary v141 MultiByte + + DynamicLibrary + v141 + MultiByte + - - - - - - + - - - - - - - + <_ProjectFileVersion>12.0.30501.0 - - true - true - - - false - - - false - - Disabled - true $(xrExternals)OpenAutomate\inc;$(xrExternals)gl\include;$(xrExternals)glew\include;$(xrExternals)gli;$(xrExternals)gli\external\glm;$(xrExternals)AGS_SDK;%(AdditionalIncludeDirectories) - USE_OGL;NO_XR_VDECLARATOR;_USRDLL;XRRENDER_GL_EXPORTS;%(PreprocessorDefinitions) - false - EnableFastChecks - MultiThreadedDLL - true - Precise - true - Use - Level4 - true - -Zm200 %(AdditionalOptions) + _USRDLL;XRRENDER_GL_EXPORTS;USE_OGL;NO_XR_VDECLARATOR;%(PreprocessorDefinitions) + + + nvapi.lib;amd_ags_$(PlatformShortName).lib;oalib.lib;opengl32.lib;glu32.lib;%(AdditionalDependencies) + $(xrExternals)OpenAutomate\libraries;$(xrExternals)nvapi\x86;$(xrExternals)AGS_SDK\ags_lib\lib;%(AdditionalLibraryDirectories) + + + + + $(xrExternals)OpenAutomate\inc;$(xrExternals)gl\include;$(xrExternals)glew\include;$(xrExternals)gli;$(xrExternals)gli\external\glm;$(xrExternals)AGS_SDK;%(AdditionalIncludeDirectories) + _USRDLL;XRRENDER_GL_EXPORTS;USE_OGL;NO_XR_VDECLARATOR;%(PreprocessorDefinitions) - LuaJIT.lib;luabind.lib;nvapi.lib;amd_ags_x86.lib;oalib.lib;opengl32.lib;glu32.lib;%(AdditionalDependencies) - true - $(xrExternals)OpenAutomate\libraries;$(xrExternals)nvapi\x86;$(xrExternals)luajit\bin\$(PlatformShortName);$(xrExternals)AGS_SDK\ags_lib\lib;%(AdditionalLibraryDirectories) - true - false - Windows - true - MachineX86 - false - false + nvapi64.lib;amd_ags_$(PlatformShortName).lib;oalib.lib;opengl32.lib;glu32.lib;%(AdditionalDependencies) + $(xrExternals)OpenAutomate\libraries;$(xrExternals)nvapi\amd64;$(xrExternals)AGS_SDK\ags_lib\lib;%(AdditionalLibraryDirectories) - MaxSpeed - AnySuitable - true - Speed - true - true - true $(xrExternals)OpenAutomate\inc;$(xrExternals)gl\include;$(xrExternals)glew\include;$(xrExternals)gli;$(xrExternals)gli\external\glm;$(xrExternals)AGS_SDK;%(AdditionalIncludeDirectories) - USE_OGL;NO_XR_VDECLARATOR;_USRDLL;XRRENDER_GL_EXPORTS;%(PreprocessorDefinitions) - true - MultiThreadedDLL - false - false - StreamingSIMDExtensions2 + _USRDLL;XRRENDER_GL_EXPORTS;USE_OGL;NO_XR_VDECLARATOR;%(PreprocessorDefinitions) + + + nvapi.lib;amd_ags_$(PlatformShortName).lib;oalib.lib;opengl32.lib;glu32.lib;%(AdditionalDependencies) + $(xrExternals)OpenAutomate\libraries;$(xrExternals)nvapi\x86;$(xrExternals)AGS_SDK\ags_lib\lib;%(AdditionalLibraryDirectories) + + + + + $(xrExternals)OpenAutomate\inc;$(xrExternals)gl\include;$(xrExternals)glew\include;$(xrExternals)gli;$(xrExternals)gli\external\glm;$(xrExternals)AGS_SDK;%(AdditionalIncludeDirectories) + _USRDLL;XRRENDER_GL_EXPORTS;USE_OGL;NO_XR_VDECLARATOR;%(PreprocessorDefinitions) Precise - true - Use - Level4 - true - -Zm200 %(AdditionalOptions) - LuaJIT.lib;luabind.lib;nvapi.lib;amd_ags_x86.lib;oalib.lib;opengl32.lib;glu32.lib;%(AdditionalDependencies) - $(xrExternals)OpenAutomate\libraries;$(xrExternals)nvapi\x86;$(xrExternals)luajit\bin\$(PlatformShortName);$(xrExternals)AGS_SDK\ags_lib\lib;%(AdditionalLibraryDirectories) - true - $(OutDir)$(TargetName).pdb - false - Windows - true - true - true - UseLinkTimeCodeGeneration - MachineX86 - false - false + nvapi64.lib;amd_ags_$(PlatformShortName).lib;oalib.lib;opengl32.lib;glu32.lib;%(AdditionalDependencies) + $(xrExternals)OpenAutomate\libraries;$(xrExternals)nvapi\amd64;$(xrExternals)AGS_SDK\ags_lib\lib;%(AdditionalLibraryDirectories) - Full - AnySuitable - true - Speed - false - true $(xrExternals)OpenAutomate\inc;$(xrExternals)gl\include;$(xrExternals)glew\include;$(xrExternals)gli;$(xrExternals)gli\external\glm;$(xrExternals)AGS_SDK;%(AdditionalIncludeDirectories) - USE_OGL;NO_XR_VDECLARATOR;_USRDLL;XRRENDER_GL_EXPORTS;%(PreprocessorDefinitions) - true - MultiThreadedDLL - true - false - Precise - true - Use - Level4 - true - -Zm200 %(AdditionalOptions) + _USRDLL;XRRENDER_GL_EXPORTS;USE_OGL;NO_XR_VDECLARATOR;%(PreprocessorDefinitions) - LuaJIT.lib;luabind.lib;nvapi.lib;amd_ags_x86.lib;oalib.lib;opengl32.lib;glu32.lib;%(AdditionalDependencies) - $(xrExternals)OpenAutomate\libraries;$(xrExternals)nvapi\x86;$(xrExternals)luajit\bin\$(PlatformShortName);$(xrExternals)AGS_SDK\ags_lib\lib;%(AdditionalLibraryDirectories) - true - false - Windows - true - MachineX86 - false - false + nvapi.lib;amd_ags_$(PlatformShortName).lib;oalib.lib;opengl32.lib;glu32.lib;%(AdditionalDependencies) + $(xrExternals)OpenAutomate\libraries;$(xrExternals)nvapi\x86;$(xrExternals)AGS_SDK\ags_lib\lib;%(AdditionalLibraryDirectories) + + + + + $(xrExternals)OpenAutomate\inc;$(xrExternals)gl\include;$(xrExternals)glew\include;$(xrExternals)gli;$(xrExternals)gli\external\glm;$(xrExternals)AGS_SDK;%(AdditionalIncludeDirectories) + _USRDLL;XRRENDER_GL_EXPORTS;USE_OGL;NO_XR_VDECLARATOR;%(PreprocessorDefinitions) + + + nvapi64.lib;amd_ags_$(PlatformShortName).lib;oalib.lib;opengl32.lib;glu32.lib;%(AdditionalDependencies) + $(xrExternals)OpenAutomate\libraries;$(xrExternals)nvapi\amd64;$(xrExternals)AGS_SDK\ags_lib\lib;%(AdditionalLibraryDirectories) @@ -191,14 +157,7 @@ - - $(IntDir)%(Filename)1.obj - $(IntDir)%(Filename)1.obj - $(IntDir)%(Filename)1.obj - $(IntDir)%(Filename)1.xdc - $(IntDir)%(Filename)1.xdc - $(IntDir)%(Filename)1.xdc - + @@ -346,9 +305,7 @@ - Create - Create - Create + Create @@ -503,15 +460,15 @@ - {664e6f0d-6784-4760-9565-d54f8eb1edf4} + {296bb298-db4d-4545-987a-74584cfc1e27} - + {ccd4afae-aa10-42c6-a452-fdee497ccdf1} - + {632aeeb6-dc06-4e15-9551-b2b09a4b73c5} - + {61d4856f-fa82-4f02-bb88-909ddfb1fe74} diff --git a/src/Layers/xrRenderPC_R1/stdafx.h b/src/Layers/xrRenderPC_R1/stdafx.h index 103e2651193..8fe84d60dac 100644 --- a/src/Layers/xrRenderPC_R1/stdafx.h +++ b/src/Layers/xrRenderPC_R1/stdafx.h @@ -16,6 +16,7 @@ #include "Layers/xrRender/R_Backend.h" #include "Layers/xrRender/R_Backend_Runtime.h" +#define R_GL 0 #define R_R1 1 #define R_R2 2 #define R_R3 3 diff --git a/src/Layers/xrRenderPC_R2/r2.h b/src/Layers/xrRenderPC_R2/r2.h index 8f277a65038..3f081900038 100644 --- a/src/Layers/xrRenderPC_R2/r2.h +++ b/src/Layers/xrRenderPC_R2/r2.h @@ -10,7 +10,7 @@ #include "Layers/xrRender/WallmarksEngine.h" #include "smap_allocator.h" #include "Layers/xrRender/light_db.h" -#include "light_render_direct.h" +#include "Layers/xrRender/light_render_direct.h" #include "Layers/xrRender/LightTrack.h" #include "Layers/xrRender/r_sun_cascades.h" #include "xrEngine/IRenderable.h" diff --git a/src/Layers/xrRenderPC_R2/stdafx.h b/src/Layers/xrRenderPC_R2/stdafx.h index ee41ed6c06d..b713aad6173 100644 --- a/src/Layers/xrRenderPC_R2/stdafx.h +++ b/src/Layers/xrRenderPC_R2/stdafx.h @@ -17,6 +17,7 @@ #include "Layers/xrRender/R_Backend.h" #include "Layers/xrRender/R_Backend_Runtime.h" +#define R_GL 0 #define R_R1 1 #define R_R2 2 #define R_R3 3 diff --git a/src/Layers/xrRenderPC_R2/xrRender_R2.vcxproj b/src/Layers/xrRenderPC_R2/xrRender_R2.vcxproj index 9bb5eced2c0..0b55a1c3e1c 100644 --- a/src/Layers/xrRenderPC_R2/xrRender_R2.vcxproj +++ b/src/Layers/xrRenderPC_R2/xrRender_R2.vcxproj @@ -303,9 +303,9 @@ - - - + + + @@ -440,11 +440,11 @@ - - - - - + + + + + diff --git a/src/Layers/xrRenderPC_R2/xrRender_R2.vcxproj.filters b/src/Layers/xrRenderPC_R2/xrRender_R2.vcxproj.filters index 02242f7168b..2679866e743 100644 --- a/src/Layers/xrRenderPC_R2/xrRender_R2.vcxproj.filters +++ b/src/Layers/xrRenderPC_R2/xrRender_R2.vcxproj.filters @@ -207,16 +207,16 @@ Lights - + Lights Lights - + Lights - + Lights @@ -716,22 +716,22 @@ Lights - + Lights Lights - + Lights - + Lights - + Lights - + Lights diff --git a/src/Layers/xrRenderPC_R3/Light_Render_Direct.cpp b/src/Layers/xrRenderPC_R3/Light_Render_Direct.cpp deleted file mode 100644 index 5f6f1f7b2c1..00000000000 --- a/src/Layers/xrRenderPC_R3/Light_Render_Direct.cpp +++ /dev/null @@ -1,2 +0,0 @@ -#include "StdAfx.h" -#include "light_render_direct.h" diff --git a/src/Layers/xrRenderPC_R3/r3.h b/src/Layers/xrRenderPC_R3/r3.h index 939f8bdbfd7..6ab1f6d0abc 100644 --- a/src/Layers/xrRenderPC_R3/r3.h +++ b/src/Layers/xrRenderPC_R3/r3.h @@ -10,7 +10,7 @@ #include "Layers/xrRender/WallmarksEngine.h" #include "smap_allocator.h" #include "Layers/xrRender/light_db.h" -#include "light_render_direct.h" +#include "Layers/xrRender/light_render_direct.h" #include "Layers/xrRender/LightTrack.h" #include "Layers/xrRender/r_sun_cascades.h" #include "xrEngine/IRenderable.h" diff --git a/src/Layers/xrRenderPC_R3/r3_rendertarget.cpp b/src/Layers/xrRenderPC_R3/r3_rendertarget.cpp index 79de3573c35..dd92521be60 100644 --- a/src/Layers/xrRenderPC_R3/r3_rendertarget.cpp +++ b/src/Layers/xrRenderPC_R3/r3_rendertarget.cpp @@ -11,7 +11,7 @@ #include "blender_luminance.h" #include "blender_ssao.h" #include "blender_fxaa.h" -#include "dx10MinMaxSMBlender.h" +#include "Layers/xrRenderDX10/dx10MinMaxSMBlender.h" #include "Layers/xrRenderDX10/msaa/dx10MSAABlender.h" #include "Layers/xrRenderDX10/DX10 Rain/dx10RainBlender.h" #include diff --git a/src/Layers/xrRenderPC_R3/stdafx.h b/src/Layers/xrRenderPC_R3/stdafx.h index 9a98cfb5ba5..0fa1f4ffe2a 100644 --- a/src/Layers/xrRenderPC_R3/stdafx.h +++ b/src/Layers/xrRenderPC_R3/stdafx.h @@ -16,6 +16,7 @@ #include "Layers/xrRender/xrD3DDefs.h" #include "Layers/xrRender/Debug/dxPixEventWrapper.h" +#define R_GL 0 #define R_R1 1 #define R_R2 2 #define R_R3 3 diff --git a/src/Layers/xrRenderPC_R3/xrRender_R3.vcxproj b/src/Layers/xrRenderPC_R3/xrRender_R3.vcxproj index 1a16cc1c8f9..488862354c8 100644 --- a/src/Layers/xrRenderPC_R3/xrRender_R3.vcxproj +++ b/src/Layers/xrRenderPC_R3/xrRender_R3.vcxproj @@ -194,6 +194,7 @@ + @@ -322,10 +323,9 @@ - - - - + + + @@ -349,6 +349,7 @@ + @@ -484,12 +485,11 @@ - - - - - - + + + + + diff --git a/src/Layers/xrRenderPC_R3/xrRender_R3.vcxproj.filters b/src/Layers/xrRenderPC_R3/xrRender_R3.vcxproj.filters index 4a7682b626d..767de20a580 100644 --- a/src/Layers/xrRenderPC_R3/xrRender_R3.vcxproj.filters +++ b/src/Layers/xrRenderPC_R3/xrRender_R3.vcxproj.filters @@ -237,16 +237,16 @@ Lights - + Lights Lights - + Lights - + Lights @@ -309,7 +309,7 @@ Shading templates - + Shading templates @@ -809,22 +809,22 @@ Lights - + Lights Lights - + Lights - + Lights - + Lights - + Lights @@ -884,7 +884,7 @@ Shading templates - + Shading templates diff --git a/src/Layers/xrRenderPC_R4/Light_Render_Direct.cpp b/src/Layers/xrRenderPC_R4/Light_Render_Direct.cpp deleted file mode 100644 index 5f6f1f7b2c1..00000000000 --- a/src/Layers/xrRenderPC_R4/Light_Render_Direct.cpp +++ /dev/null @@ -1,2 +0,0 @@ -#include "StdAfx.h" -#include "light_render_direct.h" diff --git a/src/Layers/xrRenderPC_R4/r4.h b/src/Layers/xrRenderPC_R4/r4.h index 9b4bd45a53e..5ca67453c24 100644 --- a/src/Layers/xrRenderPC_R4/r4.h +++ b/src/Layers/xrRenderPC_R4/r4.h @@ -15,7 +15,7 @@ #include "smap_allocator.h" #include "Layers/xrRender/light_db.h" -#include "light_render_direct.h" +#include "Layers/xrRender/light_render_direct.h" #include "Layers/xrRender/LightTrack.h" #include "Layers/xrRender/r_sun_cascades.h" diff --git a/src/Layers/xrRenderPC_R4/stdafx.h b/src/Layers/xrRenderPC_R4/stdafx.h index 56121e96151..f78120ea906 100644 --- a/src/Layers/xrRenderPC_R4/stdafx.h +++ b/src/Layers/xrRenderPC_R4/stdafx.h @@ -16,6 +16,7 @@ #include "Layers/xrRender/xrD3DDefs.h" #include "Layers/xrRender/Debug/dxPixEventWrapper.h" +#define R_GL 0 #define R_R1 1 #define R_R2 2 #define R_R3 3 diff --git a/src/Layers/xrRenderPC_R4/xrRender_R4.vcxproj b/src/Layers/xrRenderPC_R4/xrRender_R4.vcxproj index 152d4fecde9..3d7c85301d4 100644 --- a/src/Layers/xrRenderPC_R4/xrRender_R4.vcxproj +++ b/src/Layers/xrRenderPC_R4/xrRender_R4.vcxproj @@ -328,9 +328,9 @@ - - - + + + @@ -494,11 +494,11 @@ - - - - - + + + + + diff --git a/src/Layers/xrRenderPC_R4/xrRender_R4.vcxproj.filters b/src/Layers/xrRenderPC_R4/xrRender_R4.vcxproj.filters index 12bcd9f76fc..b093e40522e 100644 --- a/src/Layers/xrRenderPC_R4/xrRender_R4.vcxproj.filters +++ b/src/Layers/xrRenderPC_R4/xrRender_R4.vcxproj.filters @@ -243,16 +243,16 @@ Lights - + Lights Lights - + Lights - + Lights @@ -830,22 +830,22 @@ Lights - + Lights Lights - + Lights - + Lights - + Lights - + Lights diff --git a/src/engine.sln b/src/engine.sln index 198cace251b..c019c1c27d3 100644 --- a/src/engine.sln +++ b/src/engine.sln @@ -244,6 +244,9 @@ EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tbbmalloc", "..\Externals\tbbmalloc.vcxproj", "{B15F131E-328A-4D42-ADC2-9FF4CA6306D8}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tbbmalloc_proxy", "..\Externals\tbbmalloc_proxy.vcxproj", "{02F61511-D5B6-46E6-B4BB-DEAA96E6BCC7}" +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "xrRender_GL", "Layers\xrRenderPC_GL\xrRender_GL.vcxproj", "{2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "glew", "..\Externals\glew.vcxproj", "{296BB298-DB4D-4545-987A-74584CFC1E27}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -1113,6 +1116,30 @@ Global {02F61511-D5B6-46E6-B4BB-DEAA96E6BCC7}.Release|x64.Build.0 = Release|x64 {02F61511-D5B6-46E6-B4BB-DEAA96E6BCC7}.Release|x86.ActiveCfg = Release|Win32 {02F61511-D5B6-46E6-B4BB-DEAA96E6BCC7}.Release|x86.Build.0 = Release|Win32 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Debug|x64.ActiveCfg = Debug|x64 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Debug|x64.Build.0 = Debug|x64 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Debug|x86.ActiveCfg = Debug|Win32 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Debug|x86.Build.0 = Debug|Win32 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Mixed|x64.ActiveCfg = Mixed|x64 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Mixed|x64.Build.0 = Mixed|x64 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Mixed|x86.ActiveCfg = Mixed|Win32 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Mixed|x86.Build.0 = Mixed|Win32 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Release|x64.ActiveCfg = Release|x64 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Release|x64.Build.0 = Release|x64 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Release|x86.ActiveCfg = Release|Win32 + {2C5AF8C8-96A6-45B2-860B-5E9C9911DDD6}.Release|x86.Build.0 = Release|Win32 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Debug|x64.ActiveCfg = Debug|x64 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Debug|x64.Build.0 = Debug|x64 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Debug|x86.ActiveCfg = Debug|Win32 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Debug|x86.Build.0 = Debug|Win32 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Mixed|x64.ActiveCfg = Release|x64 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Mixed|x64.Build.0 = Release|x64 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Mixed|x86.ActiveCfg = Release|Win32 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Mixed|x86.Build.0 = Release|Win32 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Release|x64.ActiveCfg = Release|x64 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Release|x64.Build.0 = Release|x64 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Release|x86.ActiveCfg = Release|Win32 + {296BB298-DB4D-4545-987A-74584CFC1E27}.Release|x86.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -1186,6 +1213,7 @@ Global {F62787DD-1327-448B-9818-030062BCFAA5} = {2BFC806B-CE92-4EA4-8FE8-5F2EA54BA348} {B15F131E-328A-4D42-ADC2-9FF4CA6306D8} = {2BFC806B-CE92-4EA4-8FE8-5F2EA54BA348} {02F61511-D5B6-46E6-B4BB-DEAA96E6BCC7} = {2BFC806B-CE92-4EA4-8FE8-5F2EA54BA348} + {296BB298-DB4D-4545-987A-74584CFC1E27} = {2BFC806B-CE92-4EA4-8FE8-5F2EA54BA348} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {C5A32302-94F5-41B8-9606-017BB6BA69A6} diff --git a/src/xrEngine/EngineAPI.cpp b/src/xrEngine/EngineAPI.cpp index 76709566808..8ddaff1a847 100644 --- a/src/xrEngine/EngineAPI.cpp +++ b/src/xrEngine/EngineAPI.cpp @@ -24,6 +24,7 @@ CEngineAPI::CEngineAPI() hRenderR2 = nullptr; hRenderR3 = nullptr; hRenderR4 = nullptr; + hRenderRGL = nullptr; pCreate = nullptr; pDestroy = nullptr; tune_enabled = false; @@ -47,6 +48,20 @@ void CEngineAPI::SetupCurrentRenderer() { GEnv.CurrentRenderer = -1; + if (psDeviceFlags.test(rsRGL)) + { + if (hRenderRGL->exist()) + { + GEnv.CurrentRenderer = 5; + GEnv.SetupCurrentRenderer = GEnv.SetupRGL; + } + else + { + psDeviceFlags.set(rsRGL, false); + psDeviceFlags.set(rsR4, true); + } + } + if (psDeviceFlags.test(rsR4)) { if (hRenderR4->exist()) @@ -125,7 +140,10 @@ void CEngineAPI::InitializeRenderers() // Now unload unused renderers // XXX: Unloading disabled due to typeids invalidation - /*if (GEnv.CurrentRenderer != 4) + /*if (GEnv.CurrentRenderer != 5) + hRenderRGL->close(); + + if (GEnv.CurrentRenderer != 4) hRenderR4->close(); if (GEnv.CurrentRenderer != 3) @@ -180,6 +198,7 @@ void CEngineAPI::Destroy(void) hRenderR2 = nullptr; hRenderR3 = nullptr; hRenderR4 = nullptr; + hRenderRGL = nullptr; pCreate = nullptr; pDestroy = nullptr; Engine.Event._destroy(); @@ -209,6 +228,7 @@ void CEngineAPI::CreateRendererList() hRenderR2 = XRay::LoadModule("xrRender_R2"); hRenderR3 = XRay::LoadModule("xrRender_R3"); hRenderR4 = XRay::LoadModule("xrRender_R4"); + hRenderRGL = XRay::LoadModule("xrRender_GL"); // Restore error handling SetErrorMode(0); @@ -241,6 +261,14 @@ void CEngineAPI::CreateRendererList() else hRenderR4->close(); } + + if (hRenderRGL->exist()) + { + if (GEnv.CheckRGL && GEnv.CheckRGL()) + modes.push_back(xr_token("renderer_gl", 6)); + else + hRenderRGL->close(); + } modes.push_back(xr_token(nullptr, -1)); Msg("Available render modes[%d]:", modes.size()); diff --git a/src/xrEngine/EngineAPI.h b/src/xrEngine/EngineAPI.h index 0bf07a1c518..f1098bdb703 100644 --- a/src/xrEngine/EngineAPI.h +++ b/src/xrEngine/EngineAPI.h @@ -52,6 +52,7 @@ class ENGINE_API CEngineAPI XRay::Module hRenderR2; XRay::Module hRenderR3; XRay::Module hRenderR4; + XRay::Module hRenderRGL; public: BENCH_SEC_SCRAMBLEMEMBER1 diff --git a/src/xrEngine/defines.h b/src/xrEngine/defines.h index af1a9f8b7c7..57899a8c890 100644 --- a/src/xrEngine/defines.h +++ b/src/xrEngine/defines.h @@ -38,8 +38,9 @@ enum rsR1 = (1ul << 19ul), rsR2 = (1ul << 20ul), rsR3 = (1ul << 21ul), - rsR4 = (1ul << 22ul), // 22 was reserved for editor too - // 23-32 bit - reserved to Editor + rsR4 = (1ul << 22ul), // 22 was reserved for editor + rsRGL = (1ul << 23ul), // 23 was reserved for editor + // 24-32 bit - reserved to Editor }; //. ENGINE_API extern u32 psCurrentMode ; diff --git a/src/xrEngine/main.cpp b/src/xrEngine/main.cpp index d0224f35d7b..2f5e42e9e16 100644 --- a/src/xrEngine/main.cpp +++ b/src/xrEngine/main.cpp @@ -391,7 +391,9 @@ int RunApplication(pcstr commandLine) if (!GEnv.isDedicatedServer) { - if (strstr(Core.Params, "-r4")) + if (strstr(Core.Params, "-gl")) + Console->Execute("renderer renderer_gl"); + else if (strstr(Core.Params, "-r4")) Console->Execute("renderer renderer_r4"); else if (strstr(Core.Params, "-r3")) Console->Execute("renderer renderer_r3"); @@ -401,6 +403,8 @@ int RunApplication(pcstr commandLine) Console->Execute("renderer renderer_r2a"); else if (strstr(Core.Params, "-r2")) Console->Execute("renderer renderer_r2"); + else if (strstr(Core.Params, "-r1")) + Console->Execute("renderer renderer_r1"); else { CCC_LoadCFG_custom cmd("renderer "); diff --git a/src/xrEngine/xrSASH.cpp b/src/xrEngine/xrSASH.cpp index 825a5ee8f37..6e62be0c5c7 100644 --- a/src/xrEngine/xrSASH.cpp +++ b/src/xrEngine/xrSASH.cpp @@ -464,7 +464,15 @@ void xrSASH::TryInitEngine(bool bNoRun) xr_strcpy(Console->ConfigFile, c_name); } - if (strstr(Core.Params, "-r2a")) + if (strstr(Core.Params, "-gl")) + Console->Execute("renderer renderer_gl"); + else if (strstr(Core.Params, "-r4")) + Console->Execute("renderer renderer_r4"); + else if (strstr(Core.Params, "-r3")) + Console->Execute("renderer renderer_r3"); + else if (strstr(Core.Params, "-r2.5")) + Console->Execute("renderer renderer_r2.5"); + else if (strstr(Core.Params, "-r2a")) Console->Execute("renderer renderer_r2a"); else if (strstr(Core.Params, "-r2")) Console->Execute("renderer renderer_r2"); diff --git a/src/xrEngine/xr_ioc_cmd.cpp b/src/xrEngine/xr_ioc_cmd.cpp index 7dc292c63c0..5669361ff2c 100644 --- a/src/xrEngine/xr_ioc_cmd.cpp +++ b/src/xrEngine/xr_ioc_cmd.cpp @@ -544,10 +544,12 @@ class CCC_r2 : public CCC_Token // 1..3 - r2 // 4 - r3 // 5 - r4 + // 6 - rgl psDeviceFlags.set(rsR1, renderer_value == 0); psDeviceFlags.set(rsR2, ((renderer_value > 0) && renderer_value < 4)); psDeviceFlags.set(rsR3, (renderer_value == 4)); - psDeviceFlags.set(rsR4, (renderer_value >= 5)); + psDeviceFlags.set(rsR4, (renderer_value == 5)); + psDeviceFlags.set(rsRGL, (renderer_value == 6)); r2_sun_static = (renderer_value < 2);