custom shader data

sources/asset-processor/shader.cpp

@@ -7,6 +7,7 @@
 
 #include <cage-core/hashString.h>
 #include <cage-core/timer.h>
+#include <cage-engine/assetStructs.h>
 #include <cage-engine/opengl.h>
 
 namespace
@@ -16,7 +17,7 @@ namespace
 	std::set<String, StringComparatorFast> onces;
 	std::set<detail::StringBase<20>> keywords;
 
-	ConfigBool configShaderPrint("cage-asset-processor/shader/preview");
+	const ConfigBool configShaderPrint("cage-asset-processor/shader/preview", false);
 
 	bool validDefineChar(const char c)
 	{
@@ -478,15 +479,23 @@ void processShader()
 	}
 
 	{
+		ShaderProgramHeader header;
+		header.keywordsCount = keywords.size();
+		header.stagesCount = codes.size();
+		if (defines.count("customDataCount"))
+		{
+			const uint32 cdc = toUint32(defines["customDataCount"]);
+			CAGE_LOG(SeverityEnum::Info, "assetProcessor", Stringizer() + "custom data count: " + cdc);
+			header.customDataCount = cdc;
+		}
 		MemoryBuffer buff;
 		Serializer ser(buff);
-		ser << numeric_cast<uint32>(keywords.size());
+		ser << header;
 		for (const auto &it : keywords)
 		{
 			CAGE_LOG(SeverityEnum::Info, "assetProcessor", Stringizer() + "keyword: " + it);
 			ser << it;
 		}
-		ser << numeric_cast<uint32>(codes.size());
 		for (const auto &it : codes)
 		{
 			ser << (uint32)shaderType(it.first);

sources/include/cage-engine/assetStructs.h

@@ -8,19 +8,25 @@ namespace cage
 {
 	enum class MeshRenderFlags : uint32;
 
-	/*
+	enum class ShaderProgramFlags : uint32
+	{
+		None = 0,
+	};
+
 	struct CAGE_ENGINE_API ShaderProgramHeader
 	{
+		ShaderProgramFlags flags = ShaderProgramFlags::None;
+		uint32 customDataCount = 0; // number of floats passed from the game to the shader, per instance
+		uint32 keywordsCount = 0;
+		uint32 stagesCount = 0;
+
 		// follows:
-		// number of keywords, uint32
 		// array of keywords, each StringBase<20>
-		// number of stages, uint32
 		// for each stage:
-		//   stage name, uint32
+		//   type, uint32
 		//   length, uint32
-		//   stage code, array of chars
+		//   code, array of chars
 	};
-	*/
 
 	enum class TextureFlags : uint32
 	{

sources/include/cage-engine/font.h

@@ -32,9 +32,8 @@ namespace cage
 
 	class CAGE_ENGINE_API Font : private Immovable
 	{
-#ifdef CAGE_DEBUG
+	protected:
 		detail::StringBase<64> debugName;
-#endif // CAGE_DEBUG
 
 	public:
 		void setDebugName(const String &name);

sources/include/cage-engine/model.h

@@ -10,9 +10,8 @@ namespace cage
 
 	class CAGE_ENGINE_API Model : private Immovable
 	{
-#ifdef CAGE_DEBUG
+	protected:
 		detail::StringBase<64> debugName;
-#endif // CAGE_DEBUG
 
 	public:
 		void setDebugName(const String &name);

sources/include/cage-engine/renderObject.h

@@ -7,9 +7,8 @@ namespace cage
 {
 	class CAGE_ENGINE_API RenderObject : private Immovable
 	{
-#ifdef CAGE_DEBUG
+	protected:
 		detail::StringBase<64> debugName;
-#endif // CAGE_DEBUG
 
 	public:
 		void setDebugName(const String &name);

sources/include/cage-engine/scene.h

@@ -22,6 +22,13 @@ namespace cage
 		uint32 sceneMask = 1;
 	};
 
+	union CAGE_ENGINE_API ShaderDataComponent
+	{
+		Mat4 matrix;
+		Vec4 data[4];
+		ShaderDataComponent() : data() {}
+	};
+
 	struct CAGE_ENGINE_API TextureAnimationComponent
 	{
 		uint64 startTime = 0;

sources/include/cage-engine/shaderConventions.h

@@ -46,6 +46,7 @@
 #define CAGE_SHADER_UNIBLOCK_LIGHTS 4
 #define CAGE_SHADER_UNIBLOCK_SHADOWEDLIGHTS 5
 #define CAGE_SHADER_UNIBLOCK_OPTIONS 6
+#define CAGE_SHADER_UNIBLOCK_CUSTOMDATA 7
 
 // options indices
 

sources/include/cage-engine/shaderProgram.h

@@ -38,6 +38,8 @@ namespace cage
 #undef GCHL_GENERATE
 
 		void compute(const Vec3i &groupsCounts);
+
+		uint32 customDataCount = 0; // number of floats passed from the game to the shader, per instance
 	};
 
 	class CAGE_ENGINE_API MultiShaderProgram : private Immovable
@@ -53,6 +55,8 @@ namespace cage
 		void compile();
 
 		Holder<ShaderProgram> get(uint32 variant); // sum of hashes of keywords
+
+		uint32 customDataCount = 0; // number of floats passed from the game to the shader, per instance
 	};
 
 	CAGE_ENGINE_API Holder<ShaderProgram> newShaderProgram();

sources/include/cage-engine/texture.h

@@ -9,9 +9,8 @@ namespace cage
 
 	class CAGE_ENGINE_API Texture : private Immovable
 	{
-#ifdef CAGE_DEBUG
+	protected:
 		detail::StringBase<64> debugName;
-#endif // CAGE_DEBUG
 
 	public:
 		void setDebugName(const String &name);

sources/libengine/assets/shaderProgram.cpp

@@ -17,28 +17,26 @@ namespace cage
 			shr->setDebugName(context->textId);
 
 			Deserializer des(context->originalData);
+			ShaderProgramHeader header;
+			des >> header;
+			shr->customDataCount = header.customDataCount;
 			{
 				std::vector<detail::StringBase<20>> keywords;
-				uint32 count;
-				des >> count;
-				for (uint32 i = 0; i < count; i++)
+				keywords.reserve(header.keywordsCount);
+				for (uint32 i = 0; i < header.keywordsCount; i++)
 				{
 					detail::StringBase<20> s;
 					des >> s;
 					keywords.push_back(s);
 				}
 				shr->setKeywords(keywords);
 			}
+			for (uint32 i = 0; i < header.stagesCount; i++)
 			{
-				uint32 count;
-				des >> count;
-				for (uint32 i = 0; i < count; i++)
-				{
-					uint32 type, len;
-					des >> type >> len;
-					PointerRange<const char> pos = des.read(len);
-					shr->setSource(type, pos);
-				}
+				uint32 type, len;
+				des >> type >> len;
+				PointerRange<const char> pos = des.read(len);
+				shr->setSource(type, pos);
 			}
 			CAGE_ASSERT(des.available() == 0);
 

sources/libengine/graphics/font.cpp

@@ -492,9 +492,7 @@ namespace cage
 
 	void Font::setDebugName(const String &name)
 	{
-#ifdef CAGE_DEBUG
 		debugName = name;
-#endif // CAGE_DEBUG
 	}
 
 	void Font::importBuffer(PointerRange<const char> buffer)

sources/libengine/graphics/model.cpp

@@ -80,9 +80,7 @@ namespace cage
 
 	void Model::setDebugName(const String &name)
 	{
-#ifdef CAGE_DEBUG
 		debugName = name;
-#endif // CAGE_DEBUG
 		ModelImpl *impl = (ModelImpl *)this;
 		CAGE_ASSERT(impl->id);
 		glObjectLabel(GL_VERTEX_ARRAY, impl->id, name.length(), name.c_str());

sources/libengine/graphics/renderObject.cpp

@@ -19,9 +19,7 @@ namespace cage
 
 	void RenderObject::setDebugName(const String &name)
 	{
-#ifdef CAGE_DEBUG
 		debugName = name;
-#endif // CAGE_DEBUG
 	}
 
 	void RenderObject::setLods(PointerRange<const Real> thresholds, PointerRange<const uint32> modelIndices, PointerRange<const uint32> modelNames)

sources/libengine/graphics/renderPipeline.cpp

@@ -108,6 +108,7 @@ namespace cage
 		{
 			UniMesh uni;
 			Holder<SkeletalAnimationPreparatorInstance> skeletalAnimation;
+			std::optional<Mat4> customShaderData;
 		};
 
 		struct ModelTranslucent : public ModelShared, public ModelInstance
@@ -393,7 +394,7 @@ namespace cage
 			}
 
 			template<RenderModeEnum RenderMode>
-			void renderModelsImpl(const CameraData &data, const ModelShared &sh, const PointerRange<const UniMesh> uniMeshes, const PointerRange<const Mat3x4> uniArmatures, bool translucent) const
+			void renderModelsImpl(const CameraData &data, const ModelShared &sh, const PointerRange<const ModelInstance> instances, const PointerRange<const Mat3x4> uniArmatures, bool translucent) const
 			{
 				const Holder<RenderQueue> &renderQueue = data.renderQueue;
 
@@ -485,12 +486,28 @@ namespace cage
 				renderQueue->universalUniformStruct(uniOptions, CAGE_SHADER_UNIBLOCK_OPTIONS);
 
 				const uint32 limit = sh.skeletal ? min(uint32(CAGE_SHADER_MAX_MESHES), CAGE_SHADER_MAX_BONES / sh.mesh->bones) : CAGE_SHADER_MAX_MESHES;
-				for (uint32 offset = 0; offset < uniMeshes.size(); offset += limit)
+				std::vector<float> customShaderData;
+				std::vector<UniMesh> meshes;
+				for (uint32 offset = 0; offset < instances.size(); offset += limit)
 				{
-					const uint32 count = min(limit, numeric_cast<uint32>(uniMeshes.size()) - offset);
-					renderQueue->universalUniformArray<const UniMesh>(subRange<const UniMesh>(uniMeshes, offset, count), CAGE_SHADER_UNIBLOCK_MESHES);
+					const uint32 count = min(limit, numeric_cast<uint32>(instances.size()) - offset);
+					meshes.resize(count);
+					for (uint32 i = 0; i < count; i++)
+						meshes[i] = instances[offset + i].uni;
+					renderQueue->universalUniformArray<const UniMesh>(meshes, CAGE_SHADER_UNIBLOCK_MESHES);
 					if (sh.skeletal)
 						renderQueue->universalUniformArray<const Mat3x4>(subRange<const Mat3x4>(uniArmatures, offset * sh.mesh->bones, count * sh.mesh->bones), CAGE_SHADER_UNIBLOCK_ARMATURES);
+					if (shader->customDataCount)
+					{
+						CAGE_ASSERT(shader->customDataCount <= 16);
+						customShaderData.resize(shader->customDataCount * count);
+						for (uint32 i = 0; i < count; i++)
+						{
+							if (instances[offset + i].customShaderData)
+								detail::memcpy(customShaderData.data() + i * shader->customDataCount, (float *)&*instances[offset + i].customShaderData, shader->customDataCount * sizeof(float));
+						}
+						renderQueue->universalUniformArray<const float>(customShaderData, CAGE_SHADER_UNIBLOCK_CUSTOMDATA);
+					}
 					renderQueue->draw(sh.mesh, count);
 				}
 
@@ -520,10 +537,6 @@ namespace cage
 							if (none(sh.mesh->flags & MeshRenderFlags::DepthWrite))
 								continue;
 						}
-						std::vector<UniMesh> uniMeshes;
-						uniMeshes.reserve(shit.second.size());
-						for (const ModelInstance &inst : shit.second)
-							uniMeshes.push_back(inst.uni);
 						std::vector<Mat3x4> uniArmatures;
 						if (sh.skeletal)
 						{
@@ -536,7 +549,7 @@ namespace cage
 									uniArmatures.push_back(it);
 							}
 						}
-						renderModelsImpl<RenderMode>(data, sh, uniMeshes, uniArmatures, false);
+						renderModelsImpl<RenderMode>(data, sh, shit.second, uniArmatures, false);
 					}
 					renderQueue->resetAllState();
 					renderQueue->viewport(Vec2i(), data.resolution);
@@ -547,14 +560,14 @@ namespace cage
 					const auto graphicsDebugScope = renderQueue->namedScope("translucent");
 					for (const auto &it : layer.translucent)
 					{
-						PointerRange<const UniMesh> uniMeshes = { &it.uni, &it.uni + 1 };
 						PointerRange<const Mat3x4> uniArmatures;
 						if (it.skeletal)
 						{
 							uniArmatures = it.skeletalAnimation->armature();
 							CAGE_ASSERT(uniArmatures.size() == it.mesh->bones);
 						}
-						renderModelsImpl<RenderMode>(data, it, uniMeshes, uniArmatures, true);
+						const ModelInstance &inst = (const ModelInstance &)it;
+						renderModelsImpl<RenderMode>(data, it, PointerRange<const ModelInstance>(&inst, &inst + 1), uniArmatures, true);
 					}
 					renderQueue->resetAllState();
 					renderQueue->viewport(Vec2i(), data.resolution);
@@ -798,6 +811,8 @@ namespace cage
 						prepare.model = modelTransform(e);
 						prepare.uni = initializeMeshUni(data, prepare.model);
 						prepare.frustum = Frustum(prepare.uni.mvpMat);
+						if (e->has<ShaderDataComponent>())
+							prepare.customShaderData = e->value<ShaderDataComponent>().matrix;
 						if (Holder<RenderObject> obj = assets->get<AssetSchemeIndexRenderObject, RenderObject>(rc.object))
 						{
 							prepareObject<PrepareMode>(data, prepare, std::move(obj));

sources/libengine/graphics/shaderProgram.cpp

@@ -89,6 +89,7 @@ namespace cage
 					const std::string defines_ = defines(checked);
 					Holder<ShaderProgram> prg = newShaderProgram();
 					prg->setDebugName(debugName);
+					prg->customDataCount = customDataCount;
 					for (const auto &it : sources)
 					{
 						const std::string src = enhance(it.second, defines_);

sources/libengine/graphics/texture.cpp

@@ -53,9 +53,7 @@ namespace cage
 
 	void Texture::setDebugName(const String &name)
 	{
-#ifdef CAGE_DEBUG
 		debugName = name;
-#endif // CAGE_DEBUG
 		TextureImpl *impl = (TextureImpl *)this;
 		CAGE_ASSERT(impl->id);
 		glObjectLabel(GL_TEXTURE, impl->id, name.length(), name.c_str());

sources/libsimple/gameloop.cpp

@@ -595,6 +595,7 @@ namespace cage
 					entityMgr->defineComponent(TransformComponent());
 					transformHistoryComponent = entityMgr->defineComponent(TransformComponent());
 					entityMgr->defineComponent(RenderComponent());
+					entityMgr->defineComponent(ShaderDataComponent());
 					entityMgr->defineComponent(TextureAnimationComponent());
 					entityMgr->defineComponent(SkeletalAnimationComponent());
 					entityMgr->defineComponent(LightComponent());