most materials working

malytomas · malytomas · commit e342d0b95b8f · 2025-10-23T15:28:00.000+02:00
diff --git a/data/cage/shaders/engine/fragment.glsl b/data/cage/shaders/engine/fragment.glsl
@@ -248,12 +248,14 @@ void updateNormal()
 {
 	normal = normalize(varNormal);
 
+#if defined(MaterialTexRegular) || defined(MaterialTexArray) || defined(MaterialTexCube)
 	if (uniOptsLights[3] > 0.5)
 	{
 		vec3 normalMap = restoreNormalMap(loadNormalMap());
 		mat3 tbn = makeTangentSpace(normal, varPosition - uniViewport.eyePos.xyz, varUv.xy);
 		normal = tbn * normalMap;
 	}
+#endif
 
 	if (!gl_FrontFacing)
 		normal *= -1;
diff --git a/data/cage/shaders/engine/standard.glsl b/data/cage/shaders/engine/standard.glsl
@@ -33,7 +33,6 @@ void main()
 		discard;
 #endif // CutOut
 	outColor = lighting(material);
-	outColor = vec4(material.albedo, 1); // todo remove debug
 
 #endif // DepthOnly
 }
diff --git a/schemes/texture.scheme b/schemes/texture.scheme
@@ -73,3 +73,33 @@ default = bcn
 display = vertical flip
 type = bool
 default = false
+
+[sampleFilter]
+display = sampling filter
+type = enum
+values = nearest, linear
+default = linear
+
+[anisoFilter]
+display = anisotropic filter
+type = enum
+values = 0, 2, 4, 8, 16, 32, 64
+default = 16
+
+[wrapX]
+display = wrap x
+type = enum
+values = clamp, repeat, mirror
+default = repeat
+
+[wrapY]
+display = wrap y
+type = enum
+values = clamp, repeat, mirror
+default = repeat
+
+[wrapZ]
+display = wrap z
+type = enum
+values = clamp, repeat, mirror
+default = repeat
diff --git a/sources/asset-processor/texture.cpp b/sources/asset-processor/texture.cpp
@@ -14,6 +14,26 @@ void meshImportNotifyUsedFiles(const MeshImportResult &result);
 
 namespace
 {
+	wgpu::FilterMode convertFilter(const String &f)
+	{
+		if (f == "nearest")
+			return wgpu::FilterMode::Nearest;
+		if (f == "linear")
+			return wgpu::FilterMode::Linear;
+		return wgpu::FilterMode::Undefined;
+	}
+
+	wgpu::AddressMode convertWrap(const String &f)
+	{
+		if (f == "clamp")
+			return wgpu::AddressMode::ClampToEdge;
+		if (f == "repeat")
+			return wgpu::AddressMode::Repeat;
+		if (f == "mirror")
+			return wgpu::AddressMode::MirrorRepeat;
+		return wgpu::AddressMode::Undefined;
+	}
+
 	TextureFlags convertTarget()
 	{
 		TextureFlags result = TextureFlags::None;
@@ -269,6 +289,7 @@ namespace
 			}
 		}
 		images.parts = std::move(parts);
+		images.sort();
 	}
 
 	void checkConsistency(const TextureFlags target)
