Add near filtering for indirect

include/anki/gr/Texture.h

@@ -22,7 +22,7 @@ public:
 	F32 m_minLod = -1000.0;
 	F32 m_maxLod = 1000.0;
 	I8 m_anisotropyLevel = 0;
-	Bool8 m_repeat = true;
+	Bool8 m_repeat = true; ///< Repeat or clamp.
 };
 
 /// Texture initializer.

include/anki/renderer/Refl.h

@@ -54,6 +54,7 @@ private:
 	ResourceGroupPtr m_blitRcGroup;
 	FramebufferPtr m_isFb;
 	ShaderResourcePtr m_blitFrag;
+	ShaderResourcePtr m_blitVert;
 	PipelinePtr m_blitPpline;
 
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& config);

shaders/NearDepthUpscale.frag.glsl

@@ -0,0 +1,77 @@
+// Copyright (C) 2009-2016, Panagiotis Christopoulos Charitos.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#pragma anki type frag
+#pragma anki include "shaders/Common.glsl"
+
+layout(location = 0) in vec2 in_uv;
+
+layout(location = 0) out vec3 out_color;
+
+layout(TEX_BINDING(0, 0)) uniform sampler2D u_depthTexHigh;
+layout(TEX_BINDING(0, 1)) uniform sampler2D u_depthTexLow;
+layout(TEX_BINDING(0, 2)) uniform sampler2D u_colorTexNearest;
+layout(TEX_BINDING(0, 3)) uniform sampler2D u_colorTexLinear;
+
+const float DEPTH_THRESHOLD = 1.0 / 1000.0;
+
+const vec2 COLOR_TEX_TEXEL_SIZE = 1.0 / vec2(TEXTURE_WIDTH, TEXTURE_HEIGHT);
+
+void main()
+{
+	// Gather the depths around the UV
+	vec4 depths = textureGather(u_depthTexLow, in_uv, 0);
+
+	// Get the depth of the current fragment
+	float depth = texture(u_depthTexHigh, in_uv).r;
+
+	// Check for depth discontinuites. Use textureGrad because it's undefined
+	// if you are sampling mipmaped in a conditional branch. See
+	// http://teknicool.tumblr.com/post/77263472964/glsl-dynamic-branching-and-texture-samplers
+	vec2 texDx = dFdx(in_uv);
+	vec2 texDy = dFdy(in_uv);
+	vec4 diffs = abs(depths - vec4(depth));
+	if(all(lessThan(diffs, vec4(DEPTH_THRESHOLD))))
+	{
+		// No major discontinuites, sample with bilinear
+		out_color = textureGrad(u_colorTexLinear, in_uv, texDx, texDy).rgb;
+	}
+	else
+	{
+		// Some discontinuites, need to do some work
+		// Note: Texture gather values are placed like this:
+		// xy
+		// wz
+		// and w is the current texel
+
+		float smallestDiff = diffs.w;
+		vec2 newUv = in_uv;
+
+		if(diffs.z < smallestDiff)
+		{
+			smallestDiff = diffs.z;
+			newUv.x += COLOR_TEX_TEXEL_SIZE.x;
+		}
+
+		if(diffs.y < smallestDiff)
+		{
+			smallestDiff = diffs.y;
+			newUv = in_uv + COLOR_TEX_TEXEL_SIZE;
+		}
+
+		if(diffs.x < smallestDiff)
+		{
+			newUv = in_uv + vec2(0.0, COLOR_TEX_TEXEL_SIZE.y);
+		}
+
+		out_color = textureGrad(u_colorTexNearest, newUv, texDx, texDy).rgb;
+	}
+
+	/*vec2 texDx = dFdx(in_uv);
+	vec2 texDy = dFdy(in_uv);
+	out_color = textureGrad(u_colorTexLinear, in_uv, texDx, texDy).rgb;*/
+}
+
+

shaders/NearDepthUpscale.vert.glsl

