Adding a new effect: Ground light

CMakeLists.txt

@@ -85,13 +85,26 @@ ENDIF()
 OPTION(ANKI_STRIP "Srip the symbols from the executables" OFF)
 IF(ANKI_STRIP)
 	MESSAGE("++ Stipping: true")
-	SET(CMAKE_CXX_FLAGS " -s ")
-	SET(CMAKE_C_FLAGS " -s ")
-	SET(CMAKE_EXE_LINKER_FLAGS " -s ")
+	SET(FLAGS " -s ")
+
+	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAGS}")
+	SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FLAGS}")
+	SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${FLAGS}")
 ELSE()
 	MESSAGE("++ Stipping: false")
 ENDIF()
 
+# gperftools
+OPTION(ANKI_WITH_GPERFTOOLS_PROF "Link with gperftools profiler" OFF)
+IF(ANKI_WITH_GPERFTOOLS_PROF)
+	LINK_DIRECTORIES("/home/godlike/src/more/gperftools/install/lib")
+	SET(ANKI_GPERFTOOLS_LIBS "profiler")
+	MESSAGE("++ gperftools profiler: true")
+ELSE()
+	SET(ANKI_GPERFTOOLS_LIBS "")
+	MESSAGE("++ gperftools profiler: false")
+ENDIF()
+
 #
 # Install
 #
@@ -151,18 +164,10 @@ INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/anki/Config.h" DESTINATION "${INCLUDE
 ADD_DEFINITIONS("-Dthread_local=__thread")
 
 #
-# Compiler flags
+# AnKi compiler flags
 #
 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic-errors -pedantic -ansi -Wall -W -Wextra -Wwrite-strings -Wno-unused -Wundef -Wunused-variable -Werror -msse4 -std=c++11")
 
-IF(CMAKE_BUILD_TYPE STREQUAL Debug)
-	# Removed because they do not work with boost::regexpr and who knows what
-	# else
-	#ADD_DEFINITIONS("-D_GLIBCXX_DEBUG -D_GLIBXX_DEBUG_PEDANTIC")
-ELSE()
-	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mtune=core2 -ffast-math ")
-ENDIF()
-
 #
 # Include & lib directories
 #

include/anki/renderer/Is.h

@@ -88,6 +88,11 @@ private:
 	Bool drawToDefaultFbo;
 	U32 width, height;
 
+	/// If enabled the ground emmits a light
+	Bool groundLightEnabled;
+	/// Keep the prev light dir to avoid uniform block updates
+	Vec3 prevGroundLightDir = Vec3(0.0);
+
 	/// Called by init
 	void initInternal(const RendererInitializer& initializer);
 

include/anki/renderer/Renderer.h

@@ -44,6 +44,7 @@ struct RendererInitializer
 			U32 maxLights = 4;
 		} sm;
 		Bool drawToDefaultFbo = false;
+		Bool groundLightEnabled = true;
 	} is;
 
 	// Pps

include/anki/scene/Spatial.h

@@ -25,7 +25,10 @@ public:
 	enum SpatialFlag
 	{
 		SF_NONE = 0,
-		SF_VISIBLE = 1 ///< Visible or not. The visibility tester sets it
+		SF_VISIBLE_CAMERA = 1 << 1,
+		SF_VISIBLE_LIGHT = 1 << 2,
+		/// Visible or not. The visibility tester sets it
+		SF_VISIBLE_ANY = SF_VISIBLE_CAMERA | SF_VISIBLE_LIGHT
 	};
 
 	/// Pass the collision shape here so we can avoid the virtuals

shaders/IsLpGeneric.glsl

@@ -33,6 +33,8 @@ layout(std140, row_major, binding = 0) uniform commonBlock
 	uniform vec4 limitsOfNearPlane_;
 
 	uniform vec4 sceneAmbientColor;
+
+	uniform vec4 groundLightDir;
 };
 
 #define planes nearPlanes.zw
@@ -295,6 +297,11 @@ void main()
 		}
 	}
 
+
+#if GROUND_LIGHT
+	fColor *= dot(normal, groundLightDir.xyz) + 1.0;
+#endif
+
 #if 0
 	if(tiles[vInstanceId].lightsCount[2] > 0)
 	{
@@ -324,6 +331,6 @@ void main()
 #if 0
 	vec3 tmpc = vec3((vInstanceId % 4) / 3.0, (vInstanceId % 3) / 2.0, 
 		(vInstanceId % 2));
-	fColor += tmpc / 50.0;
+	fColor += tmpc / 40.0;
 #endif
 }

shaders/Pps.glsl

