[PICA] We can now upload floating point uniforms

include/PICA/float_types.hpp

@@ -63,6 +63,18 @@ namespace Floats {
             return value;
         }
 
+        double toFloat64() const {
+            return static_cast<double>(value);
+        }
+
+        operator float() {
+            return toFloat32();
+        }
+
+        operator double() {
+            return toFloat64();
+        }
+
         Float<M, E> operator*(const Float<M, E>& flt) const {
             float result = value * flt.toFloat32();
             // PICA gives 0 instead of NaN when multiplying by inf

include/PICA/gpu.hpp

@@ -67,7 +67,7 @@ class GPU {
 	u32 totalAttribCount = 0; // Number of vertex attributes to send to VS
 	u32 fixedAttribMask = 0; // Which attributes are fixed?
 	
-	u32 fixedAttribIndex = 0; // Which fixed attribute are we writing to ([0, 12] range)
+	u32 fixedAttribIndex = 0; // Which fixed attribute are we writing to ([0, 11] range)
 	u32 fixedAttribCount = 0; // How many attribute components have we written? When we get to 4 the attr will actually get submitted
 	std::array<u32, 3> fixedAttrBuff; // Buffer to hold fixed attributes in until they get submitted
 

include/PICA/regs.hpp

@@ -49,6 +49,16 @@ namespace PICAInternalRegs {
 
 		// Vertex shader registers
 		VertexShaderTransferEnd = 0x2BF,
+		VertexFloatUniformIndex = 0x2C0,
+		VertexFloatUniformData0 = 0x2C1,
+		VertexFloatUniformData1 = 0x2C2,
+		VertexFloatUniformData2 = 0x2C3,
+		VertexFloatUniformData3 = 0x2C4,
+		VertexFloatUniformData4 = 0x2C5,
+		VertexFloatUniformData5 = 0x2C6,
+		VertexFloatUniformData6 = 0x2C7,
+		VertexFloatUniformData7 = 0x2C8,
+
 		VertexShaderTransferIndex = 0x2CB,
 		VertexShaderData0 = 0x2CC,
 		VertexShaderData1 = 0x2CD,

include/PICA/shader.hpp

@@ -22,6 +22,11 @@ class PICAShader {
 
 	int bufferIndex; // Index of the next instruction to overwrite for shader uploads
 	int opDescriptorIndex; // Index of the next operand descriptor we'll overwrite
+	u32 floatUniformIndex = 0; // Which float uniform are we writing to? ([0, 95] range)
+	u32 floatUniformWordCount = 0; // How many words have we buffered for the current uniform transfer?
+	bool f32UniformTransfer = false; // Are we transferring an f32 uniform or an f24 uniform?
+
+	std::array<u32, 4> floatUniformBuffer; // Buffer for temporarily caching float uniform data
 	std::array<u32, 128> operandDescriptors;
 	std::array<vec4f, 16> tempRegisters;
 	ShaderType type;
@@ -84,34 +89,18 @@ public:
 
 	PICAShader(ShaderType type) : type(type) {}
 
-	void reset() {
-		loadedShader.fill(0);
-		bufferedShader.fill(0);
-		operandDescriptors.fill(0);
-
-		intUniforms.fill(0);
-		boolUniform = 0;
-		bufferIndex = 0;
-		opDescriptorIndex = 0;
-
-		const vec4f zero = vec4f({ f24::fromFloat32(0.0), f24::fromFloat32(0.0), f24::fromFloat32(0.0), f24::fromFloat32(0.0) });
-		attributes.fill(zero);
-		floatUniforms.fill(zero);
-		outputs.fill(zero);
-		tempRegisters.fill(zero);
-	}
-
+	// Theese functions are in the header to be inlined more easily, though with LTO I hope I'll be able to move them
 	void finalize() {
 		std::memcpy(&loadedShader[0], &bufferedShader[0], 512 * sizeof(u32));
 	}
 
-	void setBufferIndex(u32 offset) {
-		if (offset != 0) Helpers::panic("Is this register 9 or 11 bit?");
-		bufferIndex = (offset >> 2) & 0x1ff;
+	void setBufferIndex(u32 index) {
+		if (index != 0) Helpers::panic("Is this register 9 or 11 bit?");
+		bufferIndex = (index >> 2) & 0x1ff;
 	}
 
-	void setOpDescriptorIndex(u32 offset) {
-		opDescriptorIndex = offset & 0x7f;
+	void setOpDescriptorIndex(u32 index) {
+		opDescriptorIndex = index & 0x7f;
 	}
 
 	void uploadWord(u32 word) {
@@ -124,5 +113,35 @@ public:
 		opDescriptorIndex &= 0x7f;
 	}
 
+	void setFloatUniformIndex(u32 word) {
+		floatUniformIndex = word & 0xff;
+		floatUniformWordCount = 0;
+		f32UniformTransfer = (word & 0x80000000) != 0;
+	}
+
+	void uploadFloatUniform(u32 word) {
+		floatUniformBuffer[floatUniformWordCount++] = word;
+		if (floatUniformIndex >= 96)
+			Helpers::panic("[PICA] Tried to write float uniform %d", floatUniformIndex);
+
+		if ((f32UniformTransfer && floatUniformWordCount == 4) || (!f32UniformTransfer && floatUniformWordCount == 3)) {
+			vec4f& uniform = floatUniforms[floatUniformIndex++];
+			floatUniformWordCount = 0;
+
+			if (f32UniformTransfer) {
+				uniform.x() = f24::fromFloat32(*(float*)floatUniformBuffer[3]);
+				uniform.y() = f24::fromFloat32(*(float*)floatUniformBuffer[2]);
+				uniform.z() = f24::fromFloat32(*(float*)floatUniformBuffer[1]);
+				uniform.w() = f24::fromFloat32(*(float*)floatUniformBuffer[0]);
+			} else {
+				uniform.x() = f24::fromRaw(floatUniformBuffer[2] & 0xffffff);
+				uniform.y() = f24::fromRaw(((floatUniformBuffer[1] & 0xffff) << 8) | (floatUniformBuffer[2] >> 24));
+				uniform.z() = f24::fromRaw(((floatUniformBuffer[0] & 0xff) << 16) | (floatUniformBuffer[1] >> 16));
+				uniform.w() = f24::fromRaw(floatUniformBuffer[0] >> 8);
+			}
+		}
+	}
+
 	void run();
+	void reset();
 };

src/core/PICA/regs.cpp

@@ -54,6 +54,16 @@ void GPU::writeInternalReg(u32 index, u32 value, u32 mask) {
 			fixedAttribMask = (value >> 16) & 0xfff; // Determines which vertex attributes are fixed for all vertices
 			break;
 
+		case VertexFloatUniformIndex:
+			shaderUnit.vs.setFloatUniformIndex(value);
+			break;
+
+		case VertexFloatUniformData0: case VertexFloatUniformData1: case VertexFloatUniformData2:
+		case VertexFloatUniformData3: case VertexFloatUniformData4: case VertexFloatUniformData5:
+		case VertexFloatUniformData6: case VertexFloatUniformData7:
+			shaderUnit.vs.uploadFloatUniform(value);
+			break;
+
 		case FixedAttribIndex:
 			fixedAttribCount = 0;
 			fixedAttribIndex = value & 0xf;

src/core/PICA/shader_unit.cpp

@@ -3,4 +3,24 @@
 void ShaderUnit::reset() {
 	vs.reset();
 	gs.reset();
+}
+
+void PICAShader::reset() {
+	loadedShader.fill(0);
+	bufferedShader.fill(0);
+	operandDescriptors.fill(0);
+
+	intUniforms.fill(0);
+	boolUniform = 0;
+	bufferIndex = 0;
+	floatUniformIndex = 0;
+	floatUniformWordCount = 0;
+	opDescriptorIndex = 0;
+	f32UniformTransfer = false;
+
+	const vec4f zero = vec4f({ f24::fromFloat32(0.0), f24::fromFloat32(0.0), f24::fromFloat32(0.0), f24::fromFloat32(0.0) });
+	attributes.fill(zero);
+	floatUniforms.fill(zero);
+	outputs.fill(zero);
+	tempRegisters.fill(zero);
 }