@@ -0,0 +1,38 @@
+// Copyright (C) 2009-2016, Panagiotis Christopoulos Charitos.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#pragma anki type vert
+#pragma anki include "shaders/Common.glsl"
+
+out gl_PerVertex
+{
+	vec4 gl_Position;
+};
+
+layout(location = 0) out vec2 out_uv;
+
+void main()
+{
+	const vec2 POSITIONS[3] = vec2[](
+		vec2(-1.0, -1.0),
+		vec2(3.0, -1.0),
+		vec2(-1.0, 3.0));
+
+	vec2 pos = POSITIONS[gl_VertexID];
+	gl_Position = vec4(pos, 0.0, 1.0);
+
+	// Add to the UV and place it at the middle of the texel and slightly
+	// top-right
+	// +----+
+	// |   o|
+	// |    |
+	// |    |
+	// +----+
+	const vec2 TEXEL_SIZE = vec2(1.0 / float(TEXTURE_WIDTH),
+		1.0 / float(TEXTURE_HEIGHT));
+	const vec2 UV_OFFSET = TEXEL_SIZE / 2.0 + EPSILON * 2.0;
+	out_uv = pos * 0.5 + (0.5 + UV_OFFSET);
+}
+

shaders/Pack.glsl

@@ -140,7 +140,7 @@ void readGBuffer(
 // Rear roughness from G-Buffer
 void readRoughnessFromGBuffer(in sampler2D rt1, in vec2 uv, out float r)
 {
-	r = textureLod(rt1, uv, 0.0).z;
+	r = texture(rt1, uv).z;
 }
 
 // Read only normal from G buffer
@@ -149,7 +149,7 @@ void readNormalFromGBuffer(
 	in vec2 uv,
 	out vec3 normal)
 {
-	normal = normalize(textureLod(fai2, uv, 0.0).rgb * 2.0 - 1.0);
+	normal = normalize(texture(fai2, uv).rgb * 2.0 - 1.0);
 }
 
 // Read only normal and specular color from G buffer

shaders/Pps.frag.glsl

@@ -170,10 +170,12 @@ void main()
 	out_color = colorGrading(out_color);
 
 #if 0
+#if SSAO_ENABLED
 	if(out_color.x != 0.0000001)
 	{
 		out_color = vec3(ssao);
 	}
 #endif
+#endif
 }
 

shaders/PpsSsao.frag.glsl

@@ -64,7 +64,7 @@ vec3 readRandom(in vec2 uv)
 // Returns the Z of the position in view space
 float readZ(in vec2 uv)
 {
-	float depth = textureLod(u_mMsDepthRt, uv, 1.0).r;
+	float depth = texture(u_mMsDepthRt, uv).r;
 	float z = u_uniforms.projectionParams.z
 		/ (u_uniforms.projectionParams.w + depth);
 	return z;
@@ -73,7 +73,7 @@ float readZ(in vec2 uv)
 // Read position in view space
 vec3 readPosition(in vec2 uv)
 {
-	float depth = textureLod(u_mMsDepthRt, uv, 1.0).r;
+	float depth = texture(u_mMsDepthRt, uv).r;
 
 	vec3 fragPosVspace;
 	fragPosVspace.z = readZ(uv);

shaders/Refl.frag.glsl

@@ -43,7 +43,7 @@ void main()
 	//
 	// Decode the G-buffer
 	//
-	float depth = textureRt(u_depthRt, in_texCoord).r;
+	float depth = texture(u_depthRt, in_texCoord).r;
 	vec3 posVSpace;
 	posVSpace.z = u_projectionParams.z / (u_projectionParams.w + depth);
 	posVSpace.xy =

src/gr/gl/SamplerImpl.cpp

@@ -40,6 +40,9 @@ void SamplerImpl::create(const SamplerInitializer& sinit)
 			GLint(sinit.m_anisotropyLevel));
 	}
 #endif
