-added some point lights with light volume to the demo

-changed with point light shader

Author: Alin

example/ThreadedRenderingGL/Commands.cpp

@@ -108,7 +108,6 @@ namespace cmds
 		glBindTexture(GL_TEXTURE_2D, cmd.skyboxSandTex);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
 
-		glDisable(GL_CULL_FACE);
 		cmd.shader->enable();
 		glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 		cmd.shader->disable();

example/ThreadedRenderingGL/ThreadedRenderingGL.cpp

@@ -74,6 +74,7 @@ class ThreadedRenderingGL : public NvSampleAppGL
 
 	enum {
 		MAX_ANIMATION_THREAD_COUNT = 8,
+		MAX_LIGHTS_COUNT = 64,
 		MAX_THREAD_COUNT = MAX_ANIMATION_THREAD_COUNT + 1,
 		THREAD_STACK_SIZE = 8192U
 	};
@@ -153,8 +154,16 @@ class ThreadedRenderingGL : public NvSampleAppGL
 		nv::vec4f m_lightPosition;
 		nv::vec4f m_lightAmbient;
 		nv::vec4f m_lightDiffuse;
-		float m_causticOffset;
-		float m_causticTiling;
+		union
+		{
+			float m_causticOffset;
+			float m_linearAttenuation;
+		};
+		union
+		{
+			float m_causticTiling;
+			float m_quadraticAttenuation;
+		};
 	};
 
 	/// Book-keeping structure holding data pertinent to a thread
@@ -245,6 +254,7 @@ class ThreadedRenderingGL : public NvSampleAppGL
 	uint32_t setNumSchools(uint32_t numSchools);
 	void updateSchoolTankSizes();
 	uint32_t setAnimationThreadNum(uint32_t numThreads);
+	uint32_t setNumLights(uint32_t numLights);
 
 	/// Updates the stats displayed by the UI
 	void updateStats();
@@ -338,6 +348,7 @@ class ThreadedRenderingGL : public NvSampleAppGL
 	NvGLSLProgram* m_shader_Skybox;
 	NvGLSLProgram* m_shader_Fish;
 	NvGLSLProgram* m_shader_DirectionalLight;
+	NvGLSLProgram* m_shader_PointLight;
 
 	BRDF m_brdf;
 
@@ -383,6 +394,11 @@ class ThreadedRenderingGL : public NvSampleAppGL
 	GLuint      m_lightingUBO_Id;         // UBO Id
 	GLint       m_lightingUBO_Location;   // Uniform Index
 
+
+	LightingUBO         m_lightsUBO_Data[MAX_LIGHTS_COUNT];
+	std::vector<int>    m_lightsSchoolIndex;      
+	GLuint              m_lightsUBO_Id[MAX_LIGHTS_COUNT];     
+
 	// define the volume that the fish will remain within
 	static nv::vec3f ms_tankMin;
 	static nv::vec3f ms_tankMax;
@@ -474,6 +490,7 @@ class ThreadedRenderingGL : public NvSampleAppGL
 	typedef std::vector<School*> SchoolSet;
 	SchoolSet m_schools;
 	std::vector<uint32_t> m_schoolsDrawCount;
+	std::vector<nv::vec3f> m_schoolsCentroid;
 	uint32_t m_activeSchools;
 
 	// Scene wide and background shared textures
@@ -539,18 +556,21 @@ class ThreadedRenderingGL : public NvSampleAppGL
 		, UIACTION_RESET_FISHPLOSION
 		, UIACTION_RESET_FISHFIREWORKS
 		, UIACTION_ANIMTHREADCOUNT
+		, UIACTION_LIGHTSCOUNT
 		, UIACTION_ANIMPAUSED
 		, UIACTION_INSTCOUNT
 		, UIACTION_BATCHSIZE
 		, UIACTION_STATSTOGGLE
 		, UIACTION_RENDERINGTECHNIQUE
 		, UIACTION_TANKSIZE