@@ -311,6 +332,9 @@ namespace
 	{
 		CAGE_LOG(SeverityEnum::Info, "assetProcessor", "using bcn encoding");
 
+		if ((data.resolution[0] % 4) != 0 || (data.resolution[1] % 4) != 0)
+			CAGE_THROW_ERROR(Exception, "base image resolution for bcn encoding must be divisible by 4");
+
 		data.usage = (uint64)wgpu::TextureUsage::CopyDst | (uint64)wgpu::TextureUsage::TextureBinding;
 		data.format = (uint32)findInternalFormatForBcn(data);
 
@@ -378,6 +402,14 @@ namespace
 		header.resolution = Vec3i(images.parts[0].image->width(), images.parts[0].image->height(), numeric_cast<uint32>(images.parts.size()));
 		header.channels = images.parts[0].image->channels();
 		header.mipLevels = toBool(processor->property("mipmaps")) ? min(findContainedMipmapLevels(header.resolution, any(target & TextureFlags::Volume3D), any(target & TextureFlags::Compressed)), 8u) : 1;
+		header.sampleFilter = (uint32)convertFilter(processor->property("sampleFilter"));
+		header.mipmapFilter = (uint32)(header.mipLevels > 1 ? wgpu::MipmapFilterMode::Linear : wgpu::MipmapFilterMode::Nearest);
+		header.anisoFilter = toUint32(processor->property("anisoFilter"));
+		if (header.sampleFilter != (uint32)wgpu::FilterMode::Linear || header.mipmapFilter != (uint32)wgpu::MipmapFilterMode::Linear)
+			header.anisoFilter = 1;
+		header.wrapX = (uint32)convertWrap(processor->property("wrapX"));
+		header.wrapY = (uint32)convertWrap(processor->property("wrapY"));
+		header.wrapZ = (uint32)convertWrap(processor->property("wrapZ"));
 
 		// todo
 		if (images.parts[0].image->format() != ImageFormatEnum::U8)
diff --git a/sources/include/cage-core/imageImport.h b/sources/include/cage-core/imageImport.h
@@ -28,6 +28,8 @@ namespace cage
 	struct CAGE_CORE_API ImageImportResult
 	{
 		Holder<PointerRange<ImageImportPart>> parts;
+
+		void sort();
 	};
 
 	CAGE_CORE_API ImageImportResult imageImportBuffer(PointerRange<const char> buffer);
diff --git a/sources/include/cage-engine/assetsStructs.h b/sources/include/cage-engine/assetsStructs.h
@@ -31,6 +31,12 @@ namespace cage
 		uint32 mipLevels = 0;
 		uint64 usage = 0; // wgpu::TextureUsage
 		uint32 format = 0; // wgpu::TextureFormat
+		uint32 sampleFilter = 0; // wgpu::FilterMode
+		uint32 mipmapFilter = 0; // wgpu::MipmapFilterMode
+		uint32 anisoFilter = 1;
+		uint32 wrapX = 0; // wgpu::AddressMode
+		uint32 wrapY = 0; // wgpu::AddressMode
+		uint32 wrapZ = 0; // wgpu::AddressMode
 
 		// follows:
 		// for each mipmap level:
diff --git a/sources/include/cage-engine/graphicsEncoder.h b/sources/include/cage-engine/graphicsEncoder.h
@@ -53,6 +53,7 @@ namespace cage
 		uint32 instances = 1;
 		wgpu::CompareFunction depthTest = wgpu::CompareFunction::Less;
 		bool depthWrite = true;
+		bool backFaceCulling = true;
 		BlendingEnum blending = BlendingEnum::None;
 	};
 
diff --git a/sources/libcore/image/dds.cpp b/sources/libcore/image/dds.cpp
@@ -161,6 +161,7 @@ namespace cage
 		parts.push_back(std::move(part));
 		ImageImportResult result;
 		result.parts = std::move(parts);
+		result.sort();
 		return result;
 	}
 
diff --git a/sources/libcore/image/imageIo.cpp b/sources/libcore/image/imageIo.cpp
@@ -1,3 +1,5 @@
+#include <algorithm>
+
 #include "image.h"
 
 #include <cage-core/files.h>
@@ -150,4 +152,14 @@ namespace cage
 			return ddsDecode(buffer);
 		return decodeSingle(buffer);
 	}
+
+	void ImageImportResult::sort()
+	{
+		std::sort(parts.begin(), parts.end(),
+			[](const ImageImportPart &a, const ImageImportPart &b)
+			{
+				const auto &cmp = [](const ImageImportPart &p) { return std::tuple(p.mipmapLevel, p.cubeFace, p.layer, p.fileName); };
+				return cmp(a) < cmp(b);
+			});
+	}
 }
diff --git a/sources/libengine/assets/texture.cpp b/sources/libengine/assets/texture.cpp
@@ -78,6 +78,8 @@ namespace cage
 			TextureHeader header;
 			des >> header;
 