+
+	glSamplerParameteri(m_glName, GL_TEXTURE_MIN_LOD, sinit.m_minLod);
+	glSamplerParameteri(m_glName, GL_TEXTURE_MAX_LOD, sinit.m_maxLod);
 }
 
 } // end namespace anki

src/gr/gl/TextureImpl.cpp

@@ -407,6 +407,9 @@ void TextureImpl::create(const TextureInitializer& init)
 			glTexParameteri(m_target, GL_TEXTURE_COMPARE_FUNC,
 				convertCompareOperation(sinit.m_compareOperation));
 		}
+
+		glTexParameteri(m_target, GL_TEXTURE_MIN_LOD, sinit.m_minLod);
+		glTexParameteri(m_target, GL_TEXTURE_MAX_LOD, sinit.m_maxLod);
 	}
 
 	ANKI_CHECK_GL_ERROR();

src/renderer/Ms.cpp

@@ -41,10 +41,10 @@ Error Ms::createRt(U32 index, U32 samples)
 		RT_PIXEL_FORMATS[0], samples, SamplingFilter::NEAREST, 1, plane.m_rt0);
 
 	m_r->createRenderTarget(m_r->getWidth(), m_r->getHeight(),
-		RT_PIXEL_FORMATS[1], samples, SamplingFilter::NEAREST, 1, plane.m_rt1);
+		RT_PIXEL_FORMATS[1], samples, SamplingFilter::NEAREST, 2, plane.m_rt1);
 
 	m_r->createRenderTarget(m_r->getWidth(), m_r->getHeight(),
-		RT_PIXEL_FORMATS[2], samples, SamplingFilter::NEAREST, 1, plane.m_rt2);
+		RT_PIXEL_FORMATS[2], samples, SamplingFilter::NEAREST, 2, plane.m_rt2);
 
 	AttachmentLoadOperation loadop = AttachmentLoadOperation::DONT_CARE;
 #if ANKI_DEBUG
@@ -161,6 +161,8 @@ void Ms::generateMipmaps(CommandBufferPtr& cmdb)
 {
 	U planeId = (m_r->getSamples() == 1) ? 1 : 0;
 	cmdb->generateMipmaps(m_planes[planeId].m_depthRt);
+	cmdb->generateMipmaps(m_planes[planeId].m_rt1);
+	cmdb->generateMipmaps(m_planes[planeId].m_rt2);
 }
 
 } // end namespace anki

src/renderer/Refl.cpp

@@ -62,11 +62,8 @@ Error Refl::initInternal(const ConfigSet& config)
 	}
 
 	// Size
-	const F32 quality = config.getNumber("refl.renderingQuality");
-
-	m_width = getAlignedRoundUp(Renderer::TILE_SIZE, quality * m_r->getWidth());
-	m_height =
-		getAlignedRoundUp(Renderer::TILE_SIZE, quality * m_r->getHeight());
+	m_width = m_r->getWidth() / 2;
+	m_height = m_r->getHeight() / 2;
 
 	// IR
 	if(m_irEnabled)
