most assets should convert (todo: shaders)

Author: malytomas

cmake/cage_assets.cmake

@@ -47,7 +47,6 @@ function(cage_assets_init)
 	endif()
 	cage_assets_add_schemes_path("${cage_assets_current_list_dir}/../schemes")
 	cage_assets_add_data_path("${cage_assets_current_list_dir}/../data")
-	configure_file("${cage_assets_current_list_dir}/../sources/include/cage-engine/shaderConventions.h" "${cage_assets_intermediate_path}/data/cage/shaders/" COPYONLY)
 	cage_assets_generate_config()
 endfunction(cage_assets_init)
 

data/cage/textures/textures.assets

@@ -16,7 +16,6 @@ helper.jpg
 
 []
 scheme = texture
-target = 2dArray
 srgb = true
 progressbar/$.png
 

schemes/texture.scheme

@@ -5,8 +5,8 @@ index = 11
 [target]
 display = texture type
 type = enum
-values = 2d, 3d, 2dArray, cubeMap
-default = 2d
+values = regular, cubeMap, volume
+default = regular
 
 [channels]
 display = change channels count
@@ -16,6 +16,11 @@ min = 0
 max = 4
 default = 0
 
+[mipmaps]
+display = generate mipmaps
+type = bool
+default = true
+
 [convert]
 display = re-purpose the texture
 type = enum
@@ -68,59 +73,3 @@ default = bcn
 display = vertical flip
 type = bool
 default = false
-
-[invertRed]
-display = invert red channel
-type = bool
-default = false
-
-[invertGreen]
-display = invert green channel
-type = bool
-default = false
-
-[invertBlue]
-display = invert blue channel
-type = bool
-default = false
-
-[invertAlpha]
-display = invert alpha channel
-type = bool
-default = false
-
-[filterMin]
-display = minification filter
-type = enum
-values = nearestMipmapNearest, linearMipmapNearest, nearestMipmapLinear, linearMipmapLinear, nearest, linear
-default = linearMipmapLinear
-
-[filterMag]
-display = magnification filter
-type = enum
-values = nearest, linear
-default = linear
-
-[filterAniso]
-display = anisotropic filter
-type = enum
-values = 0, 2, 4, 8, 16, 32, 64
-default = 16
-
-[wrapX]
-display = wrap x
-type = enum
-values = clampToEdge, clampToBorder, mirroredRepeat, repeat
-default = repeat
-
-[wrapY]
-display = wrap y
-type = enum
-values = clampToEdge, clampToBorder, mirroredRepeat, repeat
-default = repeat
-
-[wrapZ]
-display = wrap z
-type = enum
-values = clampToEdge, clampToBorder, mirroredRepeat, repeat
-default = repeat

sources/asset-processor/font.cpp

@@ -6,6 +6,7 @@
 #include FT_FREETYPE_H
 #include <msdfgen/ext/import-font.h>
 #include <msdfgen/msdfgen.h>
+#include <webgpu/webgpu_cpp.h>
 
 #include "processor.h"
 
@@ -16,7 +17,7 @@
 #include <cage-core/imageAlgorithms.h>
 #include <cage-core/rectPacking.h>
 #include <cage-core/tasks.h>
-//#include <cage-engine/texture.h>
+#include <cage-engine/texture.h>
 
 #define FT_CALL(FNC, ...) \
 	if (const FT_Error err = FNC(__VA_ARGS__)) \