@@ -69,7 +69,7 @@ void main(void)
 #if 0
 	if(fColor.r != 0.00000001)
 	{
-		fColor = hdr;
+		fColor = vec3(ssao);
 	}
 #endif
 }

shaders/PpsSsao.glsl

@@ -45,7 +45,7 @@ uniform sampler2D noiseMap;
 #define SAMPLE_RAD 0.08
 #define SCALE 1.0
 #define INTENSITY 3.0
-#define BIAS 0.00
+#define BIAS 0.0
 
 vec3 getNormal(in vec2 uv)
 {
@@ -56,8 +56,8 @@ vec3 getNormal(in vec2 uv)
 
 vec2 getRandom(in vec2 uv)
 {
-	vec2 noise = texture2D(noiseMap, 
-		vec2(WIDTH, HEIGHT) * uv / NOISE_MAP_SIZE / 2.0).xy;
+	vec2 noise = texture2D(
+		noiseMap, vec2(WIDTH, HEIGHT) * uv / NOISE_MAP_SIZE / 2.0).xy;
 	return normalize(noise * 2.0 - 1.0);
 }
 
@@ -83,7 +83,7 @@ float calcAmbientOcclusionFactor(in vec2 uv, in vec3 original, in vec3 cnorm)
 	vec3 v = normalize(diff);
 	float d = length(diff) /* * SCALE*/;
 
-	float ret = max(0.0, dot(cnorm, v) /* - BIAS*/) * (INTENSITY / (1.0 + d));
+	float ret = max(0.0, dot(cnorm, v)  - BIAS) * (INTENSITY / (1.0 + d));
 	return ret;
 }
 

src/CMakeLists.txt

@@ -18,7 +18,7 @@ ELSE()
 	SET(ANKI_LIBS ${ANKI_LIBS} GLESv2 EGL)
 ENDIF()
 
-TARGET_LINK_LIBRARIES(anki ${ANKI_LIBS} ankitinyxml2 ankilua ankibullet ${_ANKI_LIBPNG} pthread)
+TARGET_LINK_LIBRARIES(anki ${ANKI_LIBS} ankitinyxml2 ankilua ankibullet ${_ANKI_LIBPNG} ${ANKI_GPERFTOOLS_LIBS} pthread)
 
 SET_TARGET_PROPERTIES(anki PROPERTIES LINKER_LANGUAGE CXX)
 

src/renderer/Dbg.cpp

@@ -60,12 +60,11 @@ void Dbg::run()
 	for(auto it = scene.getAllNodesBegin(); it != scene.getAllNodesEnd(); it++)
 	{
 		SceneNode* node = *it;
-		if(!node->getSpatial())
+		Spatial* sp = node->getSpatial();
+		if(sp)
 		{
-			continue;
+			sceneDrawer->draw(*node);
 		}
-
-		sceneDrawer->draw(*node);
 	}
 
 	for(const Sector* sector : scene.sectors)

src/renderer/DebugDrawer.cpp

@@ -486,7 +486,7 @@ void SceneDebugDrawer::draw(SceneNode& node)
 
 	Spatial* sp;
 	if(isFlagEnabled(DF_SPATIAL) && (sp = node.getSpatial())
-		&& sp->isFlagEnabled(Spatial::SF_VISIBLE))
+		&& sp->isFlagEnabled(Spatial::SF_VISIBLE_CAMERA))
 	{
 		draw(*sp);
 	}

src/renderer/Hdr.cpp

@@ -119,7 +119,6 @@ void Hdr::run()
 	toneSProg->findUniformVariable("fai").set(r->getIs().getFai());
 	r->drawQuad();
 
-#if 0
 	// blurring passes
 	for(U32 i = 0; i < blurringIterationsCount; i++)
 	{
@@ -141,19 +140,6 @@ void Hdr::run()
 		}
 		r->drawQuad();
 	}
-#else
-	hblurFbo.bind();
-	hblurSProg->bind();
-	hblurSProg->findUniformVariable("img").set(vblurFai);
-
-	r->drawQuadMultiple(blurringIterationsCount);
-
-	vblurFbo.bind();
-	vblurSProg->bind();
-	vblurSProg->findUniformVariable("img").set(hblurFai);
-
-	r->drawQuadMultiple(blurringIterationsCount);
-#endif
 
 	// For the next stage it should be LINEAR though
 	//vblurFai.setFiltering(Texture::TFT_LINEAR);

src/renderer/Is.cpp