@@ -85,6 +82,8 @@ Error Refl::initInternal(const ConfigSet& config)
 //==============================================================================
 Error Refl::init1stPass(const ConfigSet& config)
 {
+	GrManager& gr = getGrManager();
+
 	// Create shader
 	StringAuto pps(getFrameAllocator());
 	const PixelFormat& pixFormat = Pps::RT_PIXEL_FORMAT;
@@ -125,9 +124,19 @@ Error Refl::init1stPass(const ConfigSet& config)
 
 	// Create RC group
 	ResourceGroupInitializer rcInit;
+	SamplerInitializer sinit;
+
+	sinit.m_minLod = 1.0;
+	sinit.m_minMagFilter = SamplingFilter::NEAREST;
+	sinit.m_mipmapFilter = SamplingFilter::NEAREST;
 	rcInit.m_textures[0].m_texture = m_r->getMs().getDepthRt();
+	rcInit.m_textures[0].m_sampler = gr.newInstance<Sampler>(sinit);
+
 	rcInit.m_textures[1].m_texture = m_r->getMs().getRt1();
+	rcInit.m_textures[1].m_sampler = gr.newInstance<Sampler>(sinit);
+
 	rcInit.m_textures[2].m_texture = m_r->getMs().getRt2();
+	rcInit.m_textures[2].m_sampler = gr.newInstance<Sampler>(sinit);
 
 	if(m_sslrEnabled)
 	{
@@ -168,25 +177,59 @@ Error Refl::init1stPass(const ConfigSet& config)
 //==============================================================================
 Error Refl::init2ndPass()
 {
+	GrManager& gr = getGrManager();
+
 	// Create RC group
+	SamplerInitializer sinit;
 	ResourceGroupInitializer rcInit;
-	rcInit.m_textures[0].m_texture = m_rt;
+
+	sinit.m_mipmapFilter = SamplingFilter::NEAREST;
+	rcInit.m_textures[0].m_texture = m_r->getMs().getDepthRt();
+	rcInit.m_textures[0].m_sampler = gr.newInstance<Sampler>(sinit);
+
+	sinit.m_minLod = 1.0;
+	rcInit.m_textures[1].m_texture = m_r->getMs().getDepthRt();
+	rcInit.m_textures[1].m_sampler = gr.newInstance<Sampler>(sinit);
+
+	sinit.m_minLod = 0.0;
+	rcInit.m_textures[2].m_texture = m_rt;
+	rcInit.m_textures[2].m_sampler = gr.newInstance<Sampler>(sinit);
+
+	sinit.m_minMagFilter = SamplingFilter::LINEAR;
+	rcInit.m_textures[3].m_texture = m_rt;
+	rcInit.m_textures[3].m_sampler = gr.newInstance<Sampler>(sinit);
 
 	m_blitRcGroup = getGrManager().newInstance<ResourceGroup>(rcInit);
 
 	// Shader
-	ANKI_CHECK(getResourceManager().loadResource(
-		"shaders/Blit.frag.glsl", m_blitFrag));
+	StringAuto pps(getFrameAllocator());
+	pps.sprintf(
+		"#define TEXTURE_WIDTH %uu\n"
+		"#define TEXTURE_HEIGHT %uu\n",
+		m_width, m_height);
+
+	ANKI_CHECK(getResourceManager().loadResourceToCache(m_blitFrag,
+		"shaders/NearDepthUpscale.frag.glsl", pps.toCString(), "r_refl_"));
+
+	ANKI_CHECK(getResourceManager().loadResourceToCache(m_blitVert,
+		"shaders/NearDepthUpscale.vert.glsl", pps.toCString(), "r_refl_"));
 
 	// Ppline
-	ColorStateInfo colorState;
-	colorState.m_attachmentCount = 1;
-	colorState.m_attachments[0].m_format = Is::RT_PIXEL_FORMAT;
-	colorState.m_attachments[0].m_srcBlendMethod = BlendMethod::ONE;
-	colorState.m_attachments[0].m_dstBlendMethod = BlendMethod::ONE;
+	PipelineInitializer ppinit;
+
+	ppinit.m_inputAssembler.m_topology = PrimitiveTopology::TRIANGLE_STRIP;
+
+	ppinit.m_depthStencil.m_depthWriteEnabled = false;
+	ppinit.m_depthStencil.m_depthCompareFunction = CompareOperation::ALWAYS;
+
+	ppinit.m_color.m_attachmentCount = 1;
+	ppinit.m_color.m_attachments[0].m_format = Is::RT_PIXEL_FORMAT;
+	ppinit.m_color.m_attachments[0].m_srcBlendMethod = BlendMethod::ONE;
+	ppinit.m_color.m_attachments[0].m_dstBlendMethod = BlendMethod::ONE;
 
-	m_r->createDrawQuadPipeline(m_blitFrag->getGrShader(), colorState,
-		m_blitPpline);
+	ppinit.m_shaders[U(ShaderType::VERTEX)] = m_blitVert->getGrShader();
+	ppinit.m_shaders[U(ShaderType::FRAGMENT)] = m_blitFrag->getGrShader();
+	m_blitPpline = gr.newInstance<Pipeline>(ppinit);
 
 	// Create FB
 	FramebufferInitializer fbInit;

src/renderer/Ssao.cpp

@@ -99,6 +99,8 @@ Error Ssao::initInternal(const ConfigSet& config)
 		return ErrorCode::NONE;
 	}
 
+	GrManager& gr = getGrManager();
+
 	m_blurringIterationsCount =
 		config.getNumber("pps.ssao.blurringIterationsCount");
 
@@ -128,19 +130,19 @@ Error Ssao::initInternal(const ConfigSet& config)
 	tinit.m_format =
 		PixelFormat(ComponentFormat::R32G32B32, TransformFormat::FLOAT);
 	tinit.m_mipmapsCount = 1;
-	tinit.m_sampling.m_minMagFilter = SamplingFilter::NEAREST;
+	tinit.m_sampling.m_minMagFilter = SamplingFilter::LINEAR;
 	tinit.m_sampling.m_repeat = true;
 
-	m_noiseTex = getGrManager().newInstance<Texture>(tinit);
+	m_noiseTex = gr.newInstance<Texture>(tinit);
 
-	CommandBufferPtr cmdb = getGrManager().newInstance<CommandBuffer>();
+	CommandBufferPtr cmdb = gr.newInstance<CommandBuffer>();
 
 	PtrSize noiseSize = NOISE_TEX_SIZE * NOISE_TEX_SIZE * sizeof(Vec3);
 
 	DynamicBufferToken token;
 	Vec3* noise = static_cast<Vec3*>(
-		getGrManager().allocateFrameHostVisibleMemory(noiseSize,
-		BufferUsage::TRANSFER, token));
+		gr.allocateFrameHostVisibleMemory(noiseSize, BufferUsage::TRANSFER,
+		token));
 
 	genNoise(noise, noise + NOISE_TEX_SIZE * NOISE_TEX_SIZE);
 
@@ -169,9 +171,8 @@ Error Ssao::initInternal(const ConfigSet& config)
 	//
 	// Shaders
 	//
-	m_uniformsBuff = getGrManager().newInstance<Buffer>(
-		sizeof(ShaderCommonUniforms), BufferUsageBit::UNIFORM,
-		BufferAccessBit::CLIENT_WRITE);
+	m_uniformsBuff = gr.newInstance<Buffer>(sizeof(ShaderCommonUniforms),
+		BufferUsageBit::UNIFORM, BufferAccessBit::CLIENT_WRITE);
 
 	ColorStateInfo colorState;
 	colorState.m_attachmentCount = 1;
@@ -230,21 +231,31 @@ Error Ssao::initInternal(const ConfigSet& config)
 	// Resource groups
 	//
 	ResourceGroupInitializer rcinit;
+	SamplerInitializer sinit;
+	sinit.m_minMagFilter = SamplingFilter::LINEAR;
+	sinit.m_mipmapFilter = SamplingFilter::NEAREST;
+	sinit.m_repeat = false;
+	sinit.m_minLod = 0.0;
+
 	rcinit.m_textures[0].m_texture = m_r->getMs().getDepthRt();
+	rcinit.m_textures[0].m_sampler = gr.newInstance<Sampler>(sinit);
+
 	rcinit.m_textures[1].m_texture = m_r->getMs().getRt2();
+	rcinit.m_textures[1].m_sampler = rcinit.m_textures[0].m_sampler;
+
 	rcinit.m_textures[2].m_texture = m_noiseTex;
 	rcinit.m_uniformBuffers[0].m_buffer = m_uniformsBuff;
-	m_rcFirst = getGrManager().newInstance<ResourceGroup>(rcinit);
+	m_rcFirst = gr.newInstance<ResourceGroup>(rcinit);
 
 	rcinit = ResourceGroupInitializer();
 	rcinit.m_textures[0].m_texture = m_vblurRt;
-	m_hblurRc = getGrManager().newInstance<ResourceGroup>(rcinit);
+	m_hblurRc = gr.newInstance<ResourceGroup>(rcinit);
 
 	rcinit = ResourceGroupInitializer();
 	rcinit.m_textures[0].m_texture = m_hblurRt;
-	m_vblurRc = getGrManager().newInstance<ResourceGroup>(rcinit);
+	m_vblurRc = gr.newInstance<ResourceGroup>(rcinit);
 
-	getGrManager().finish();
+	gr.finish();
 	return ErrorCode::NONE;
 }
 
