Moving from old glTexImageXX to glTexStorageXX

include/anki/gl/GlCommon.h

@@ -60,13 +60,10 @@ public:
 	U32 m_depth = 0; ///< Relevant only for 3D and 2DArray textures
 	GLenum m_target = GL_TEXTURE_2D;
 	GLenum m_internalFormat = GL_NONE;
-	GLenum m_format = GL_NONE;
-	GLenum m_type = GL_NONE;
 	U32 m_mipmapsCount = 0;
 	GlTextureFilter m_filterType = GlTextureFilter::NEAREST;
 	Bool8 m_repeat = false;
 	I32 m_anisotropyLevel = 0;
-	Bool8 m_genMipmaps = false;
 	U32 m_samples = 1;
 };
 

include/anki/gl/GlTexture.h

@@ -59,24 +59,12 @@ public:
 		return m_internalFormat;
 	}
 
-	GLenum getFormat() const
-	{
-		ANKI_ASSERT(isCreated());
-		return m_format;
-	}
-
 	GLenum getTarget() const
 	{
 		ANKI_ASSERT(isCreated());
 		return m_target;
 	}
 
-	GLenum getType() const
-	{
-		ANKI_ASSERT(isCreated());
-		return m_type;
-	}
-
 	U32 getWidth() const
 	{
 		ANKI_ASSERT(isCreated());
@@ -128,8 +116,6 @@ public:
 private:
 	GLenum m_target = GL_NONE; ///< GL_TEXTURE_2D, GL_TEXTURE_3D... etc
 	GLenum m_internalFormat = GL_NONE; ///< GL_COMPRESSED_RED, GL_RGB16 etc
-	GLenum m_format = GL_NONE; ///< GL_RED, GL_RG, GL_RGB etc
-	GLenum m_type = GL_NONE; ///< GL_UNSIGNED_BYTE, GL_BYTE etc
 	U32 m_width = 0;
 	U32 m_height = 0;
 	U32 m_depth = 0;

include/anki/scene/Light.h

@@ -29,6 +29,13 @@ public:
 	{
 		return Type::LIGHT;
 	}
+
+private:
+	Vec4 m_diffColor = Vec4(0.5);
+	Vec4 m_specColor = Vec4(0.5);
+
+	Bool8 m_shadow = false;
+	U8 m_shadowMapIndex = 0xFF; ///< Used by the renderer
 };
 
 /// Light scene node. It can be spot or point

shaders/IsLp.frag.glsl

@@ -270,7 +270,7 @@ void main()
 	vec3 diffCol;
 	float specCol;
 	float specPower;
-	const float subsurface = 0.1;
+	const float subsurface = 0.0;
 
 	readGBuffer(
 		u_msRt0, u_msRt1, in_texCoord, diffCol, normal, specCol, specPower);
@@ -340,10 +340,9 @@ void main()
 			* (att * spot * max(subsurface, lambert * shadow));
 	}
 
-//#if GROUND_LIGHT
-#if 0
+#if GROUND_LIGHT
 	out_color += max(dot(normal, u_groundLightDir.xyz), 0.0) 
-		* vec3(0.10, 0.01, 0.01);
+		* vec3(0.01, 0.001, 0.001);
 #endif
 
 #if 0

src/gl/GlTexture.cpp