+		, UIACTION_UIBRDF
 	};
 
 	uint32_t m_uiSchoolCount;
 	uint32_t m_uiFishCount;
 	uint32_t m_uiTankSize;
 	bool     m_bTankSizeChanged;
+	uint32_t m_uiLightsCount;
 	uint32_t m_uiThreadCount;
 	uint32_t m_uiInstanceCount;
 	uint32_t m_uiBatchSize;
@@ -679,8 +699,10 @@ class ThreadedRenderingGL : public NvSampleAppGL
 
 			glEnable(GL_DEPTH_TEST);
 			glDepthMask(GL_TRUE);
-			glEnable(GL_STENCIL_TEST);
+			glDisable(GL_STENCIL_TEST);
 			glDisable(GL_BLEND);
+			glDisable(GL_CULL_FACE);
+			glCullFace(GL_BACK);
 		}
 	};
 
@@ -715,7 +737,7 @@ class ThreadedRenderingGL : public NvSampleAppGL
 		}
 	};
 
-	// Setups a new frame
+	// Setups the deferred pass
 	struct BeginDeferredCommand
 	{
 		static const cb::RenderContext::function_t kDispatchFunction;
@@ -728,10 +750,37 @@ class ThreadedRenderingGL : public NvSampleAppGL
 
 			glBindFramebuffer(GL_FRAMEBUFFER, cmd.mainFboId);
 
-			glClearDepth(1.0f);
-			glClearStencil(0);
+			glClear(GL_COLOR_BUFFER_BIT);
+
+			glDisable(GL_DEPTH_TEST);
+			glDisable(GL_STENCIL_TEST);
+			glDepthMask(GL_FALSE);
+		}
+	};
+
+	struct BeginPointLightPassCommand
+	{
+		static const cb::RenderContext::function_t kDispatchFunction;
+
+		uint32_t dummy;
+
+		static void execute(const void* data, cb::RenderContext* rc)
+		{
+			auto& cmd = *reinterpret_cast<const BeginPointLightPassCommand*>(data);
+
+			glEnable(GL_BLEND);
+			glBlendEquation(GL_FUNC_ADD);
+			glBlendFunc(GL_ONE, GL_ONE);
+
+			glEnable(GL_STENCIL_TEST);
+			glDisable(GL_CULL_FACE); 
+
 			glStencilMask(0xFF);
-			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+			glClearStencil(0);
+
+			// we'll render the light volume faces once per light
+			glStencilFunc(GL_EQUAL, 0, 0xFF);
+			glStencilOp(GL_KEEP, GL_INCR, GL_INCR);
 		}
 	};
 
@@ -754,6 +803,26 @@ class ThreadedRenderingGL : public NvSampleAppGL
 		static void execute(const void* data, cb::RenderContext* rc);
 	};
 
+	struct DrawPointLightCommand
+	{
+		static const cb::RenderContext::function_t kDispatchFunction;
+		// hint that we dont care about ctr/dtr
+		typedef void pod_hint_tag;
+
+		GLuint projUBO_Location;
+		GLuint projUBO_Id;
+		GLuint lightingUBO_Location;
+		GLuint lightingUBO_Id;
+		LightingUBO lightingUBO_Data;
+		NvGLSLProgram* shader;
+		GLuint texGBuffer[GBUFFER_COUNT];
+		uint32_t brdf;
+
+		nv::matrix4f MVP;
+
+		static void execute(const void* data, cb::RenderContext* rc);
+	};
+
 	GeometryCommandBuffer m_geometryCommands;
 	DeferredCommandBuffer m_deferredCommands;
 

example/ThreadedRenderingGL/ThreadedRenderingGL.h

@@ -211,7 +211,7 @@
     </ClCompile>
     <Link>
       <AdditionalOptions>/DEBUG /MACHINE:x86 /LARGEADDRESSAWARE /NOLOGO /OPT:REF /OPT:ICF /INCREMENTAL:NO</AdditionalOptions>