@@ -208,27 +209,11 @@ namespace
 	void saveTexture(uint32 index, const Image *img)
 	{
 		TextureHeader data;
-		detail::memset(&data, 0, sizeof(TextureHeader));
-		/*
-		data.target = GL_TEXTURE_2D;
 		data.resolution = Vec3i(img->width(), img->height(), 1);
 		data.channels = img->channels();
-		data.filterMin = GL_LINEAR;
-		data.filterMag = GL_LINEAR;
-		data.filterAniso = 0;
-		data.wrapX = GL_CLAMP_TO_EDGE;
-		data.wrapY = GL_CLAMP_TO_EDGE;
-		data.wrapZ = GL_CLAMP_TO_EDGE;
-		data.swizzle[0] = TextureSwizzleEnum::R;
-		data.swizzle[1] = TextureSwizzleEnum::G;
-		data.swizzle[2] = TextureSwizzleEnum::B;
-		data.swizzle[3] = TextureSwizzleEnum::A;
-		data.containedLevels = 1;
-		data.mipmapLevels = 1;
-		data.copyType = GL_UNSIGNED_BYTE;
-		data.internalFormat = GL_RGB8;
-		data.copyFormat = GL_RGB;
-		*/
+		data.mipLevels = 1;
+		data.usage = (uint64)(wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::TextureBinding);
+		data.format = (uint32)wgpu::TextureFormat::RGBA8Unorm;
 
 		MemoryBuffer inputBuffer;
 		Serializer ser(inputBuffer);
@@ -238,7 +223,7 @@ namespace
 		ser.write(bufferCast(img->rawViewU8()));
 
 		AssetHeader h = processor->initializeAssetHeader();
-		//h.scheme = AssetSchemeIndexTexture;
+		h.scheme = AssetSchemeIndexTexture;
 		h.originalSize = inputBuffer.size();
 		Holder<PointerRange<char>> outputBuffer = memoryCompress(inputBuffer);
 		h.compressedSize = outputBuffer.size();

sources/asset-processor/model.cpp

@@ -9,7 +9,7 @@
 #include <cage-core/meshAlgorithms.h>
 #include <cage-core/meshImport.h>
 #include <cage-core/skeletalAnimation.h>
-#include <cage-engine/shaderConventions.h>
+#include <cage-engine/model.h>
 
 MeshImportConfig meshImportConfig()
 {
@@ -164,26 +164,9 @@ uint32 meshImportSelectIndex(const MeshImportResult &result)
 
 namespace
 {
-	enum class ModelDataFlags : uint32
+	void setFlags(MeshComponentsFlags &flags, MeshComponentsFlags idx, bool available, const char *name)
 	{
-		None = 0,
-		Normals = 1 << 0,
-		Bones = 1 << 1,
-		Uvs2 = 1 << 2,
-		Uvs3 = 1 << 3,
-	};
-}
-
-namespace cage
-{
-	GCHL_ENUM_BITS(ModelDataFlags);
-}
-
-namespace
-{
-	void setFlags(ModelDataFlags &flags, ModelDataFlags idx, bool available, const char *name)
-	{
-		bool requested = toBool(processor->property(name));
+		const bool requested = toBool(processor->property(name));
 		if (requested && !available)
 		{
 			CAGE_LOG_THROW(cage::String("requested feature: ") + name);
@@ -219,13 +202,13 @@ namespace
 		}
 	}
 
-	void validateFlags(const ModelHeader &dsm, const ModelDataFlags flags, const MeshRenderFlags renderFlags, const MeshImportMaterial &mat)
+	void validateFlags(const ModelHeader &dsm, const MeshComponentsFlags flags, const MeshRenderFlags renderFlags, const MeshImportMaterial &mat)
 	{
 		{
 			uint32 texCount = 0;
 			for (uint32 i = 0; i < MaxTexturesCountPerMaterial; i++)
 				texCount += dsm.textureNames[i] == 0 ? 0 : 1;
-			if (texCount && none(flags & (ModelDataFlags::Uvs2 | ModelDataFlags::Uvs3)))
+			if (texCount && none(flags & (MeshComponentsFlags::Uvs2 | MeshComponentsFlags::Uvs3)))
 			{
 				if (dsm.shaderName)
 					CAGE_LOG(SeverityEnum::Warning, "assetProcessor", "material has a texture but no uvs");
@@ -237,7 +220,7 @@ namespace
 		if (any(renderFlags & MeshRenderFlags::CutOut) + any(renderFlags & MeshRenderFlags::Transparent) + any(renderFlags & MeshRenderFlags::Fade) > 1)
 			CAGE_THROW_ERROR(Exception, "material has multiple transparency flags (cutOut, transparent, fade)");
 
-		if (dsm.textureNames[CAGE_SHADER_TEXTURE_NORMAL] != 0 && none(flags & ModelDataFlags::Normals))
+		if (dsm.textureNames[2] != 0 && none(flags & MeshComponentsFlags::Normals))
 			CAGE_THROW_ERROR(Exception, "model uses normal map texture but has no normals");
 	}
 
@@ -301,29 +284,29 @@ void processModel()
 	if (part.mesh->verticesCount() == 0)
 		CAGE_THROW_ERROR(Exception, "the mesh is empty");
 
-	ModelDataFlags flags = ModelDataFlags::None;
-	setFlags(flags, ModelDataFlags::Uvs2, !part.mesh->uvs().empty() || !part.mesh->uvs3().empty(), "uvs");
-	setFlags(flags, ModelDataFlags::Normals, !part.mesh->normals().empty(), "normals");
-	setFlags(flags, ModelDataFlags::Bones, !part.mesh->boneIndices().empty(), "bones");
+	MeshComponentsFlags flags = MeshComponentsFlags::None;
+	setFlags(flags, MeshComponentsFlags::Uvs2, !part.mesh->uvs().empty() || !part.mesh->uvs3().empty(), "uvs");
+	setFlags(flags, MeshComponentsFlags::Normals, !part.mesh->normals().empty(), "normals");
+	setFlags(flags, MeshComponentsFlags::Bones, !part.mesh->boneIndices().empty(), "bones");
 
 	if (!part.mesh->uvs3().empty())
 	{
 		CAGE_ASSERT(part.mesh->uvs().empty());
-		flags &= ~ModelDataFlags::Uvs2;
-		flags |= ModelDataFlags::Uvs3;
+		flags &= ~MeshComponentsFlags::Uvs2;
+		flags |= MeshComponentsFlags::Uvs3;
 	}
-	if (any(flags & ModelDataFlags::Uvs2))
+	if (any(flags & MeshComponentsFlags::Uvs2))
 		CAGE_LOG(SeverityEnum::Info, "assetProcessor", "using 2D uvs");
-	if (any(flags & ModelDataFlags::Uvs3))
+	if (any(flags & MeshComponentsFlags::Uvs3))
 		CAGE_LOG(SeverityEnum::Info, "assetProcessor", "using 3D uvs");
 
-	if (none(flags & ModelDataFlags::Uvs2))
+	if (none(flags & MeshComponentsFlags::Uvs2))
 		part.mesh->uvs({});
-	if (none(flags & ModelDataFlags::Uvs3))
+	if (none(flags & MeshComponentsFlags::Uvs3))
 		part.mesh->uvs3({});
-	if (none(flags & ModelDataFlags::Normals))
+	if (none(flags & MeshComponentsFlags::Normals))
 		part.mesh->normals({});
-	if (none(flags & ModelDataFlags::Bones))
+	if (none(flags & MeshComponentsFlags::Bones))
 	{
 		part.mesh->boneIndices(PointerRange<Vec4i>());
 		part.mesh->boneWeights(PointerRange<Vec4>());
@@ -342,13 +325,13 @@ void processModel()
 		switch (t.type)
 		{
 			case MeshImportTextureType::Albedo:
-				dsm.textureNames[CAGE_SHADER_TEXTURE_ALBEDO] = n;
+				dsm.textureNames[0] = n;
 				break;
 			case MeshImportTextureType::Special:
-				dsm.textureNames[CAGE_SHADER_TEXTURE_SPECIAL] = n;
+				dsm.textureNames[1] = n;
 				break;
 			case MeshImportTextureType::Normal:
-				dsm.textureNames[CAGE_SHADER_TEXTURE_NORMAL] = n;
+				dsm.textureNames[2] = n;
 				break;
 			case MeshImportTextureType::Custom:
 				dsm.textureNames[3] = n;
@@ -388,7 +371,7 @@ void processModel()
 			h.dependenciesCount++;
 	h.dependenciesCount += !!dsm.shaderName;
 
-	cage::MemoryBuffer buffer;
+	MemoryBuffer buffer;
 	Serializer ser(buffer);
 	ser << dsm;
 	ser << mat;

sources/asset-processor/processor.h

@@ -1,5 +1,6 @@
 #include <cage-core/assetHeader.h>
 #include <cage-core/assetProcessor.h>
+#include <cage-core/assetsSchemes.h>
 #include <cage-core/config.h>
 #include <cage-core/files.h>
 #include <cage-core/geometry.h>
@@ -8,7 +9,8 @@
 #include <cage-core/memoryCompression.h>
 #include <cage-core/serialization.h>
 #include <cage-core/string.h>
-#include <cage-engine/assetStructs.h>
+#include <cage-engine/assetsSchemes.h>
+#include <cage-engine/assetsStructs.h>
 
 using namespace cage;
 

sources/asset-processor/shader.cpp

@@ -7,7 +7,6 @@
 
 #include <cage-core/hashString.h>
 #include <cage-core/timer.h>
-#include <cage-engine/assetStructs.h>
 
 namespace
 {
@@ -242,20 +241,12 @@ namespace
 
 	uint32 shaderType(const String &name)
 	{
-		/*
 		if (name == "vertex")
-			return GL_VERTEX_SHADER;
+			return 1;
 		if (name == "fragment")
-			return GL_FRAGMENT_SHADER;
-		if (name == "geometry")
-			return GL_GEOMETRY_SHADER;
-		if (name == "control")
-			return GL_TESS_CONTROL_SHADER;
-		if (name == "evaluation")
-			return GL_TESS_EVALUATION_SHADER;
+			return 2;
 		if (name == "compute")
-			return GL_COMPUTE_SHADER;
-		*/
+			return 3;
 		return 0;
 	}
 
@@ -267,13 +258,6 @@ namespace
 		return true;
 	}
 
-	bool allowParsingHash()
-	{
-		if (defines.count("allowParsingHash") == 0)
-			return false;
-		return toBool(defines["allowParsingHash"]);
-	}
-
 	void parse(const String &filename)
 	{
 		Holder<File> file = readFile(filename);
@@ -292,7 +276,7 @@ namespace
 						output("");
 					continue;
 				}
-				if (line[0] == '$' || (allowParsingHash() && line[0] == '#'))
+				if (line[0] == '$')
 				{
 					line = trim(subString(line, 1, m));
 					String cmd = split(line);
@@ -481,9 +465,8 @@ void processShader()
 	}
 
 	{
-		ShaderProgramHeader header;
-		header.keywordsCount = keywords.size();
-		header.stagesCount = codes.size();
+		MultiShaderHeader header;
+		header.variantsCount = codes.size();
 		if (defines.count("customDataCount"))
 		{
 			const uint32 cdc = toUint32(defines["customDataCount"]);
@@ -493,11 +476,13 @@ void processShader()
 		MemoryBuffer buff;
 		Serializer ser(buff);
 		ser << header;
+		/*
 		for (const auto &it : keywords)
 		{
 			CAGE_LOG(SeverityEnum::Info, "assetProcessor", Stringizer() + "keyword: " + it);
 			ser << it;
 		}
+		*/
 		for (const auto &it : codes)
 		{
 			ser << (uint32)shaderType(it.first);