@@ -7,6 +7,19 @@
 
 namespace anki {
 
+//==============================================================================
+static Bool groundVectorsEqual(const Vec3& prev, const Vec3& crnt)
+{
+	Bool out = true;
+	for(U i = 0; i < 3; i++)
+	{
+		Bool subout = fabs(prev[i] - crnt[i]) < (getEpsilon<F32>() * 10.0);
+		out = out && subout;
+	}
+
+	return out;
+}
+
 //==============================================================================
 
 // Shader structs and block representations
@@ -56,6 +69,7 @@ struct ShaderCommonUniforms
 	Vec4 nearPlanes;
 	Vec4 limitsOfNearPlane;
 	Vec4 sceneAmbientColor;
+	Vec4 groundLightDir;
 };
 
 //==============================================================================
@@ -276,6 +290,7 @@ void Is::initInternal(const RendererInitializer& initializer)
 	drawToDefaultFbo = initializer.is.drawToDefaultFbo;
 	width = initializer.width / initializer.renderingQuality;
 	height = initializer.height / initializer.renderingQuality;
+	groundLightEnabled = initializer.is.groundLightEnabled;
 
 	//
 	// Init the passes
@@ -293,7 +308,8 @@ void Is::initInternal(const RendererInitializer& initializer)
 		"#define MAX_LIGHTS_PER_TILE " + std::to_string(MAX_LIGHTS_PER_TILE)
 		+ "\n"
 		"#define MAX_POINT_LIGHTS " + std::to_string(MAX_POINT_LIGHTS) + "\n"
-		"#define MAX_SPOT_LIGHTS " + std::to_string(MAX_SPOT_LIGHTS) + "\n";
+		"#define MAX_SPOT_LIGHTS " + std::to_string(MAX_SPOT_LIGHTS) + "\n"
+		"#define GROUND_LIGHT " + std::to_string(groundLightEnabled) + "\n";
 
 	if(sm.getPcfEnabled())
 	{
@@ -582,10 +598,19 @@ void Is::run()
 	Scene& scene = r->getScene();
 	cam = &scene.getActiveCamera();
 
+	// Ground light direction
+	Vec3 groundLightDir;
+	if(groundLightEnabled)
+	{
+		groundLightDir = cam->getViewMatrix().getColumn(1).xyz();
+	}
+
 	// Write common block
 	if(commonUboUpdateTimestamp < r->getPlanesUpdateTimestamp()
 		|| commonUboUpdateTimestamp < scene.getAmbientColorUpdateTimestamp()
-		|| commonUboUpdateTimestamp == 1)
+		|| commonUboUpdateTimestamp == 1
+		|| (groundLightEnabled
+			&& !groundVectorsEqual(groundLightDir, prevGroundLightDir)))
 	{
 		const Camera& cam = scene.getActiveCamera();
 		ShaderCommonUniforms blk;
@@ -595,6 +620,12 @@ void Is::run()
 			r->getLimitsOfNearPlane2());
 		blk.sceneAmbientColor = Vec4(scene.getAmbientColor(), 0.0);
 
+		if(groundLightEnabled)
+		{
+			blk.groundLightDir = Vec4(groundLightDir, 1.0);
+			prevGroundLightDir = groundLightDir;
+		}
+
 		commonUbo.write(&blk);
 
 		commonUboUpdateTimestamp = Timestamp::getTimestamp();

src/renderer/Ssao.cpp