-      <AdditionalDependencies>xinput9_1_0.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;opengl32.lib;glew32sd.lib;glfw3d.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>xinput9_1_0.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;opengl32.lib;glew32sd.lib;glfw3d.lib;glu32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)ThreadedRenderingGLD.exe</OutputFile>
       <AdditionalLibraryDirectories>./../GraphicsSamples/extensions/externals/lib/vs2015x86;./../GraphicsSamples/extensions/lib/vs2015x86;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <ProgramDatabaseFile>$(OutDir)/ThreadedRenderingGLD.exe.pdb</ProgramDatabaseFile>
@@ -450,7 +450,7 @@
     <ClInclude Include="VertexFormatBinder.h" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="assets\src_shaders\DirectionalLighting_FS.glsl" />
+    <None Include="assets\src_shaders\Lighting_FS.glsl" />
     <None Include="assets\src_shaders\Lighting_VS.glsl" />
     <None Include="assets\src_shaders\groundplane_FS.glsl" />
     <None Include="assets\src_shaders\groundplane_VS.glsl" />

example/ThreadedRenderingGL/ThreadedRenderingGL.vcxproj

@@ -83,9 +83,6 @@
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
-    <None Include="assets\src_shaders\DirectionalLighting_FS.glsl">
-      <Filter>src_shaders</Filter>
-    </None>
     <None Include="assets\src_shaders\Lighting_VS.glsl">
       <Filter>src_shaders</Filter>
     </None>
@@ -107,5 +104,8 @@
     <None Include="assets\src_shaders\groundplane_FS.glsl">
       <Filter>src_shaders</Filter>
     </None>
+    <None Include="assets\src_shaders\Lighting_FS.glsl">
+      <Filter>src_shaders</Filter>
+    </None>
   </ItemGroup>
 </Project>

example/ThreadedRenderingGL/ThreadedRenderingGL.vcxproj.filters

@@ -51,9 +51,14 @@ layout(binding=0) uniform ProjBlock {
 layout(binding=1) uniform LightingBlock {
 	vec4 u_vLightPosition;  
 	vec4 u_vLightAmbient;   
-	vec4 u_vLightDiffuse;   
+	vec4 u_vLightDiffuse;  
+#ifdef USE_POINT_LIGHT
+	float u_fLinearAttenuation;
+	float u_fQuadraticAttenuation;
+#else
 	float u_fCausticOffset;
 	float u_fCausticTiling;
+#endif
 };
 
 void main(void)
@@ -81,7 +86,14 @@ void main(void)
     if (normLength > 0.0)
     {
         vec3 normal = worldNormal / normLength;
-        vec3 dirToLight = normalize(u_vLightPosition.xyz);
+#ifdef USE_POINT_LIGHT
+        vec3 dirToLight = worldPos - u_vLightPosition.xyz;
+		float distance = length(dirToLight);
+		dirToLight = dirToLight / distance;
+#else
+		// directional light
+		vec3 dirToLight = normalize(u_vLightPosition.xyz);
+#endif
         vec3 lightAmbient = u_vLightAmbient.rgb;
         vec3 lightColor = u_vLightDiffuse.rgb;
         switch (uLightingModel)
@@ -95,11 +107,26 @@ void main(void)
 			color += max(0.0, GGX(dirToLight, toEyeVector, normal, roughness, 0.6));
             break;
         }
+
+#ifdef USE_POINT_LIGHT
+		float Kc = 1.0;
+		float Kl = u_fLinearAttenuation;
+		float Kd = u_fQuadraticAttenuation;
+		float attenuation = Kc + Kl * distance + Kd * distance * distance;
+		attenuation = max(1.0, attenuation);
+		color /= attenuation;
+#endif
+
     }
     else
     {
-        // No geometry rendered, so use just the color
-        color = mtlColor;
+#ifdef USE_POINT_LIGHT
+		color = vec3(0.0);
+#else
+		// No geometry rendered, so use just the color
+        color = mtlColor * u_vLightAmbient.rgb * 1.5;
+#endif
     }
-    outColor = vec4(color, 1.0);
+	 
+	outColor = vec4(color, 1.0);
 }

example/ThreadedRenderingGL/assets/src_shaders/DirectionalLighting_FS.glsl renamed to example/ThreadedRenderingGL/assets/src_shaders/Lighting_FS.glsl