@@ -14,34 +14,88 @@ namespace anki {
 // Misc                                                                        =
 //==============================================================================
 
-namespace {
-
 //==============================================================================
-Bool isCompressedInternalFormat(const GLenum internalFormat)
+static void getTextureInformation(
+	const GLenum internalFormat,
+	Bool& compressed,
+	GLenum& format,
+	GLenum& type)
 {
-	Bool out = false;
 	switch(internalFormat)
 	{
 #if ANKI_GL == ANKI_GL_DESKTOP
 	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+		compressed = true;
+		format = internalFormat;
+		type = GL_UNSIGNED_BYTE;
+		break;
+	case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
+		compressed = true;
+		format = internalFormat;
+		type = GL_UNSIGNED_BYTE;
+		break;
 	case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+		compressed = true;
+		format = internalFormat;
+		type = GL_UNSIGNED_BYTE;
+		break;
 	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-		out = true;
+		compressed = true;
+		format = internalFormat;
+		type = GL_UNSIGNED_BYTE;
 		break;
 #else
 	case GL_COMPRESSED_RGB8_ETC2:
+		compressed = true;
+		format = internalFormat;
+		type = GL_UNSIGNED_BYTE;
+		break;
 	case GL_COMPRESSED_RGBA8_ETC2_EAC:
-		out = true;
+		compressed = true;
+		format = internalFormat;
+		type = GL_UNSIGNED_BYTE;
 		break;
 #endif
+	case GL_R8:
+		compressed = false;
+		format = GL_R;
+		type = GL_UNSIGNED_BYTE;
+		break;
+	case GL_RGB8:
+		compressed = false;
+		format = GL_RGB;
+		type = GL_UNSIGNED_BYTE;
+		break;
+	case GL_RGB32F:
+		compressed = false;
+		format = GL_RGB;
+		type = GL_FLOAT;
+		break;
+	case GL_RGBA8:
+		compressed = false;
+		format = GL_RGBA;
+		type = GL_UNSIGNED_BYTE;
+		break;
+	case GL_RG32UI:
+		compressed = false;
+		format = GL_RG_INTEGER;
+		type = GL_UNSIGNED_INT;
+		break;
+	case GL_DEPTH_COMPONENT24:
+		compressed = false;
+		format = GL_DEPTH_COMPONENT;
+		type = GL_UNSIGNED_INT;
+		break;
+	case GL_DEPTH_COMPONENT16:
+		compressed = false;
+		format = GL_DEPTH_COMPONENT;
+		type = GL_UNSIGNED_SHORT;
+		break;
 	default:
-		out = false;
+		ANKI_ASSERT(0);
 	}
-	return out;
 }
 
-} // end anonymous namespace
-
 //==============================================================================
 // GlTexture                                                                   =
 //==============================================================================
@@ -54,6 +108,7 @@ Error GlTexture::create(const Initializer& init,
 	//
 	ANKI_ASSERT(!isCreated());
 	ANKI_ASSERT(init.m_width > 0 && init.m_height > 0);
+	ANKI_ASSERT(init.m_mipmapsCount > 0);
 
 	// Create
 	//
@@ -65,161 +120,197 @@ Error GlTexture::create(const Initializer& init,
 	m_depth = init.m_depth;
 	m_target = init.m_target;
 	m_internalFormat = init.m_internalFormat;
-	m_format = init.m_format;
-	m_type = init.m_type;
 	m_samples = init.m_samples;
 	ANKI_ASSERT(m_samples > 0);
 
 	// Bind
 	bind(0);
 
-	// Load data
-	U w = m_width;
-	U h = m_height;
-	ANKI_ASSERT(init.m_mipmapsCount > 0);
-	for(U level = 0; level < init.m_mipmapsCount; level++)
+	// Create storage
+	switch(m_target)
 	{
-		switch(m_target)
-		{
 		case GL_TEXTURE_2D:
-			if(!isCompressedInternalFormat(m_internalFormat))
-			{
-				glTexImage2D(
-					m_target, 
-					level, 
-					m_internalFormat, 
-					w,
-					h, 
-					0, 
-					m_format, 
-					m_type, 
-					init.m_data[level][0].m_ptr);
-			}
-			else
-			{
-				ANKI_ASSERT(init.m_data[level][0].m_ptr 
-					&& init.m_data[level][0].m_size > 0);
-
-				glCompressedTexImage2D(
-					m_target, 
-					level, 
-					m_internalFormat,
-					w, 
-					h, 
-					0, 
-					init.m_data[level][0].m_size, 
-					init.m_data[level][0].m_ptr);
-			}
+			glTexStorage2D(
+				m_target, 
+				init.m_mipmapsCount, 
+				m_internalFormat,
+				m_width,
+				m_height);
 			break;
 		case GL_TEXTURE_CUBE_MAP:
-			for(U face = 0; face < 6; face++)
+		case GL_TEXTURE_2D_ARRAY:
+		case GL_TEXTURE_3D:
+			glTexStorage3D(
+				m_target,
+				init.m_mipmapsCount,
+				m_internalFormat,
+				m_width,
+				m_height,
+				init.m_depth);
+			break;
+		case GL_TEXTURE_2D_MULTISAMPLE:
+			glTexStorage2DMultisample(
+				m_target,
+				m_samples,
+				m_internalFormat,
+				m_width,
+				m_height,
+				GL_FALSE);
+			break;
+		default:
+			ANKI_ASSERT(0);
+	}
+
+	// Load data
+	if(init.m_data[0][0].m_ptr != nullptr)
+	{
+		Bool compressed;
+		GLenum format;
+		GLenum type;
+		getTextureInformation(m_internalFormat, compressed, format, type);
+
+		U w = m_width;
+		U h = m_height;
+		for(U level = 0; level < init.m_mipmapsCount; level++)
+		{
+			ANKI_ASSERT(init.m_data[level][0].m_ptr != nullptr);
+
+			switch(m_target)
 			{
-				if(!isCompressedInternalFormat(m_internalFormat))
+			case GL_TEXTURE_2D:
+				if(!compressed)
 				{
-					glTexImage2D(
-						GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, 
+					glTexSubImage2D(
+						m_target, 
 						level, 
-						m_internalFormat, 
-						w, 
+						0,
+						0,
+						w,
 						h, 
-						0, 
-						m_format, 
-						m_type, 
-						init.m_data[level][face].m_ptr);
+						format, 
+						type, 
+						init.m_data[level][0].m_ptr);
 				}
 				else
 				{
-					glCompressedTexImage2D(
-						GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, 
+					ANKI_ASSERT(init.m_data[level][0].m_ptr 
+						&& init.m_data[level][0].m_size > 0);
+
+					glCompressedTexSubImage2D(
+						m_target, 
 						level, 
-						m_internalFormat,
+						0,
+						0,
 						w, 
-						h, 
-						0, 
-						init.m_data[level][face].m_size, 
-						init.m_data[level][face].m_ptr);
+						h,  
+						format,
+						init.m_data[level][0].m_size, 
+						init.m_data[level][0].m_ptr);
 				}
-			}
-			break;
-		case GL_TEXTURE_2D_ARRAY:
-		case GL_TEXTURE_3D:
-			{
-				ANKI_ASSERT(m_depth > 0);
-
-				// Gather the data
-				DArrayAuto<U8, GlAllocator<U8>> data(alloc);
-
-				// Check if there are data
-				if(init.m_data[level][0].m_ptr != nullptr)
+				break;
+			case GL_TEXTURE_CUBE_MAP:
+				for(U face = 0; face < 6; face++)
 				{
-					PtrSize layerSize = init.m_data[level][0].m_size;
-					ANKI_ASSERT(layerSize > 0);
-					Error err = data.create(layerSize * m_depth);
-					if(err)
+					if(!compressed)
 					{
-						return err;
+						glTexSubImage2D(
+							GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, 
+							level, 
+							0,
+							0,
+							w,
+							h, 
+							format, 
+							type, 
+							init.m_data[level][face].m_ptr);
 					}
-
-					for(U d = 0; d < m_depth; d++)
+					else
 					{
-						ANKI_ASSERT(init.m_data[level][d].m_size == layerSize
-							&& init.m_data[level][d].m_ptr != nullptr);
 
-						memcpy(&data[0] + d * layerSize, 
-							init.m_data[level][d].m_ptr, 
-							layerSize);
+						glCompressedTexSubImage2D(
+							GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, 
+							level, 
+							0,
+							0,
+							w, 
+							h,  
+							format,
+							init.m_data[level][face].m_size, 
+							init.m_data[level][face].m_ptr);
 					}
 				}
-
-				if(!isCompressedInternalFormat(m_internalFormat))
-				{
-					glTexImage3D(
-						m_target, 
-						level, 
-						m_internalFormat, 
-						w, 
-						h, 
-						m_depth,
-						0, 
-						m_format, 
-						m_type, 
-						(data.getSize() > 0) ? &data[0] : nullptr);
-				}
-				else
+				break;
+			case GL_TEXTURE_2D_ARRAY:
+			case GL_TEXTURE_3D:
 				{
-					ANKI_ASSERT(data.getSize() > 0);
-						
-					glCompressedTexImage3D(
-						m_target, 
-						level, 
-						m_internalFormat,
-						w, 
-						h, 
-						m_depth, 
-						0, 
-						data.getSize(), 
-						(data.getSize() > 0) ? &data[0] : nullptr);
+					ANKI_ASSERT(m_depth > 0);
+
+					// Gather the data
+					DArrayAuto<U8, GlAllocator<U8>> data(alloc);
+
+					// Check if there are data
+					if(init.m_data[level][0].m_ptr != nullptr)
+					{
+						PtrSize layerSize = init.m_data[level][0].m_size;
+						ANKI_ASSERT(layerSize > 0);
+						Error err = data.create(layerSize * m_depth);
+						if(err)
+						{
+							return err;
+						}
+
+						for(U d = 0; d < m_depth; d++)
+						{
+							ANKI_ASSERT(
+								init.m_data[level][d].m_size == layerSize
+								&& init.m_data[level][d].m_ptr != nullptr);
+
+							memcpy(&data[0] + d * layerSize, 
+								init.m_data[level][d].m_ptr, 
+								layerSize);
+						}
+					}
+
+					if(!compressed)
+					{
+						glTexSubImage3D(
+							m_target, 
+							level, 
+							0,
+							0,
+							0,
+							w, 
+							h, 
+							m_depth,
+							format, 
+							type, 
+							&data[0]);
+					}
+					else
+					{							
+						glCompressedTexSubImage3D(
+							m_target, 
+							level, 
+							0,
+							0,
+							0,
+							w, 
+							h, 
+							m_depth, 
+							format, 
+							data.getSize(), 
+							&data[0]);
+					}
 				}
+				break;
+			default:
+				ANKI_ASSERT(0);
 			}
-			break;
-#if ANKI_GL == ANKI_GL_DESKTOP
-		case GL_TEXTURE_2D_MULTISAMPLE:
-			glTexImage2DMultisample(
-				m_target,
-				m_samples,
-				m_internalFormat,
-				w,
-				h,
-				GL_FALSE);
-			break;
-#endif
-		default:
-			ANKI_ASSERT(0);
-		}
 
-		w /= 2;
-		h /= 2;
-	}
+			w /= 2;
+			h /= 2;
+		}
+	} // end if data
 
 	// Set parameters
 	if(m_samples == 1)
@@ -235,16 +326,9 @@ Error GlTexture::create(const Initializer& init,
 			glTexParameteri(m_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 		}
 
-		if(init.m_genMipmaps)
-		{
-			glGenerateMipmap(m_target);
-		}
-		else
-		{
-			// Make sure that the texture is complete
-			glTexParameteri(
-				m_target, GL_TEXTURE_MAX_LEVEL, init.m_mipmapsCount - 1);
-		}
+		// Make sure that the texture is complete
+		glTexParameteri(
+			m_target, GL_TEXTURE_MAX_LEVEL, init.m_mipmapsCount - 1);
 
 		// Set filtering type
 		setFilterNoBind(init.m_filterType);

src/renderer/Renderer.cpp

@@ -295,13 +295,10 @@ Error Renderer::createRenderTarget(U32 w, U32 h, GLenum internalFormat,
 	init.m_target = GL_TEXTURE_2D;
 #endif
 	init.m_internalFormat = internalFormat;
-	init.m_format = format;
-	init.m_type = type;
 	init.m_mipmapsCount = 1;
 	init.m_filterType = GlTextureHandle::Filter::NEAREST;
 	init.m_repeat = false;
 	init.m_anisotropyLevel = 0;
-	init.m_genMipmaps = false;
 	init.m_samples = samples;
 
 	GlCommandBufferHandle cmdBuff;

src/renderer/Sm.cpp

@@ -44,9 +44,7 @@ Error Sm::init(const ConfigSet& initializer)
 	sminit.m_width = m_resolution;
 	sminit.m_height = m_resolution;
 	sminit.m_depth = initializer.get("is.sm.maxLights");
-	sminit.m_format = GL_DEPTH_COMPONENT;
 	sminit.m_internalFormat = GL_DEPTH_COMPONENT16;
-	sminit.m_type = GL_UNSIGNED_SHORT;
 	sminit.m_mipmapsCount = 1;
 	if(m_bilinearEnabled)
 	{

src/renderer/Ssao.cpp

@@ -71,7 +71,7 @@ Error Ssao::createFb(GlFramebufferHandle& fb, GlTextureHandle& rt)
 {
 	Error err = ErrorCode::NONE;
 
-	err = m_r->createRenderTarget(m_width, m_height, GL_RED, GL_RED, 
+	err = m_r->createRenderTarget(m_width, m_height, GL_R8, GL_RED, 
 		GL_UNSIGNED_BYTE, 1, rt);
 	if(err) return err;
 
@@ -143,8 +143,6 @@ Error Ssao::initInternal(const ConfigSet& config)
 	tinit.m_width = tinit.m_height = NOISE_TEX_SIZE;
 	tinit.m_target = GL_TEXTURE_2D;
 	tinit.m_internalFormat = GL_RGB32F;
-	tinit.m_format = GL_RGB;
-	tinit.m_type = GL_FLOAT;
 	tinit.m_filterType = GlTextureHandle::Filter::NEAREST;
 	tinit.m_repeat = true;
 	tinit.m_mipmapsCount = 1;

src/resource/TextureResource.cpp

@@ -40,7 +40,6 @@ Error TextureResource::load(const CString& filename, ResourceInitializer& rinit)
 
 	GlTextureHandle::Initializer init;
 	U layers = 0;
-	Bool driverShouldGenMipmaps = false;
 
 	// Load image
 	Image* img = rinit.m_alloc.newInstance<Image>(rinit.m_alloc);
@@ -101,7 +100,6 @@ Error TextureResource::load(const CString& filename, ResourceInitializer& rinit)
 		{
 		case Image::DataCompression::RAW:
 			init.m_internalFormat = GL_RGB;
-			driverShouldGenMipmaps = true;
 			break;
 #if ANKI_GL == ANKI_GL_DESKTOP
 		case Image::DataCompression::S3TC:
@@ -122,7 +120,6 @@ Error TextureResource::load(const CString& filename, ResourceInitializer& rinit)
 		{
 		case Image::DataCompression::RAW:
 			init.m_internalFormat = GL_RGBA;
-			driverShouldGenMipmaps = true;
 			break;
 #if ANKI_GL == ANKI_GL_DESKTOP
 		case Image::DataCompression::S3TC:
@@ -142,22 +139,6 @@ Error TextureResource::load(const CString& filename, ResourceInitializer& rinit)
 		ANKI_ASSERT(0);
 	}
 
-	// format
-	switch(img->getColorFormat())
-	{
-	case Image::ColorFormat::RGB8:
-		init.m_format = GL_RGB;
-		break;
-	case Image::ColorFormat::RGBA8:
-		init.m_format = GL_RGBA;
-		break;
-	default:
-		ANKI_ASSERT(0);
-	}
-
-	// type
-	init.m_type = GL_UNSIGNED_BYTE;
-
 	// mipmapsCount
 	init.m_mipmapsCount = img->getMipLevelsCount();
 
@@ -170,16 +151,6 @@ Error TextureResource::load(const CString& filename, ResourceInitializer& rinit)
 	// anisotropyLevel
 	init.m_anisotropyLevel = rinit.m_resources.getTextureAnisotropy();
 
-	// genMipmaps
-	if(init.m_mipmapsCount == 1 || driverShouldGenMipmaps)
-	{
-		init.m_genMipmaps = true;
-	}
-	else
-	{
-		init.m_genMipmaps = false;
-	}
-
 	// Now assign the data
 	for(U layer = 0; layer < layers; layer++)
 	{

testapp/Main.cpp

@@ -49,7 +49,7 @@ Error init()
 	MainRenderer& renderer = app->getMainRenderer();
 	ResourceManager& resources = app->getResourceManager();
 
-	scene.setAmbientColor(Vec4(0.1, 0.05, 0.05, 0.0) * 3);
+	scene.setAmbientColor(Vec4(0.1, 0.05, 0.05, 0.0) * 0.0);
 
 	if(getenv("PROFILE"))
 	{
@@ -526,7 +526,7 @@ Error initSubsystems(int argc, char* argv[])
 	config.set("is.sm.enabled", true);
 	config.set("is.sm.poissonEnabled", true);
 	config.set("is.sm.resolution", 1024);
-	config.set("pps.enabled", true);
+	config.set("pps.enabled", false);
 	config.set("pps.hdr.enabled", true);
 	config.set("pps.hdr.renderingQuality", 0.5);
 	config.set("pps.hdr.blurringDist", 1.0);