Quaternions

cont/base/springcontent/shaders/GLSL/ModelVertProgGL4.glsl

@@ -83,8 +83,13 @@ layout(std140, binding = 1) uniform UniformParamsBuffer {
 	vec4 teamColor[255]; //all team colors
 };
 
-layout(std140, binding = 0) readonly buffer MatrixBuffer {
-	mat4 mat[];
+struct Transform {
+	vec4 quat;
+	vec4 trSc;
+};
+
+layout(std140, binding = 0) readonly buffer TransformBuffer {
+	Transform transforms[];
 };
 
 uniform int cameraMode = 0;
@@ -114,7 +119,7 @@ out Data {
 };
 out float gl_ClipDistance[3];
 
-#line 1117
+#line 1122
 
 void TransformPlayerCam(vec4 worldPos) {
 	gl_Position = cameraViewProj * worldPos;
@@ -132,6 +137,37 @@ uint GetUnpackedValue(uint packedValue, uint byteNum) {
 	return (packedValue >> (8u * byteNum)) & 0xFFu;
 }
 
+vec4 MultiplyQuat(vec4 a, vec4 b)
+{
+    return vec4(a.w * b.w - dot(a.w, b.w), a.w * b.xyz + b.w * a.xyz + cross(a.xyz, b.xyz));
+}
+
+vec3 RotateByQuaternion(vec4 q, vec3 v) {
+	return 2.0f * dot(q.xyz, v) * q.xyz + (q.w * q.w - dot(q.xyz, q.xyz)) * v + 2.0 * q.w * cross(q.xyz, v);
+}
+
+vec4 RotateByQuaternion(vec4 q, vec4 v) {
+	return vec4(RotateByQuaternion(q, v.xyz), v.w);
+}
+
+vec3 ApplyTransform(Transform tra, vec3 v) {
+	return RotateByQuaternion(tra.quat, v * tra.trSc.w) + tra.trSc.xyz;
+}
+
+vec4 ApplyTransform(Transform tra, vec4 v) {
+	return vec4(ApplyTransform(tra, v.xyz), v.w);
+}
+
+Transform ApplyTransform(Transform parentTra, Transform childTra) {
+	return Transform(
+		MultiplyQuat(parentTra.quat, childTra.quat),
+		vec4(
+			parentTra.trSc.xyz + RotateByQuaternion(parentTra.quat, parentTra.trSc.w * childTra.trSc.xyz),
+			parentTra.trSc.w * childTra.trSc.w
+		)
+	);
+}
+
 void GetModelSpaceVertex(out vec4 msPosition, out vec3 msNormal)
 {
 	bool staticModel = (matrixMode > 0);
@@ -146,13 +182,12 @@ void GetModelSpaceVertex(out vec4 msPosition, out vec3 msNormal)
 	);
 
 	uint b0 = GetUnpackedValue(bonesInfo.x, 0); //first boneID
-	mat4 b0BoneMat = mat[instData.x + b0 + uint(!staticModel)];
-	mat3 b0NormMat = mat3(b0BoneMat);
+	Transform b0BoneTra = transforms[instData.x + b0 + uint(!staticModel)];
 
-	weights[0] *= b0BoneMat[3][3];
+	weights[0] *= step(0.0, b0BoneTra.trSc.w);
 
-	msPosition = b0BoneMat * piecePos;
-	msNormal   = b0NormMat * normal;
+	msPosition = ApplyTransform(b0BoneTra, piecePos);
+	msNormal   = RotateByQuaternion(b0BoneTra.quat, normal);
 
 	if (staticModel || weights[0] == 1.0)
 		return;
@@ -164,7 +199,7 @@ void GetModelSpaceVertex(out vec4 msPosition, out vec3 msNormal)
 	wSum       += weights[0];
 
 	uint numPieces = GetUnpackedValue(instData.z, 3);
-	mat4 bposeMat    = mat[instData.w + b0];
+	Transform bposeTra = transforms[instData.w + b0];
 
 	// Vertex[ModelSpace,BoneX] = PieceMat[BoneX] * InverseBindPosMat[BoneX] * BindPosMat[Bone0] * Vertex[Bone0]
 	for (uint bi = 1; bi < 3; ++bi) {
@@ -173,16 +208,15 @@ void GetModelSpaceVertex(out vec4 msPosition, out vec3 msNormal)
 		if (bID == 0xFFu || weights[bi] == 0.0)
 			continue;
 
-		mat4 bposeInvMat = mat[instData.w + numPieces + bID];
-		mat4 boneMat     = mat[instData.x +        1u + bID];
+		Transform bposeInvTra = transforms[instData.w + numPieces + bID];
+		Transform boneTra     = transforms[instData.x +        1u + bID];
 
-		weights[bi] *= boneMat[3][3];
+		weights[bi] *= step(0.0, boneTra.trSc.w);
 
-		mat4 skinMat = boneMat * bposeInvMat * bposeMat;
-		mat3 normMat = mat3(skinMat);
+		Transform skinTra = ApplyTransform(ApplyTransform(boneTra, bposeInvTra), bposeTra);
 
-		msPosition += skinMat * piecePos * weights[bi];
-		msNormal   += normMat * normal   * weights[bi];
+		msPosition += ApplyTransform(skinTra, piecePos * weights[bi]);
+		msNormal   += RotateByQuaternion(skinTra.quat, normal * weights[bi]);
 		wSum       += weights[bi];
 	}
 
@@ -194,14 +228,15 @@ void main(void)
 {
 	bool staticModel = (matrixMode > 0);
 
-	mat4 worldMatrix = staticModel ? staticModelMatrix : mat[instData.x]; //don't cover ARRAY_MATMODE yet
+	//mat4 worldMatrix = staticModel ? staticModelMatrix : mat[instData.x]; //don't cover ARRAY_MATMODE yet
+	Transform worldTra = transforms[instData.x]; //don't cover ARRAY_MATMODE yet
 
 	vec4 modelPos;
 	vec3 modelNormal;
 	GetModelSpaceVertex(modelPos, modelNormal);
 
-	worldPos = worldMatrix * modelPos;
-	worldNormal = mat3(worldMatrix) * modelNormal;
+	worldPos = ApplyTransform(worldTra, modelPos);
+	worldNormal = RotateByQuaternion(worldTra.quat, modelNormal);
 
 	gl_ClipDistance[0] = dot(modelPos, clipPlane0); //upper construction clip plane
 	gl_ClipDistance[1] = dot(modelPos, clipPlane1); //lower construction clip plane

rts/Game/Game.cpp

@@ -736,8 +736,11 @@ void CGame::PreLoadRendering()
 	geometricObjects = new CGeometricObjects();
 
 	// load components that need to exist before PostLoadSimulation
-	matrixUploader.Init();
-	modelsUniformsUploader.Init();
+	modelUniformsStorage.Init();
+	//transformsMemStorage.Init(); // Add?
+
+	transformsUploader.Init();
+	modelUniformsUploader.Init();
 	worldDrawer.InitPre();
 }
 
@@ -997,8 +1000,9 @@ void CGame::KillRendering()
 	icon::iconHandler.Kill();
 	spring::SafeDelete(geometricObjects);
 	worldDrawer.Kill();
-	matrixUploader.Kill();
-	modelsUniformsUploader.Kill();
+
+	transformsUploader.Kill();
+	modelUniformsUploader.Kill();
 }
 
 void CGame::KillInterface()
@@ -1041,6 +1045,9 @@ void CGame::KillSimulation()
 	unitHandler.Kill();
 	projectileHandler.Kill();
 
+	modelUniformsStorage.Kill();
+	//transformsMemStorage.Kill(); //Add?
+
 	LOG("[Game::%s][3]", __func__);
 	IPathManager::FreeInstance(pathManager);
 	IMapDamage::FreeMapDamage(mapDamage);
@@ -1470,8 +1477,8 @@ bool CGame::UpdateUnsynced(const spring_time currentTime)
 	shadowHandler.Update();
 	{
 		worldDrawer.Update(newSimFrame);
-		matrixUploader.Update();
-		modelsUniformsUploader.Update();
+		transformsUploader.Update();
+		modelUniformsUploader.Update();
 	}
 
 	mouse->UpdateCursorCameraDir(); // make sure mouse->dir is in sync with camera

rts/Lua/LuaOpenGL.cpp

@@ -1423,7 +1423,7 @@ static void GLObjectPieceMultMatrix(lua_State* L, const CSolidObject* obj)
 	if (lmp == nullptr)
 		return;
 
-	glMultMatrixf(lmp->GetModelSpaceMatrix());
+	glMultMatrixf(lmp->GetModelSpaceTransform().ToMatrix());
 }
 
 static bool GLObjectDrawWithLuaMat(lua_State* L, CSolidObject* obj, LuaObjType objType)