+			Holder<wgpu::Device> dev = ((GraphicsDevice *)context->device)->nativeDevice();
+
 			wgpu::TextureDescriptor desc = {};
 			desc.dimension = any(header.flags & TextureFlags::Volume3D) ? wgpu::TextureDimension::e3D : wgpu::TextureDimension::e2D;
 			static_assert(sizeof(desc.usage) == sizeof(header.usage));
@@ -87,13 +89,29 @@ namespace cage
 			desc.mipLevelCount = header.mipLevels;
 			desc.size = { numeric_cast<uint32>(header.resolution[0]), numeric_cast<uint32>(header.resolution[1]), numeric_cast<uint32>(header.resolution[2]) };
 			desc.label = context->textId.c_str();
-			Holder<wgpu::Device> dev = ((GraphicsDevice *)context->device)->nativeDevice();
 			wgpu::Texture wtex = dev->CreateTexture(&desc);
+
 			wgpu::TextureViewDescriptor twd = {};
 			twd.dimension = textureViewDimension(header.flags);
-			Holder<Texture> tex = newTexture(wtex, wtex.CreateView(&twd), dev->CreateSampler(), context->textId);
-			dev.clear();
+			twd.label = context->textId.c_str();
+			wgpu::TextureView view = wtex.CreateView(&twd);
+
+			wgpu::SamplerDescriptor sd = {};
+			static_assert(sizeof(sd.magFilter) == sizeof(header.sampleFilter));
+			sd.magFilter = (wgpu::FilterMode)header.sampleFilter;
+			sd.minFilter = (wgpu::FilterMode)header.sampleFilter;
+			static_assert(sizeof(sd.mipmapFilter) == sizeof(header.mipmapFilter));
+			sd.mipmapFilter = (wgpu::MipmapFilterMode)header.mipmapFilter;
+			sd.maxAnisotropy = header.anisoFilter;
+			static_assert(sizeof(sd.addressModeU) == sizeof(header.wrapX));
+			sd.addressModeU = (wgpu::AddressMode)header.wrapX;
+			sd.addressModeV = (wgpu::AddressMode)header.wrapY;
+			sd.addressModeW = (wgpu::AddressMode)header.wrapZ;
+			sd.label = context->textId.c_str();
+			wgpu::Sampler samp = dev->CreateSampler(&sd);
 
+			dev.clear();
+			Holder<Texture> tex = newTexture(wtex, view, samp, context->textId);
 			tex->flags = header.flags;
 
 			Holder<wgpu::Queue> queue = ((GraphicsDevice *)context->device)->nativeQueue();
diff --git a/sources/libengine/graphics/device.cpp b/sources/libengine/graphics/device.cpp
@@ -88,6 +88,61 @@ namespace cage
 			Holder<DevicePipelinesCache> pipelinesCache;
 			Holder<Texture> texDummy2d, texDummyArray, texDummyCube;
 