@@ -18,6 +18,7 @@ void Ssao::createFbo(Fbo& fbo, Texture& fai)
 {
 
 	Renderer::createFai(width, height, GL_RED, GL_RED, GL_FLOAT, fai);
+	fai.setFiltering(Texture::TFT_LINEAR);
 
 	fbo.create();
 	fbo.setColorAttachments({&fai});
@@ -107,6 +108,10 @@ void Ssao::init(const RendererInitializer& initializer)
 void Ssao::run()
 {
 	ANKI_ASSERT(enabled);
+	if(r->getFramesCount() % 2 == 1)
+	{
+		return;
+	}
 
 	const Camera& cam = r->getScene().getActiveCamera();
 

src/renderer/Tiler.cpp

@@ -43,7 +43,7 @@ struct UpdateTiles4PlanesPerspectiveCameraJob: ThreadJob
 
 			Tiler::Tile& tile = tiler->tiles1d[k];
 
-			tile.planesWSpace[Frustum::FP_LEFT] = 
+			tile.planesWSpace[Frustum::FP_LEFT] =
 				tile.planes[Frustum::FP_LEFT].getTransformed(trf);
 			tile.planesWSpace[Frustum::FP_RIGHT] = 
 				tile.planes[Frustum::FP_RIGHT].getTransformed(trf);
@@ -217,7 +217,7 @@ void Tiler::updateTiles(Camera& cam, const Texture& depthMap)
 	fai.readPixels(pixels);
 #else
 	glReadPixels(0, 0, TILES_X_COUNT, TILES_Y_COUNT, GL_RG_INTEGER,
-		GL_UNSIGNED_INT, pixels);
+		GL_UNSIGNED_INT, &pixels[0][0][0]);
 #endif
 
 	waitUpdate4Planes();
@@ -228,6 +228,15 @@ void Tiler::updateTiles(Camera& cam, const Texture& depthMap)
 	update2Planes(cam, pixels);
 
 	prevCam = &cam;
+
+	/*for(U i = 0; i < TILES_Y_COUNT; i++)
+		for(U j = 0; j < TILES_X_COUNT; j++)
+		{
+			std::cout << tiles[j][i].planesWSpace[0].getNormal() << " "
+				<< tiles[j][i].planesWSpace[0].getOffset() << std::endl;
+		}
+
+	std::cout << std::endl;*/
 #else
 	Vector<F32> allpixels;
 

src/scene/VisibilityTester.cpp

@@ -51,6 +51,7 @@ struct VisibilityTestJob: ThreadJob
 	std::mutex* renderablesMtx;
 	std::mutex* lightsMtx;
 	Frustumable* frustumable;
+	Renderer* renderer;
 
 	void operator()(U threadId, U threadsCount)
 	{
@@ -79,23 +80,18 @@ struct VisibilityTestJob: ThreadJob
 				continue;
 			}
 
-			sp->disableFlag(Spatial::SF_VISIBLE);
-
 			if(!frustumable->insideFrustum(*sp))
 			{
 				continue;
 			}
 
-			/*if(!r.doVisibilityTests(sp->getAabb()))
-			{
-				continue;
-			}*/
-
-			sp->enableFlag(Spatial::SF_VISIBLE);
-
 			Renderable* r = node->getRenderable();
 			if(r)
 			{
+				if(!renderer->doVisibilityTests(sp->getAabb()))
+				{
+					continue;
+				}
 				tmpRenderables[renderablesIdx++] = node;
 			}
 			else
@@ -111,6 +107,8 @@ struct VisibilityTestJob: ThreadJob
 					}
 				}
 			}
+
+			sp->enableFlag(Spatial::SF_VISIBLE_CAMERA);
 		} // end for
 
 		VisibilityInfo& vinfo = frustumable->getVisibilityInfo();
@@ -166,7 +164,7 @@ struct VisibilityTestJob: ThreadJob
 				continue;
 			}
 
-			sp->enableFlag(Spatial::SF_VISIBLE);
+			sp->enableFlag(Spatial::SF_VISIBLE_LIGHT);
 
 			Renderable* r = node->getRenderable();
 			if(r)
@@ -211,6 +209,17 @@ VisibilityTester::~VisibilityTester()
 //==============================================================================
 void VisibilityTester::test(Frustumable& ref, Scene& scene, Renderer& r)
 {
+	// Set all spatials to not visible
+	for(auto it = scene.getAllNodesBegin(); it != scene.getAllNodesEnd(); ++it)
+	{
+		Spatial* sp = (*it)->getSpatial();
+
+		if(sp)
+		{
+			sp->disableFlag(Spatial::SF_VISIBLE_ANY);
+		}
+	}
+
 	VisibilityInfo& vinfo = ref.getVisibilityInfo();
 	vinfo.renderables.clear();
 	vinfo.lights.clear();
@@ -228,6 +237,7 @@ void VisibilityTester::test(Frustumable& ref, Scene& scene, Renderer& r)
 		jobs[i].renderablesMtx = &renderablesMtx;
 		jobs[i].lightsMtx = &lightsMtx;
 		jobs[i].frustumable = &ref;
+		jobs[i].renderer = &r;
 
 		threadPool.assignNewJob(i, &jobs[i]);
 	}

testapp/Main.cpp

@@ -383,7 +383,7 @@ void initSubsystems(int argc, char* argv[])
 	initializer.is.sm.resolution = 512;
 	initializer.pps.hdr.enabled = true;
 	initializer.pps.hdr.renderingQuality = 0.25;
-	initializer.pps.hdr.blurringDist = 0.5;
+	initializer.pps.hdr.blurringDist = 1.0;
 	initializer.pps.hdr.blurringIterationsCount = 2;
 	initializer.pps.hdr.exposure = 8.0;
 	initializer.pps.ssao.blurringIterationsNum = 4;