rts/Lua/LuaShaders.cpp

@@ -960,7 +960,7 @@ namespace {
 		if (o == nullptr)
 			luaL_error(L, "gl.%s() Invalid %s id (%d)", func, &spring::TypeToCStr<T>()[1], id);
 
-		ModelUniformData& uni = modelsUniformsStorage.GetObjUniformsArray(o);
+		ModelUniformData& uni = modelUniformsStorage.GetObjUniformsArray(o);
 
 		std::array<float, ModelUniformData::MAX_MODEL_UD_UNIFORMS> floatArray = {0};
 		int size = LuaUtils::ParseFloatArray(L, 2, floatArray.data(), ModelUniformData::MAX_MODEL_UD_UNIFORMS);

rts/Lua/LuaSyncedRead.cpp

@@ -8245,7 +8245,7 @@ static int GetSolidObjectPieceMatrix(lua_State* L, const CSolidObject* o)
 	if (lmp == nullptr)
 		return 0;
 
-	const CMatrix44f& mat = lmp->GetModelSpaceMatrix();
+	const CMatrix44f& mat = lmp->GetModelSpaceTransform().ToMatrix();
 
 	for (float mi: mat.m) {
 		lua_pushnumber(L, mi);

rts/Lua/LuaVBOImpl.cpp

@@ -986,8 +986,8 @@ SInstanceData LuaVBOImpl::InstanceDataFromGetData(int id, int attrID, uint8_t de
 	uint32_t teamID = defTeamID;
 
 	const TObj* obj = LuaUtils::SolIdToObject<TObj>(id, __func__);
-	const uint32_t matOffset = static_cast<uint32_t>(matrixUploader.GetElemOffset(obj));
-	const uint32_t uniIndex  = static_cast<uint32_t>(modelsUniformsStorage.GetObjOffset(obj)); //doesn't need to exist for defs and model. Don't check for validity
+	const uint32_t matOffset = static_cast<uint32_t>(transformsUploader.GetElemOffset(obj));
+	const uint32_t uniIndex  = static_cast<uint32_t>(modelUniformsStorage.GetObjOffset(obj)); //doesn't need to exist for defs and model. Don't check for validity
 
 	if (matOffset == ~0u) {
 		LuaUtils::SolLuaError("[LuaVBOImpl::%s] Invalid data supplied. See infolog for details", __func__);
@@ -1003,11 +1003,11 @@ SInstanceData LuaVBOImpl::InstanceDataFromGetData(int id, int attrID, uint8_t de
 	size_t bposeIndex = 0;
 	if constexpr (std::is_same<TObj, S3DModel>::value) {
 		numPieces = static_cast<uint8_t>(obj->numPieces);
-		bposeIndex = matrixUploader.GetElemOffset(obj);
+		bposeIndex = transformsUploader.GetElemOffset(obj);
 	}
 	else {
 		numPieces = static_cast<uint8_t>(obj->model->numPieces);
-		bposeIndex = matrixUploader.GetElemOffset(obj->model);
+		bposeIndex = transformsUploader.GetElemOffset(obj->model);
 	}
 
 	return SInstanceData(matOffset, teamID, drawFlags, numPieces, uniIndex, bposeIndex);

rts/Rendering/CMakeLists.txt

@@ -123,6 +123,7 @@ set(sources_engine_Rendering
 		"${CMAKE_CURRENT_SOURCE_DIR}/Common/ModelDrawerData.cpp"
 		"${CMAKE_CURRENT_SOURCE_DIR}/Common/ModelDrawerState.cpp"
 		"${CMAKE_CURRENT_SOURCE_DIR}/Common/ModelDrawerHelpers.cpp"
+		"${CMAKE_CURRENT_SOURCE_DIR}/Common/UpdateList.cpp"
 		"${CMAKE_CURRENT_SOURCE_DIR}/Features/FeatureDrawerData.cpp"
 		"${CMAKE_CURRENT_SOURCE_DIR}/Features/FeatureDrawer.cpp"
 		"${CMAKE_CURRENT_SOURCE_DIR}/Units/UnitDrawerData.cpp"

rts/Rendering/Common/ModelDrawer.h

@@ -21,7 +21,7 @@
 
 namespace GL { struct GeometryBuffer; }
 template<typename T> class ScopedModelDrawerImpl;
-class ScopedMatricesMemAlloc;
+class ScopedTransformMemAlloc;
 
 
 static constexpr const char* ModelDrawerNames[ModelDrawerTypes::MODEL_DRAWER_CNT] = {
@@ -110,7 +110,7 @@ class CModelDrawerBase : public CModelDrawerConcept {
 	static bool CanDrawDeferred() { return modelDrawerState->CanDrawDeferred(); }
 	static bool SetTeamColor(int team, const float alpha = 1.0f) { return modelDrawerState->SetTeamColor(team, alpha); }
 	static void SetNanoColor(const float4& color) { modelDrawerState->SetNanoColor(color); }
-	static const ScopedMatricesMemAlloc& GetMatricesMemAlloc(const ObjType* o) { return const_cast<const TDrawerData*>(modelDrawerData)->GetObjectMatricesMemAlloc(o); }
+	static const ScopedTransformMemAlloc& GetTransformMemAlloc(const ObjType* o) { return const_cast<const TDrawerData*>(modelDrawerData)->GetObjectTransformMemAlloc(o); }
 public:
 	virtual void Update() const = 0;
 	// Draw*

rts/Rendering/Common/ModelDrawerData.h

@@ -69,18 +69,18 @@ class CModelDrawerDataBase : public CModelDrawerDataConcept
 
 	void ClearPreviousDrawFlags() { for (auto object : unsortedObjects) object->previousDrawFlag = 0; }
 
-	const ScopedMatricesMemAlloc& GetObjectMatricesMemAlloc(const T* o) const {
-		const auto it = matricesMemAllocs.find(const_cast<T*>(o));
-		return (it != matricesMemAllocs.end()) ? it->second : ScopedMatricesMemAlloc::Dummy();
+	const auto& GetObjectTransformMemAlloc(const T* o) const {
+		const auto it = scTransMemAllocMap.find(const_cast<T*>(o));
+		return (it != scTransMemAllocMap.end()) ? it->second : ScopedTransformMemAlloc::Dummy();
 	}
-	ScopedMatricesMemAlloc& GetObjectMatricesMemAlloc(const T* o) { return matricesMemAllocs[const_cast<T*>(o)]; }
+	auto& GetObjectTransformMemAlloc(const T* o) { return scTransMemAllocMap[const_cast<T*>(o)]; }
 private:
 	static constexpr int MMA_SIZE0 = 2 << 16;
 protected:
 	std::array<ModelRenderContainer<T>, MODELTYPE_CNT> modelRenderers;
 
 	std::vector<T*> unsortedObjects;
-	std::unordered_map<T*, ScopedMatricesMemAlloc> matricesMemAllocs;
+	std::unordered_map<T*, ScopedTransformMemAlloc> scTransMemAllocMap;
 
 	bool& mtModelDrawer;
 };
@@ -100,15 +100,15 @@ inline CModelDrawerDataBase<T>::CModelDrawerDataBase(const std::string& ecName,
 	: CModelDrawerDataConcept(ecName, ecOrder)
 	, mtModelDrawer(mtModelDrawer_)
 {
-	matricesMemAllocs.reserve(MMA_SIZE0);
+	scTransMemAllocMap.reserve(MMA_SIZE0);
 	for (auto& mr : modelRenderers) { mr.Clear(); }
 }
 
 template<typename T>
 inline CModelDrawerDataBase<T>::~CModelDrawerDataBase()
 {
 	unsortedObjects.clear();
-	matricesMemAllocs.clear();
+	scTransMemAllocMap.clear();
 }
 
 template<typename T>
@@ -126,9 +126,9 @@ inline void CModelDrawerDataBase<T>::AddObject(const T* co, bool add)
 	unsortedObjects.emplace_back(o);
 
 	const uint32_t numMatrices = (o->model ? o->model->numPieces : 0) + 1u;
-	matricesMemAllocs.emplace(o, ScopedMatricesMemAlloc(numMatrices));
+	scTransMemAllocMap.emplace(o, ScopedTransformMemAlloc(numMatrices));
 
-	modelsUniformsStorage.GetObjOffset(co);
+	modelUniformsStorage.AddObject(co);
 }
 
 template<typename T>
@@ -141,8 +141,8 @@ inline void CModelDrawerDataBase<T>::DelObject(const T* co, bool del)
 	}
 
 	if (del && spring::VectorErase(unsortedObjects, o)) {
-		matricesMemAllocs.erase(o);
-		modelsUniformsStorage.GetObjOffset(co);
+		scTransMemAllocMap.erase(o);
+		modelUniformsStorage.DelObject(co);
 	}
 }
 
@@ -157,15 +157,13 @@ inline void CModelDrawerDataBase<T>::UpdateObject(const T* co, bool init)
 template<typename T>
 inline void CModelDrawerDataBase<T>::UpdateObjectSMMA(const T* o)
 {
-	ScopedMatricesMemAlloc& smma = GetObjectMatricesMemAlloc(o);
+	ScopedTransformMemAlloc& smma = GetObjectTransformMemAlloc(o);
 
-	const auto  tmNew = o->GetTransformMatrix();
-	const auto& tmOld = const_cast<const ScopedMatricesMemAlloc&>(smma)[0];
+	const auto tmNew = Transform::FromMatrix(o->GetTransformMatrix());
 
 	// from one point it doesn't worth the comparison, cause units usually move
-	// but having not updated smma[0] allows for longer solid no-update areas in ModelsUniformsUploader::UpdateDerived()
-	if (tmNew != tmOld)
-		smma[0] = tmNew;
+	// but having not updated smma[0] allows for longer solid no-update areas in ModelUniformsUploader::UpdateDerived()
+	smma.UpdateIfChanged(0, tmNew);
 
 	for (int i = 0; i < o->localModel.pieces.size(); ++i) {
 		const LocalModelPiece& lmp = o->localModel.pieces[i];
@@ -175,22 +173,25 @@ inline void CModelDrawerDataBase<T>::UpdateObjectSMMA(const T* o)
 			continue;
 
 		if unlikely(!lmp.GetScriptVisible()) {
-			smma[i + 1] = CMatrix44f::Zero();
+			//smma[i + 1] = CMatrix44f::Zero();
+			smma.UpdateForced(i + 1, Transform::Zero());
 			continue;
 		}
 
-		smma[i + 1] = lmp.GetModelSpaceMatrix();
+		// UpdateIfChanged is not needed, wasCustomDirty takes that role
+		smma.UpdateForced(i + 1, lmp.GetModelSpaceTransform());
 	}
 }
 
 template<typename T>
 inline void CModelDrawerDataBase<T>::UpdateObjectUniforms(const T* o)
 {
-	auto& uni = modelsUniformsStorage.GetObjUniformsArray(o);
+	auto& uni = modelUniformsStorage.GetObjUniformsArray(o);
 	uni.drawFlag = o->drawFlag;
 
 	if (gu->spectatingFullView || o->IsInLosForAllyTeam(gu->myAllyTeam)) {
 		uni.id = o->id;
+		// TODO remove drawPos, replace with pos
 		uni.drawPos = float4{ o->drawPos, o->heading * math::PI / SPRING_MAX_HEADING };
 		uni.speed = o->speed;
 		uni.maxHealth = o->maxHealth;