+			void generateDummyTextures()
+			{
+				ColorTextureCreateConfig cfg;
+				cfg.resolution = Vec3i(1);
+				cfg.channels = 4;
+				cfg.mipLevels = 1;
+				texDummy2d = newTexture(this, cfg, "dummy2d");
+				cfg.flags = TextureFlags::Array;
+				texDummyArray = newTexture(this, cfg, "dummyArray");
+				cfg.resolution[2] = 6;
+				cfg.flags = TextureFlags::Cubemap;
+				texDummyCube = newTexture(this, cfg, "dummyCube");
+
+				wgpu::TexelCopyTextureInfo dest = {};
+				dest.texture = texDummy2d->nativeTexture();
+				dest.mipLevel = 0;
+				dest.aspect = wgpu::TextureAspect::All;
+				wgpu::TexelCopyBufferLayout layout = {};
+				layout.bytesPerRow = 4;
+				layout.rowsPerImage = 1;
+				wgpu::Extent3D extents = { 1, 1, 1 };
+				static constexpr std::array<unsigned char, 4 * 6> data = {
+					0,
+					0,
+					0,
+					255,
+					0,
+					0,
+					0,
+					255,
+					0,
+					0,
+					0,
+					255,
+					0,
+					0,
+					0,
+					255,
+					0,
+					0,
+					0,
+					255,
+					0,
+					0,
+					0,
+					255,
+				};
+				queue.WriteTexture(&dest, data.data(), data.size(), &layout, &extents);
+				dest.texture = texDummyArray->nativeTexture();
+				queue.WriteTexture(&dest, data.data(), data.size(), &layout, &extents);
+				dest.texture = texDummyCube->nativeTexture();
+				extents.depthOrArrayLayers = 6;
+				queue.WriteTexture(&dest, data.data(), data.size(), &layout, &extents);
+			}
+
 			GraphicsDeviceImpl(const GraphicsDeviceCreateConfig &config)
 			{
 				{
@@ -165,19 +220,7 @@ namespace cage
 
 				bindingsCache = newDeviceBindingsCache(this);
 				pipelinesCache = newDevicePipelinesCache(this);
-
-				{
-					ColorTextureCreateConfig cfg;
-					cfg.resolution = Vec3i(1);
-					cfg.channels = 4;
-					cfg.mipLevels = 1;
-					texDummy2d = newTexture(this, cfg, "dummy2d");
-					cfg.flags = TextureFlags::Array;
-					texDummyArray = newTexture(this, cfg, "dummyArray");
-					cfg.resolution[2] = 6;
-					cfg.flags = TextureFlags::Cubemap;
-					texDummyCube = newTexture(this, cfg, "dummyCube");
-				}
+				generateDummyTextures();
 
 				CAGE_LOG(SeverityEnum::Info, "graphics", "wgpu initialized");
 			}
diff --git a/sources/libengine/graphics/encoder.cpp b/sources/libengine/graphics/encoder.cpp
@@ -33,6 +33,7 @@ namespace cage
 			wgpu::TextureFormat depthFormat = wgpu::TextureFormat::Undefined;
 			wgpu::CompareFunction depthTest = wgpu::CompareFunction::Less;
 			bool depthWrite = true;
+			bool backFaceCulling = true;
 			BlendingEnum blending = BlendingEnum::None;
 
 			std::size_t hash = 0;
@@ -53,6 +54,7 @@ namespace cage
 					depthTest = config.depthTest;
 					depthWrite = config.depthWrite;
 				}
+				backFaceCulling = config.backFaceCulling;
 				blending = config.blending;
 
 				auto hashCombine = [&](std::unsigned_integral auto v) { hash ^= std::hash<std::decay_t<decltype(v)>>{}(v) + 0x9e3779b9 + (hash << 6) + (hash >> 2); };
@@ -65,7 +67,7 @@ namespace cage
 				hashCombine((uint32)meshComponents);
 				hashCombine((uint32)depthTest);
 				hashCombine((uint32)depthFormat);
-				hashCombine(depthWrite);
+				hashCombine((uint32(depthWrite) << 1) + uint32(backFaceCulling));
 				hashCombine((uint32)blending);
 			}
 
@@ -139,7 +141,7 @@ namespace cage
 			rpd.vertex.module = config.shader->nativeVertex();
 			rpd.vertex.bufferCount = 1;
 			rpd.vertex.buffers = &config.model->getLayout();
-			rpd.primitive.cullMode = wgpu::CullMode::None;
+			rpd.primitive.cullMode = config.backFaceCulling ? wgpu::CullMode::Back : wgpu::CullMode::None;
 			if (passData.depthTarget)
 				rpd.depthStencil = &dss;
 			rpd.fragment = &fs;