@@ -44,17 +44,16 @@ vec3 LambertDiffuse(vec3 dirToLight, vec3 surfaceNormal, vec3 ambientColor, vec3
 
 float GGX(vec3 L, vec3 V, vec3 N, float roughness, float F0)
 {
-
-	float alpha = roughness * roughness;
+	float roughSqr = roughness * roughness;
 	vec3 H = normalize(L - V);
 	float dotLH = max(0.0, dot(L, H));
 	float dotNH = max(0.0, dot(N, H));
 	float dotNL = max(0.0, dot(N, L));
-	float alphaSqr = alpha * alpha;
+	float alphaSqr = roughSqr * roughSqr;
 	float denom = dotNH * dotNH * (alphaSqr - 1.0) + 1.0;
 	float D = alphaSqr / (3.141592653589793 * denom * denom);
 	float F = F0 + (1.0 - F0) * pow(1.0 - dotLH, 5.0);
-	float k = 0.5 * alpha;
+	float k = 0.5 * roughSqr;
 	float k2 = k * k;
 	return dotNL * D * F / (dotLH*dotLH*(1.0 - k2) + k2);
 }
@@ -83,10 +82,11 @@ vec3 OrenNayar(vec3 dirToLight, vec3 dirToEye, vec3 surfaceNormal, vec3 lightCol
     vec3 projEye = normalize(dirToEye - (surfaceNormal * clamp(dot(dirToEye, surfaceNormal), 0.0, 1.0)));        // approaches ||0,0,0|| , 
 
     float gamma = dot(projEye, projLight);
-    float roughSqr = roughness * roughness;
 
-    float A = 1.0 - (0.5 * (roughSqr / (roughSqr + 0.57)));
-    float B = 0.45 * (roughSqr / (roughSqr + 0.09));
+    float alphaSqr = 1.0 - roughness * roughness;
+
+    float A = 1.0 - (0.5 * (alphaSqr / (alphaSqr + 0.57)));
+    float B = 0.45 * (alphaSqr / (alphaSqr + 0.09));
     float C = clamp(sin(alpha), 0.0, 1.0) * max(0.0, tan(beta));
 
     float final = A + B * max(0.0, gamma) * C;

example/ThreadedRenderingGL/assets/src_shaders/Lighting_FS_Shared.h

@@ -42,6 +42,6 @@ uniform mat4 uModelViewMatrix;
 
 void main(void)
 {
-    outProjPos = inVertexPosition;
-    gl_Position = uModelViewMatrix * inVertexPosition;
+    outProjPos = uModelViewMatrix * inVertexPosition;
+    gl_Position = outProjPos;
 }

example/ThreadedRenderingGL/assets/src_shaders/Lighting_VS.glsl

@@ -93,8 +93,8 @@ void main()
     outDiffuseRoughness.rgb += vec3(getCausticIntensity(v_vPosWorldSpace));
     float fog = fogIntensity(length(v_vPosEyeSpace.xyz));
     outDiffuseRoughness.rgb = mix(outDiffuseRoughness.rgb, g_fogColor, fog);
-	outDiffuseRoughness.a = 0.5;
-	
+	outDiffuseRoughness.a = 0.25;
+
 	outNormalDepth.xyz = normalize(v_vNormalWorldSpace);
     outNormalDepth.w = v_vPosEyeSpace.z / 100.0;
 }

example/ThreadedRenderingGL/assets/src_shaders/staticfish_FS.glsl

@@ -0,0 +1,25 @@
+Copyright 2016 NVIDIA Corporation
+
+BY DOWNLOADING THE SOFTWARE AND OTHER AVAILABLE MATERIALS, YOU  ("DEVELOPER") AGREE TO BE BOUND BY THE FOLLOWING TERMS AND CONDITIONS
+
+The materials available for download to Developers may include software in both sample source ("Source Code") and object code ("Object Code") versions, documentation ("Documentation"), certain art work ("Art Assets") and other materials (collectively, these materials referred to herein as "Materials").  Except as expressly indicated herein, all terms and conditions of this Agreement apply to all of the Materials.
+
+Except as expressly set forth herein, NVIDIA owns all of the Materials and makes them available to Developer only under the terms and conditions set forth in this Agreement.
+
+License:  Subject to the terms of this Agreement, NVIDIA hereby grants to Developer a royalty-free, non-exclusive license to possess and to use the Materials.  The following terms apply to the specified type of Material:
+
+Source Code:  Developer shall have the right to modify and create derivative works with the Source Code.  Developer shall own any derivative works ("Derivatives") it creates to the Source Code, provided that Developer uses the Materials in accordance with the terms of this Agreement.  Developer may distribute the Derivatives, provided that all NVIDIA copyright notices and trademarks are used properly and the Derivatives include the following statement: "This software contains source code provided by NVIDIA Corporation."  
+
+Object Code:  Developer agrees not to disassemble, decompile or reverse engineer the Object Code versions of any of the Materials.  Developer acknowledges that certain of the Materials provided in Object Code version may contain third party components that may be subject to restrictions, and expressly agrees not to attempt to modify or distribute such Materials without first receiving consent from NVIDIA.
+
+Art Assets:  Developer shall have the right to modify and create Derivatives of the Art Assets, but may not distribute any of the Art Assets or Derivatives created therefrom without NVIDIA�s prior written consent.
+
+Government End Users: If you are acquiring the Software on behalf of any unit or agency of the United States Government, the following provisions apply. The Government agrees the Software and documentation were developed at private expense and are provided with �RESTRICTED RIGHTS�. Use, duplication, or disclosure by the Government is subject to restrictions as set forth in DFARS 227.7202-1(a) and 227.7202-3(a) (1995), DFARS 252.227-7013(c)(1)(ii) (Oct 1988), FAR 12.212(a)(1995), FAR 52.227-19, (June 1987) or FAR 52.227-14(ALT III) (June 1987),as amended from time to time. In the event that this License, or any part thereof, is deemed inconsistent with the minimum rights identified in the Restricted Rights provisions, the minimum rights shall prevail.
+No Other License. No rights or licenses are granted by NVIDIA under this License, expressly or by implication, with respect to any proprietary information or patent, copyright, trade secret or other intellectual property right owned or controlled by NVIDIA, except as expressly provided in this License.
+Term:  This License is effective until terminated.  NVIDIA may terminate this Agreement (and with it, all of Developer�s right to the Materials) immediately upon written notice (which may include email) to Developer, with or without cause.
+
+Support:  NVIDIA has no obligation to support or to continue providing or updating any of the Materials.
+
+No Warranty:  THE SOFTWARE AND ANY OTHER MATERIALS PROVIDED BY NVIDIA TO DEVELOPER HEREUNDER ARE PROVIDED "AS IS."  NVIDIA DISCLAIMS ALL WARRANTIES, EXPRESS, IMPLIED OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+LIMITATION OF LIABILITY:  NVIDIA SHALL NOT BE LIABLE TO DEVELOPER, DEVELOPER�S CUSTOMERS, OR ANY OTHER PERSON OR ENTITY CLAIMING THROUGH OR UNDER DEVELOPER FOR ANY LOSS OF PROFITS, INCOME, SAVINGS, OR ANY OTHER CONSEQUENTIAL, INCIDENTAL, SPECIAL, PUNITIVE, DIRECT OR INDIRECT DAMAGES (WHETHER IN AN ACTION IN CONTRACT, TORT OR BASED ON A WARRANTY), EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF THE ESSENTIAL PURPOSE OF ANY LIMITED REMEDY.  IN NO EVENT SHALL NVIDIA�S AGGREGATE LIABILITY TO DEVELOPER OR ANY OTHER PERSON OR ENTITY CLAIMING THROUGH OR UNDER DEVELOPER EXCEED THE AMOUNT OF MONEY ACTUALLY PAID BY DEVELOPER TO NVIDIA FOR THE SOFTWARE OR ANY OTHER MATERIALS.