@@ -279,7 +290,7 @@ void Ssao::run(CommandBufferPtr& cmdb)
 	if(m_commonUboUpdateTimestamp
 			< m_r->getProjectionParametersUpdateTimestamp()
 		|| m_commonUboUpdateTimestamp < camFr.getTimestamp()
-		|| m_commonUboUpdateTimestamp == 1)
+		|| m_commonUboUpdateTimestamp == 0)
 	{
 		DynamicBufferToken token;
 		ShaderCommonUniforms* blk = static_cast<ShaderCommonUniforms*>(

src/renderer/Tiler.cpp

@@ -160,7 +160,8 @@ Bool Tiler::test(const CollisionShape& cs, const Aabb& aabb) const
 	for(Vec4& p : points)
 	{
 		p = m_viewProjMat * p;
-		p /= abs(p.w());
+		ANKI_ASSERT(p.w() > 0.0);
+		p = p.perspectiveDivide();
 
 		for(U i = 0; i < 2; ++i)
 		{

testapp/Main.cpp

@@ -42,8 +42,8 @@ App* app;
 ModelNode* horse;
 PerspectiveCamera* cam;
 
-#define PLAYER 1
-#define MOUSE 1
+#define PLAYER 0
+#define MOUSE 0
 
 Bool profile = false;
 
@@ -88,9 +88,9 @@ Error init()
 #if !PLAYER
 	cam->getComponent<MoveComponent>().
 		setLocalTransform(Transform(
-		Vec4(147.392776, -10.132728, 16.607138, 0.0),
-		//Vec4(0.0, 10, 0, 0),
-		Mat3x4(Euler(toRad(0.0), toRad(90.0), toRad(0.0))),
+		//Vec4(147.392776, -10.132728, 16.607138, 0.0),
+		Vec4(120.124107, -12.032735, 12.564746, 0),
+		Mat3x4(Euler(toRad(0.0), toRad(0.0), toRad(0.0))),
 		//Mat3x4::getIdentity(),
 		1.0));
 #endif
@@ -488,7 +488,7 @@ Error initSubsystems(int argc, char* argv[])
 	config.set("is.sm.poissonEnabled", true);
 	config.set("is.sm.resolution", 1024);
 	config.set("lf.maxFlares", 32);
-	config.set("pps.enabled", true);
+	config.set("pps.enabled", false);
 	config.set("pps.bloom.enabled", true);
 	config.set("pps.bloom.renderingQuality", 0.5);
 	config.set("pps.bloom.blurringDist", 1.0);
@@ -517,7 +517,7 @@ Error initSubsystems(int argc, char* argv[])
 	config.set("sslr.enabled", false);
 	config.set("ir.rendererSize", 64);
 	config.set("ir.clusterSizeZ", 16);
-	config.set("fullscreenDesktopResolution", false);
+	config.set("fullscreenDesktopResolution", true);
 	//config.set("clusterSizeZ", 16);
 	config.set("debugContext", false);
 	if(getenv("ANKI_DATA_PATH"))