diff --git a/sources/libengine/graphics/model.cpp b/sources/libengine/graphics/model.cpp
@@ -48,18 +48,18 @@ namespace cage
 				if (any(components & MeshComponentsFlags::Bones))
 				{
 					attrs[index].offset = layout.arrayStride;
-					attrs[index].format = wgpu::VertexFormat::Float32x4;
+					attrs[index].format = wgpu::VertexFormat::Uint32x4;
 					attrs[index].shaderLocation = 2;
 					index++;
-					layout.arrayStride += sizeof(Vec4);
+					layout.arrayStride += sizeof(Vec4i);
 				}
 				if (any(components & MeshComponentsFlags::Bones))
 				{
 					attrs[index].offset = layout.arrayStride;
-					attrs[index].format = wgpu::VertexFormat::Uint32x4;
+					attrs[index].format = wgpu::VertexFormat::Float32x4;
 					attrs[index].shaderLocation = 3;
 					index++;
-					layout.arrayStride += sizeof(Vec4i);
+					layout.arrayStride += sizeof(Vec4);
 				}
 				CAGE_ASSERT(any(components & MeshComponentsFlags::Uvs3) + any(components & MeshComponentsFlags::Uvs2) < 2)
 				if (any(components & MeshComponentsFlags::Uvs3))
@@ -143,19 +143,19 @@ namespace cage
 			Serializer ser(mem);
 			PointerRange<const Vec3> ps = mesh->positions();
 			PointerRange<const Vec3> ns = mesh->normals();
-			PointerRange<const Vec4> bws = mesh->boneWeights();
 			PointerRange<const Vec4i> bis = mesh->boneIndices();
+			PointerRange<const Vec4> bws = mesh->boneWeights();
 			PointerRange<const Vec3> uv3s = mesh->uvs3();
 			PointerRange<const Vec2> uv2s = mesh->uvs();
 			for (uint32 i = 0; i < cnt; i++)
 			{
 				ser << ps[i];
 				if (!ns.empty())
 					ser << ns[i];
-				if (!bws.empty())
-					ser << bws[i];
 				if (!bis.empty())
 					ser << bis[i];
+				if (!bws.empty())
+					ser << bws[i];
 				if (!uv3s.empty())
 					ser << uv3s[i];
 				if (!uv2s.empty())
diff --git a/sources/libengine/graphics/sceneRender.cpp b/sources/libengine/graphics/sceneRender.cpp
diff --git a/sources/libsimple/gameloop.cpp b/sources/libsimple/gameloop.cpp

Original file line number	Diff line number	Diff line change
`@@ -248,12 +248,14 @@ void updateNormal()`
`248`	`248`	`{`
`249`	`249`	`normal = normalize(varNormal);`
`250`	`250`
	`251`	`+#if defined(MaterialTexRegular) \|\| defined(MaterialTexArray) \|\| defined(MaterialTexCube)`
`251`	`252`	`if (uniOptsLights[3] > 0.5)`
`252`	`253`	`{`
`253`	`254`	`vec3 normalMap = restoreNormalMap(loadNormalMap());`
`254`	`255`	`mat3 tbn = makeTangentSpace(normal, varPosition - uniViewport.eyePos.xyz, varUv.xy);`
`255`	`256`	`normal = tbn * normalMap;`
`256`	`257`	`}`
	`258`	`+#endif`
`257`	`259`
`258`	`260`	`if (!gl_FrontFacing)`
`259`	`261`	`normal *= -1;`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,6 @@ void main()`
`33`	`33`	`discard;`
`34`	`34`	`#endif // CutOut`
`35`	`35`	`outColor = lighting(material);`
`36`		`- outColor = vec4(material.albedo, 1); // todo remove debug`
`37`	`36`
`38`	`37`	`#endif // DepthOnly`
`39`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,8 @@ namespace cage`
`28`	`28`	`struct CAGE_CORE_API ImageImportResult`
`29`	`29`	`{`
`30`	`30`	`Holder<PointerRange<ImageImportPart>> parts;`
	`31`	`+`
	`32`	`+ void sort();`
`31`	`33`	`};`
`32`	`34`
`33`	`35`	`CAGE_CORE_API ImageImportResult imageImportBuffer(PointerRange<const char> buffer);`
Original file line number	Diff line number	Diff line change
`@@ -161,6 +161,7 @@ namespace cage`
`161`	`161`	`parts.push_back(std::move(part));`
`162`	`162`	`ImageImportResult result;`
`163`	`163`	`result.parts = std::move(parts);`
	`164`	`+ result.sort();`
`164`	`165`	`return result;`
`165`	`166`	`}`
`166`	`167`