Use files from master

- Drop smart vertex storage and use OpenGL's one instead.

rpcs3/Emu/RSX/Common/BufferUtils.cpp

@@ -20,7 +20,7 @@ std::vector<VertexBufferFormat> FormatVertexData(const rsx::data_array_format_in
 		const rsx::data_array_format_info &vertexData = vertex_array_desc[i];
 		if (!vertexData.size) continue;
 
-		u32 addrRegVal = rsx::method_registers[NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 4 * i];
+		u32 addrRegVal = rsx::method_registers[NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + i];
 		u32 addr = rsx::get_address(addrRegVal & 0x7fffffff, addrRegVal >> 31);
 		size_t elementCount = ((vertexData.array) ? vertex_data_size[i] : vertex_data[i].size()) / (vertexData.size * rsx::get_vertex_type_size(vertexData.type));
 
@@ -61,7 +61,7 @@ void uploadVertexData(const VertexBufferFormat &vbf, const rsx::data_array_forma
 	{
 		for (size_t attributeId : vbf.attributeId)
 		{
-			u32 addrRegVal = rsx::method_registers[NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 4 * attributeId];
+			u32 addrRegVal = rsx::method_registers[NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + attributeId];
 			u32 addr = rsx::get_address(addrRegVal & 0x7fffffff, addrRegVal >> 31);
 
 			if (!vertex_array_desc[attributeId].array)

rpcs3/Emu/RSX/Common/VertexProgramDecompiler.cpp

@@ -136,13 +136,13 @@ void VertexProgramDecompiler::SetDST(bool is_sca, std::string value)
 
 	std::string mask = GetMask(is_sca);
 
-	value += mask;
+	if (is_sca)
-
-	if (is_sca && d0.vec_result)
 	{
-		//value = "vec4(" + value + ")";
+		value = getFloatTypeName(4) + "(" + value + ")";
 	}
 
+	value += mask;
+
 	if (d0.staturate)
 	{
 		value = "clamp(" + value + ", 0.0, 1.0)";
@@ -309,7 +309,7 @@ void VertexProgramDecompiler::AddCodeCond(const std::string& dst, const std::str
 
 	if (dst_var.swizzles[0].length() == 1)
 	{
-		AddCode("if (" + cond + ".x) " + dst + " = " + getFloatTypeName(4) + "(" + src + ".xxxx).x;");
+		AddCode("if (" + cond + ".x) " + dst + " = " + src + ";");
 	}
 	else
 	{
@@ -559,7 +559,7 @@ std::string VertexProgramDecompiler::Decompile()
 		case RSX_SCA_OPCODE_MOV: SetDSTSca("$s"); break;
 		case RSX_SCA_OPCODE_RCP: SetDSTSca("(1.0 / $s)"); break;
 		case RSX_SCA_OPCODE_RCC: SetDSTSca("clamp(1.0 / $s, 5.42101e-20, 1.884467e19)"); break;
-		case RSX_SCA_OPCODE_RSQ: SetDSTSca("1.f / sqrt($s)"); break;
+		case RSX_SCA_OPCODE_RSQ: SetDSTSca("(1.f / sqrt($s))"); break;
 		case RSX_SCA_OPCODE_EXP: SetDSTSca("exp($s)"); break;
 		case RSX_SCA_OPCODE_LOG: SetDSTSca("log($s)"); break;
 		case RSX_SCA_OPCODE_LIT: SetDSTSca(getFloatTypeName(4) + "(1.0, $s.x, ($s.x > 0.0 ? exp($s.w * log2($s.y)) : 0.0), 1.0)"); break;

rpcs3/Emu/RSX/D3D12/D3D12Buffer.cpp

@@ -92,27 +92,27 @@ DXGI_FORMAT getFormat(u8 type, u8 size)
 }
 
 static
-std::vector<D3D12_INPUT_ELEMENT_DESC> getIALayout(ID3D12Device *device, const std::vector<VertexBufferFormat> &vertexBufferFormat, const rsx::data_array_format_info *m_vertex_data, size_t baseOffset)
+std::vector<D3D12_INPUT_ELEMENT_DESC> getIALayout(const rsx::data_array_format_info *vertex_info, const std::vector<u8> *vertex_data)
 {
 	std::vector<D3D12_INPUT_ELEMENT_DESC> result;
 
-	for (size_t inputSlot = 0; inputSlot < vertexBufferFormat.size(); inputSlot++)
+	size_t inputSlot = 0;
+	for (size_t index = 0; index < rsx::limits::vertex_count; index++)
 	{
-		for (size_t attributeId : vertexBufferFormat[inputSlot].attributeId)
+		const auto &info = vertex_info[index];
-		{
+
-			u32 addrRegVal = rsx::method_registers[NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 4 * attributeId];
+		if (!info.size)
-			u32 addr = rsx::get_address(addrRegVal & 0x7fffffff, addrRegVal >> 31);
+			continue;
-			const rsx::data_array_format_info &vertexData = m_vertex_data[attributeId];
+
 			D3D12_INPUT_ELEMENT_DESC IAElement = {};
 			IAElement.SemanticName = "TEXCOORD";
-			IAElement.SemanticIndex = (UINT)attributeId;
+			IAElement.SemanticIndex = (UINT)index;
-			IAElement.InputSlot = (UINT)inputSlot;
+			IAElement.InputSlot = (UINT)inputSlot++;
-			IAElement.Format = getFormat(vertexData.type - 1, vertexData.size);
+			IAElement.Format = getFormat(info.type - 1, info.size);
-			IAElement.AlignedByteOffset = (UINT)(addr + baseOffset - vertexBufferFormat[inputSlot].range.first);
+			IAElement.AlignedByteOffset = 0;
-			IAElement.InputSlotClass = (addr > 0) ? D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA : D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
+			IAElement.InputSlotClass = info.array ? D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA : D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
-			IAElement.InstanceDataStepRate = (addr > 0) ? 0 : 1;
+			IAElement.InstanceDataStepRate = 0;
 			result.push_back(IAElement);
-		}
 	}
 	return result;
 }
@@ -121,22 +121,19 @@ std::vector<D3D12_INPUT_ELEMENT_DESC> getIALayout(ID3D12Device *device, const st
 
 
 /**
- * Suballocate a new vertex buffer with attributes from vbf using vertexIndexHeap as storage heap.
+ * 
  */
 static
-D3D12_GPU_VIRTUAL_ADDRESS createVertexBuffer(const VertexBufferFormat &vbf, const rsx::data_array_format_info *vertex_array_desc, const std::vector<u8> *vertex_data, size_t baseOffset, ID3D12Device *device, DataHeap<ID3D12Resource, 65536> &vertexIndexHeap)
+D3D12_GPU_VIRTUAL_ADDRESS createVertexBuffer(const rsx::data_array_format_info &vertex_array_desc, const std::vector<u8> &vertex_data, ID3D12Device *device, DataHeap<ID3D12Resource, 65536> &vertexIndexHeap)
 {
-	size_t subBufferSize = vbf.range.second - vbf.range.first + 1;
+	size_t subBufferSize = vertex_data.size();
-	// Make multiple of stride
-	if (vbf.stride)
-		subBufferSize = ((subBufferSize + vbf.stride - 1) / vbf.stride) * vbf.stride;
 	assert(vertexIndexHeap.canAlloc(subBufferSize));
 	size_t heapOffset = vertexIndexHeap.alloc(subBufferSize);
 
 	void *buffer;
 	ThrowIfFailed(vertexIndexHeap.m_heap->Map(0, &CD3DX12_RANGE(heapOffset, heapOffset + subBufferSize), (void**)&buffer));
 	void *bufferMap = (char*)buffer + heapOffset;
-	uploadVertexData(vbf, vertex_array_desc, vertex_data, baseOffset, bufferMap);
+	memcpy(bufferMap, vertex_data.data(), vertex_data.size());
 	vertexIndexHeap.m_heap->Unmap(0, &CD3DX12_RANGE(heapOffset, heapOffset + subBufferSize));
 	return vertexIndexHeap.m_heap->GetGPUVirtualAddress() + heapOffset;
 }
@@ -145,26 +142,21 @@ std::vector<D3D12_VERTEX_BUFFER_VIEW> D3D12GSRender::UploadVertexBuffers(bool in
 {
 	u32 m_vertex_data_base_offset = rsx::method_registers[NV4097_SET_VERTEX_DATA_BASE_OFFSET];
 	std::vector<D3D12_VERTEX_BUFFER_VIEW> result;
-	const std::vector<VertexBufferFormat> &vertexBufferFormat = FormatVertexData(vertex_arrays_info, vertex_arrays, m_vertexBufferSize, m_vertex_data_base_offset);
+	m_IASet = getIALayout(vertex_arrays_info, vertex_arrays);
-	m_IASet = getIALayout(m_device.Get(), vertexBufferFormat, vertex_arrays_info, m_vertex_data_base_offset);
 
-	const u32 data_offset = indexed_draw ? 0 : draw_array_first;
+	for (int index = 0; index < rsx::limits::vertex_count; ++index)
-
-	for (size_t buffer = 0; buffer < vertexBufferFormat.size(); buffer++)
 	{
-		const VertexBufferFormat &vbf = vertexBufferFormat[buffer];
+		const auto &info = vertex_arrays_info[index];
-		// Make multiple of stride
-		size_t subBufferSize = vbf.range.second - vbf.range.first + 1;
-		if (vbf.stride)
-			subBufferSize = ((subBufferSize + vbf.stride - 1) / vbf.stride) * vbf.stride;
 
-		D3D12_GPU_VIRTUAL_ADDRESS virtualAddress = createVertexBuffer(vbf, vertex_arrays_info, vertex_arrays, m_vertex_data_base_offset, m_device.Get(), m_vertexIndexData);
+		if (!info.size)
-		m_timers.m_bufferUploadSize += subBufferSize;
+			continue;
+
+		D3D12_GPU_VIRTUAL_ADDRESS virtualAddress = createVertexBuffer(info, vertex_arrays[index], m_device.Get(), m_vertexIndexData);
 
 		D3D12_VERTEX_BUFFER_VIEW vertexBufferView = {};
 		vertexBufferView.BufferLocation = virtualAddress;
-		vertexBufferView.SizeInBytes = (UINT)subBufferSize;
+		vertexBufferView.SizeInBytes = (UINT)vertex_arrays[index].size();
-		vertexBufferView.StrideInBytes = (UINT)vbf.stride;
+		vertexBufferView.StrideInBytes = (UINT)rsx::get_vertex_type_size(info.type) * info.size;
 		result.push_back(vertexBufferView);
 	}
 
@@ -179,13 +171,15 @@ D3D12_INDEX_BUFFER_VIEW D3D12GSRender::uploadIndexBuffers(bool indexed_draw)
 	if (!indexed_draw && isNativePrimitiveMode(draw_mode))
 	{
 		m_renderingInfo.m_indexed = false;
-		m_renderingInfo.m_count = draw_array_count;
+		m_renderingInfo.m_count = vertex_draw_count;
-		m_renderingInfo.m_baseVertex = draw_array_first;
+		m_renderingInfo.m_baseVertex = 0;
 		return indexBufferView;
 	}
 
 	m_renderingInfo.m_indexed = true;
 
+	u32 indexed_type = rsx::method_registers[NV4097_SET_INDEX_ARRAY_DMA] >> 4;
+
 	// Index type
 	size_t indexSize;
 	if (!indexed_draw)
@@ -195,7 +189,7 @@ D3D12_INDEX_BUFFER_VIEW D3D12GSRender::uploadIndexBuffers(bool indexed_draw)
 	}
 	else
 	{
-		switch (m_indexed_array.m_type)
+		switch (indexed_type)
 		{
 		default: abort();
 		case CELL_GCM_DRAW_INDEX_ARRAY_TYPE_16:
@@ -210,11 +204,11 @@ D3D12_INDEX_BUFFER_VIEW D3D12GSRender::uploadIndexBuffers(bool indexed_draw)
 	}
 
 	// Index count
-	m_renderingInfo.m_count = getIndexCount(draw_mode, indexed_draw ? (u32)(m_indexed_array.m_data.size() / indexSize) : draw_array_count);
+	m_renderingInfo.m_count = getIndexCount(draw_mode, indexed_draw ? (u32)(vertex_index_array.size() / indexSize) : vertex_draw_count);
 
 	// Base vertex
 	if (!indexed_draw && isNativePrimitiveMode(draw_mode))
-		m_renderingInfo.m_baseVertex = draw_array_first;
+		m_renderingInfo.m_baseVertex = 0;
 	else
 		m_renderingInfo.m_baseVertex = 0;
 
@@ -227,7 +221,7 @@ D3D12_INDEX_BUFFER_VIEW D3D12GSRender::uploadIndexBuffers(bool indexed_draw)
 	void *buffer;
 	ThrowIfFailed(m_vertexIndexData.m_heap->Map(0, &CD3DX12_RANGE(heapOffset, heapOffset + subBufferSize), (void**)&buffer));
 	void *bufferMap = (char*)buffer + heapOffset;
-	uploadIndexData(draw_mode, m_indexed_array.m_type, indexed_draw ? m_indexed_array.m_data.data() : nullptr, bufferMap, indexed_draw ? (u32)(m_indexed_array.m_data.size() / indexSize) : draw_array_count);
+	uploadIndexData(draw_mode, indexed_type, indexed_draw ? vertex_index_array.data() : nullptr, bufferMap, indexed_draw ? (u32)(vertex_index_array.size() / indexSize) : vertex_draw_count);
 	m_vertexIndexData.m_heap->Unmap(0, &CD3DX12_RANGE(heapOffset, heapOffset + subBufferSize));
 	m_timers.m_bufferUploadSize += subBufferSize;
 	indexBufferView.SizeInBytes = (UINT)subBufferSize;
@@ -249,14 +243,14 @@ void D3D12GSRender::setScaleOffset()
 	int clip_h = rsx::method_registers[NV4097_SET_SURFACE_CLIP_VERTICAL] >> 16;
 
 	// Scale
-	scaleOffsetMat[0] *= (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE + (0x4 * 0)] / (clip_w / 2.f);
+	scaleOffsetMat[0] *= (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE] / (clip_w / 2.f);
-	scaleOffsetMat[5] *= (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE + (0x4 * 1)] / (clip_h / 2.f);
+	scaleOffsetMat[5] *= (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE + 1] / (clip_h / 2.f);
-	scaleOffsetMat[10] = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE + (0x4 * 2)];
+	scaleOffsetMat[10] = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE + 2];
 
 	// Offset
-	scaleOffsetMat[3] = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET + (0x4 * 0)] - (clip_w / 2.f);
+	scaleOffsetMat[3] = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET] - (clip_w / 2.f);
-	scaleOffsetMat[7] = -((float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET + (0x4 * 1)] - (clip_h / 2.f));
+	scaleOffsetMat[7] = -((float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET + 1] - (clip_h / 2.f));
-	scaleOffsetMat[11] = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET + (0x4 * 2)];
+	scaleOffsetMat[11] = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET + 2];
 
 	scaleOffsetMat[3] /= clip_w / 2.f;
 	scaleOffsetMat[7] /= clip_h / 2.f;
@@ -285,6 +279,9 @@ void D3D12GSRender::setScaleOffset()
 
 void D3D12GSRender::FillVertexShaderConstantsBuffer()
 {
+	for (const auto &entry : transform_constants)
+		local_transform_constants[entry.first] = entry.second;
+
 	size_t bufferSize = 512 * 4 * sizeof(float);
 
 	assert(m_constantsData.canAlloc(bufferSize));
@@ -292,7 +289,7 @@ void D3D12GSRender::FillVertexShaderConstantsBuffer()
 
 	void *constantsBufferMap;
 	ThrowIfFailed(m_constantsData.m_heap->Map(0, &CD3DX12_RANGE(heapOffset, heapOffset + bufferSize), &constantsBufferMap));
-	for (const auto &entry : transform_constants)
+	for (const auto &entry : local_transform_constants)
 	{
 		float data[4] = {
 			entry.second.x,
@@ -332,7 +329,7 @@ void D3D12GSRender::FillPixelShaderConstantsBuffer()
 		// Is it assigned by color register in command buffer ?
 		// TODO : we loop every iteration, we might do better...
 		bool isCommandBufferSetConstant = false;
-		for (const auto& entry : fragment_constants)
+/*		for (const auto& entry : fragment_constants)
 		{
 			size_t fragmentId = entry.first - fragment_program.offset;
 			if (fragmentId == offsetInFP)
@@ -344,7 +341,7 @@ void D3D12GSRender::FillPixelShaderConstantsBuffer()
 				vector[3] = (u32&)entry.second.w;
 				break;
 			}
-		}
+		}*/
 		if (!isCommandBufferSetConstant)
 		{
 			auto data = vm::ps3::ptr<u32>::make(fragment_program.addr + (u32)offsetInFP);

rpcs3/Emu/RSX/D3D12/D3D12GSRender.cpp

@@ -291,10 +291,6 @@ void D3D12GSRender::onexit_thread()
 {
 }
 
-void D3D12GSRender::OnReset()
-{
-}
-
 bool D3D12GSRender::domethod(u32 cmd, u32 arg)
 {
 	switch (cmd)
@@ -411,35 +407,10 @@ void D3D12GSRender::end()
 
 	std::chrono::time_point<std::chrono::system_clock> vertexIndexDurationStart = std::chrono::system_clock::now();
 
-	// Init vertex count
+	if (!vertex_index_array.empty() || vertex_draw_count)
-	if (m_indexed_array.m_count)
 	{
-		for (u32 i = 0; i < rsx::limits::vertex_count; ++i)
+		const std::vector<D3D12_VERTEX_BUFFER_VIEW> &vertexBufferViews = UploadVertexBuffers(!vertex_index_array.empty());
-		{
+		const D3D12_INDEX_BUFFER_VIEW &indexBufferView = uploadIndexBuffers(!vertex_index_array.empty());
-			if (!vertex_arrays_info[i].size) continue;
-			if (!vertex_arrays_info[i].array) continue;
-
-			const u32 tsize = rsx::get_vertex_type_size(vertex_arrays_info[i].type);
-			m_vertexBufferSize[i] = (m_indexed_array.index_min + m_indexed_array.index_max - m_indexed_array.index_min + 1) * tsize * vertex_arrays_info[i].size;
-		}
-	}
-	else
-	{
-		for (u32 i = 0; i < rsx::limits::vertex_count; ++i)
-		{
-			if (!vertex_arrays_info[i].size) continue;
-			if (!vertex_arrays_info[i].array) continue;
-
-			const u32 tsize = rsx::get_vertex_type_size(vertex_arrays_info[i].type);
-			m_vertexBufferSize[i] = (draw_array_first + draw_array_count) * tsize * vertex_arrays_info[i].size;
-		}
-	}
-
-
-	if (m_indexed_array.m_count || draw_array_count)
-	{
-		const std::vector<D3D12_VERTEX_BUFFER_VIEW> &vertexBufferViews = UploadVertexBuffers(m_indexed_array.m_count ? true : false);
-		const D3D12_INDEX_BUFFER_VIEW &indexBufferView = uploadIndexBuffers(m_indexed_array.m_count ? true : false);
 		getCurrentResourceStorage().m_commandList->IASetVertexBuffers(0, (UINT)vertexBufferViews.size(), vertexBufferViews.data());
 		if (m_renderingInfo.m_indexed)
 			getCurrentResourceStorage().m_commandList->IASetIndexBuffer(&indexBufferView);
@@ -624,7 +595,7 @@ void D3D12GSRender::end()
 	else
 		getCurrentResourceStorage().m_commandList->DrawInstanced((UINT)m_renderingInfo.m_count, 1, (UINT)m_renderingInfo.m_baseVertex, 0);
 
-	m_indexed_array.Reset();
+	vertex_index_array.clear();
 	std::chrono::time_point<std::chrono::system_clock> endDuration = std::chrono::system_clock::now();
 	m_timers.m_drawCallDuration += std::chrono::duration_cast<std::chrono::microseconds>(endDuration - startDuration).count();
 	m_timers.m_drawCallCount++;
@@ -669,9 +640,9 @@ void D3D12GSRender::flip(int buffer)
 		size_t w = 0, h = 0, rowPitch = 0;
 
 		size_t offset = 0;
-		if (m_read_buffer)
+		if (false)
 		{
-			CellGcmDisplayInfo* buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr);
+			CellGcmDisplayInfo* buffers;// = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr);
 			u32 addr = rsx::get_address(buffers[gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL);
 			w = buffers[gcm_current_buffer].width;
 			h = buffers[gcm_current_buffer].height;
@@ -818,6 +789,7 @@ void D3D12GSRender::flip(int buffer)
 	storage.m_getPosUAVHeap = m_UAVHeap.getCurrentPutPosMinusOne();
 
 	// Flush
+	local_transform_constants.clear();
 	m_texturesRTTs.clear();
 
 	// Now get ready for next frame

rpcs3/Emu/RSX/D3D12/D3D12GSRender.h

@@ -310,11 +310,12 @@ private:
 	// Copy of RTT to be used as texture
 	std::unordered_map<u32, ID3D12Resource* > m_texturesRTTs;
 
+	rsx::surface_info m_surface;
+
 	RSXFragmentProgram fragment_program;
 	PipelineStateObjectCache m_cachePSO;
 	std::pair<ID3D12PipelineState *, size_t> *m_PSO;
-
+	std::unordered_map<u32, color4f> local_transform_constants;
-	size_t m_vertexBufferSize[32];
 
 	struct
 	{
@@ -455,13 +456,9 @@ public:
 	D3D12GSRender();
 	virtual ~D3D12GSRender();
 
-	virtual void semaphorePGRAPHTextureReadRelease(u32 offset, u32 value) override;
+	virtual void semaphorePGRAPHTextureReadRelease(u32 offset, u32 value);
-	virtual void semaphorePGRAPHBackendRelease(u32 offset, u32 value) override;
+	virtual void semaphorePGRAPHBackendRelease(u32 offset, u32 value);
-	virtual void semaphorePFIFOAcquire(u32 offset, u32 value) override;
+	virtual void semaphorePFIFOAcquire(u32 offset, u32 value);
-	virtual void notifyProgramChange() override;
-	virtual void notifyBlendStateChange() override;
-	virtual void notifyDepthStencilStateChange() override;
-	virtual void notifyRasterizerStateChange() override;
 
 private:
 	void InitD2DStructures();
@@ -512,7 +509,6 @@ private:
 
 protected:
 	virtual void onexit_thread() override;
-	virtual void OnReset() override;
 	virtual bool domethod(u32 cmd, u32 arg) override;
 	virtual void end() override;
 	virtual void flip(int buffer) override;

rpcs3/Emu/RSX/D3D12/D3D12PipelineState.cpp

@@ -33,36 +33,29 @@ void Shader::Compile(const std::string &code, SHADER_TYPE st)
 	}
 }
 
-void D3D12GSRender::notifyProgramChange()
-{
-	m_PSO = nullptr;
-}
-void D3D12GSRender::notifyBlendStateChange()
-{
-	m_PSO = nullptr;
-}
-void D3D12GSRender::notifyDepthStencilStateChange()
-{
-	m_PSO = nullptr;
-}
-void D3D12GSRender::notifyRasterizerStateChange()
-{
-	m_PSO = nullptr;
-}
-
 bool D3D12GSRender::LoadProgram()
 {
+	RSXVertexProgram vertex_program;
+	u32 transform_program_start = rsx::method_registers[NV4097_SET_TRANSFORM_PROGRAM_START];
+	vertex_program.data.reserve((512 - transform_program_start) * 4);
+
+	for (int i = transform_program_start; i < 512; ++i)
+	{
+		vertex_program.data.resize((i - transform_program_start) * 4 + 4);
+		memcpy(vertex_program.data.data() + (i - transform_program_start) * 4, transform_program + i * 4, 4 * sizeof(u32));
+
+		D3 d3;
+		d3.HEX = transform_program[i * 4 + 3];
+
+		if (d3.end)
+			break;
+	}
+
 	u32 shader_program = rsx::method_registers[NV4097_SET_SHADER_PROGRAM];
 	fragment_program.offset = shader_program & ~0x3;
 	fragment_program.addr = rsx::get_address(fragment_program.offset, (shader_program & 0x3) - 1);
 	fragment_program.ctrl = rsx::method_registers[NV4097_SET_SHADER_CONTROL];
 
-	if (!m_cur_vertex_prog)
-	{
-		LOG_WARNING(RSX, "LoadProgram: m_cur_vertex_prog == NULL");
-		return false;
-	}
-
 	D3D12PipelineProperties prop = {};
 	switch (draw_mode - 1)
 	{
@@ -300,7 +293,7 @@ bool D3D12GSRender::LoadProgram()
 
 	prop.IASet = m_IASet;
 
-	m_PSO = m_cachePSO.getGraphicPipelineState(m_cur_vertex_prog, &fragment_program, prop, std::make_pair(m_device.Get(), m_rootSignatures));
+	m_PSO = m_cachePSO.getGraphicPipelineState(&vertex_program, &fragment_program, prop, std::make_pair(m_device.Get(), m_rootSignatures));
 	return m_PSO != nullptr;
 }
 

rpcs3/Emu/RSX/GL/GLFragmentProgram.cpp

@@ -28,7 +28,7 @@ std::string GLFragmentDecompilerThread::compareFunction(COMPARE f, const std::st
 
 void GLFragmentDecompilerThread::insertHeader(std::stringstream & OS)
 {
-	OS << "#version 420" << std::endl;
+	OS << "#version 140" << std::endl;
 }
 
 void GLFragmentDecompilerThread::insertIntputs(std::stringstream & OS)
@@ -110,7 +110,7 @@ void GLFragmentDecompilerThread::insertMainEnd(std::stringstream & OS)
 			OS << "	" << table[i].first << " = " << table[i].second << ";" << std::endl;
 	}
 
-	OS << "};" << std::endl;
+	OS << "}" << std::endl;
 }
 
 void GLFragmentDecompilerThread::Task()

rpcs3/Emu/RSX/GL/GLGSRender.h

@@ -1,183 +1,101 @@
 #pragma once
 #include "Emu/RSX/GSRender.h"
 #include "GLBuffers.h"
+#include "gl_helpers.h"
 
 #define RSX_DEBUG 1
 
-
 #include "GLProgramBuffer.h"
 
 #pragma comment(lib, "opengl32.lib")
 
-#if RSX_DEBUG
-#define checkForGlError(sit) if((g_last_gl_error = glGetError()) != GL_NO_ERROR) printGlError(g_last_gl_error, sit)
-#else
-#define checkForGlError(sit)
-#endif
-
-extern GLenum g_last_gl_error;
-void printGlError(GLenum err, const char* situation);
-void printGlError(GLenum err, const std::string& situation);
-
-
 class GLTexture
 {
-	u32 m_id;
+	u32 m_id = 0;
 
 public:
-	GLTexture() : m_id(0)
+	void create();
-	{
-	}
 
-	void Create();
+	int gl_wrap(int wrap);
 
-	int GetGlWrap(int wrap);
+	float max_aniso(int aniso);
 
-	float GetMaxAniso(int aniso);
+	inline static u8 convert_4_to_8(u8 v)
-
-	inline static u8 Convert4To8(u8 v)
 	{
 		// Swizzle bits: 00001234 -> 12341234
 		return (v << 4) | (v);
 	}
 
-	inline static u8 Convert5To8(u8 v)
+	inline static u8 convert_5_to_8(u8 v)
 	{
 		// Swizzle bits: 00012345 -> 12345123
 		return (v << 3) | (v >> 2);
 	}
 
-	inline static u8 Convert6To8(u8 v)
+	inline static u8 convert_6_to_8(u8 v)
 	{
 		// Swizzle bits: 00123456 -> 12345612
 		return (v << 2) | (v >> 4);
 	}
 
-	void Init(rsx::texture& tex);
+	void init(rsx::texture& tex);
+	void save(rsx::texture& tex, const std::string& name);
+	void save(rsx::texture& tex);
+	void bind();
+	void unbind();
+	void remove();
 
-	void Save(rsx::texture& tex, const std::string& name);
+	u32 id() const;
-
-	void Save(rsx::texture& tex);
-
-	void Bind();
-
-	void Unbind();
-
-	void Delete();
 };
 
-class PostDrawObj
+class GLGSRender : public GSRender
-{
-protected:
-	GLFragmentProgram m_fp;
-	GLVertexProgram m_vp;
-	GLProgram m_program;
-	GLfbo m_fbo;
-	GLrbo m_rbo;
-
-public:
-	virtual void Draw();
-
-	virtual void InitializeShaders() = 0;
-	virtual void InitializeLocations() = 0;
-
-	void Initialize();
-};
-
-class DrawCursorObj : public PostDrawObj
-{
-	u32 m_tex_id;
-	void* m_pixels;
-	u32 m_width, m_height;
-	double m_pos_x, m_pos_y, m_pos_z;
-	bool m_update_texture, m_update_pos;
-
-public:
-	DrawCursorObj() : PostDrawObj()
-		, m_tex_id(0)
-		, m_update_texture(false)
-		, m_update_pos(false)
-	{
-	}
-
-	virtual void Draw();
-
-	virtual void InitializeShaders();
-
-	void SetTexture(void* pixels, int width, int height);
-
-	void SetPosition(float x, float y, float z = 0.0f);
-
-	void InitializeLocations();
-};
-
-class GLGSRender final : public GSRender
 {
 private:
-	std::vector<u8> m_vdata;
-	std::vector<PostDrawObj> m_post_draw_objs;
-
-	GLProgram m_program;
-	int m_fp_buf_num;
-	int m_vp_buf_num;
-	GLProgramBuffer m_prog_buffer;
-
 	GLFragmentProgram m_fragment_prog;
 	GLVertexProgram m_vertex_prog;
 
 	GLTexture m_gl_textures[rsx::limits::textures_count];
 	GLTexture m_gl_vertex_textures[rsx::limits::vertex_textures_count];
 
-	GLvao m_vao;
+	//TODO: program cache
-	GLvbo m_vbo;
+	gl::glsl::program m_program;
-	GLrbo m_rbo;
-	GLfbo m_fbo;
 
-	void* m_context;
+	rsx::surface_info m_surface;
 
 public:
-	u32 m_draw_frames;
+	gl::fbo draw_fbo;
-	u32 m_skip_frames;
+	gl::buffers clear_surface_buffers = gl::buffers::none;
-	bool is_intel_vendor;
-	
-	GLGSRender();
-	virtual ~GLGSRender() override;
 
 private:
-	void EnableVertexData(bool indexed_draw = false);
+	GLProgramBuffer m_prog_buffer;
-	void DisableVertexData();
-	void InitVertexData();
-	void InitFragmentData();
 
-	void Enable(bool enable, const u32 cap);
+	gl::texture m_draw_tex_color[rsx::limits::color_buffers_count];
+	gl::texture m_draw_tex_depth_stencil;
 
-	bool LoadProgram();
+	//buffer
-	void WriteBuffers();
+	gl::fbo m_flip_fbo;
-	void WriteDepthBuffer();
+	gl::texture m_flip_tex_color;
-	void WriteColorBuffers();
-	void WriteColorBufferA();
-	void WriteColorBufferB();
-	void WriteColorBufferC();
-	void WriteColorBufferD();
 
-	void DrawObjects();
+public:
-	void InitDrawBuffers();
+	GLGSRender();
+
+private:
+	static u32 enable(u32 enable, u32 cap);
+	static u32 enable(u32 enable, u32 cap, u32 index);
+
+public:
+	bool load_program();
+	void init_buffers();
+	void read_buffers();
+	void write_buffers();
 
 protected:
-	virtual void oninit() override;
+	void begin() override;
-	virtual void oninit_thread() override;
+	void end() override;
-	virtual void onexit_thread() override;
-	virtual void OnReset() override;
-	virtual bool domethod(u32, u32) override;
-	virtual void end() override;
-	virtual void flip(int buffer) override;
 
-	virtual void semaphorePGRAPHTextureReadRelease(u32 offset, u32 value) override;
+	void oninit_thread() override;
-	virtual void semaphorePGRAPHBackendRelease(u32 offset, u32 value) override;
+	void onexit_thread() override;
-	virtual void semaphorePFIFOAcquire(u32 offset, u32 value) override;
+	bool domethod(u32 id, u32 arg) override;
-
+	void flip(int buffer) override;
-	virtual void notifyProgramChange() override {}
+	u64 timestamp() const override;
-	virtual void notifyBlendStateChange() override {}
-	virtual void notifyDepthStencilStateChange() override {}
-	virtual void notifyRasterizerStateChange() override {}
 };

rpcs3/Emu/RSX/GL/GLProcTable.h

@@ -23,25 +23,12 @@ OPENGL_PROC(PFNGLATTACHSHADERPROC, AttachShader);
 OPENGL_PROC(PFNGLDETACHSHADERPROC, DetachShader);
 OPENGL_PROC(PFNGLGETATTRIBLOCATIONPROC, GetAttribLocation);
 OPENGL_PROC(PFNGLLINKPROGRAMPROC, LinkProgram);
-//OPENGL_PROC(PFNGLBINDFRAGDATALOCATIONPROC, BindFragDataLocation);
+OPENGL_PROC(PFNGLVALIDATEPROGRAMPROC, ValidateProgram);
+OPENGL_PROC(PFNGLBINDFRAGDATALOCATIONPROC, BindFragDataLocation);
 OPENGL_PROC(PFNGLBINDATTRIBLOCATIONPROC, BindAttribLocation);
 OPENGL_PROC(PFNGLGETUNIFORMLOCATIONPROC, GetUniformLocation);
 OPENGL_PROC(PFNGLGETPROGRAMIVPROC, GetProgramiv);
 OPENGL_PROC(PFNGLGETPROGRAMINFOLOGPROC, GetProgramInfoLog);
-OPENGL_PROC(PFNGLVERTEXATTRIB4BVPROC, VertexAttrib4bv);
-OPENGL_PROC(PFNGLVERTEXATTRIB4UBVPROC, VertexAttrib4ubv);
-OPENGL_PROC(PFNGLVERTEXATTRIB1SPROC, VertexAttrib1s);
-OPENGL_PROC(PFNGLVERTEXATTRIB2SVPROC, VertexAttrib2sv);
-OPENGL_PROC(PFNGLVERTEXATTRIB3SVPROC, VertexAttrib3sv);
-OPENGL_PROC(PFNGLVERTEXATTRIB4SVPROC, VertexAttrib4sv);
-OPENGL_PROC(PFNGLVERTEXATTRIB4IVPROC, VertexAttrib4iv);
-OPENGL_PROC(PFNGLVERTEXATTRIB1FPROC, VertexAttrib1f);
-OPENGL_PROC(PFNGLVERTEXATTRIB2FPROC, VertexAttrib2f);
-OPENGL_PROC(PFNGLVERTEXATTRIB3FPROC, VertexAttrib3f);
-OPENGL_PROC(PFNGLVERTEXATTRIB4FPROC, VertexAttrib4f);
-OPENGL_PROC(PFNGLVERTEXATTRIB2FVPROC, VertexAttrib2fv);
-OPENGL_PROC(PFNGLVERTEXATTRIB3FVPROC, VertexAttrib3fv);
-OPENGL_PROC(PFNGLVERTEXATTRIB4FVPROC, VertexAttrib4fv);
 OPENGL_PROC(PFNGLVERTEXATTRIBPOINTERPROC, VertexAttribPointer);
 OPENGL_PROC(PFNGLENABLEVERTEXATTRIBARRAYPROC, EnableVertexAttribArray);
 OPENGL_PROC(PFNGLDISABLEVERTEXATTRIBARRAYPROC, DisableVertexAttribArray);
@@ -49,36 +36,106 @@ OPENGL_PROC(PFNGLGENVERTEXARRAYSPROC, GenVertexArrays);
 OPENGL_PROC(PFNGLBINDVERTEXARRAYPROC, BindVertexArray);
 OPENGL_PROC(PFNGLDELETEVERTEXARRAYSPROC, DeleteVertexArrays);
 OPENGL_PROC(PFNGLDEPTHRANGEFPROC, DepthRangef);
+
+OPENGL_PROC(PFNGLVERTEXATTRIB1FPROC, VertexAttrib1f);
+OPENGL_PROC(PFNGLVERTEXATTRIB1DPROC, VertexAttrib1d);
+OPENGL_PROC(PFNGLVERTEXATTRIB1FVPROC, VertexAttrib1fv);
+OPENGL_PROC(PFNGLVERTEXATTRIB1DVPROC, VertexAttrib1dv);
+OPENGL_PROC(PFNGLVERTEXATTRIB2FPROC, VertexAttrib2f);
+OPENGL_PROC(PFNGLVERTEXATTRIB2DPROC, VertexAttrib2d);
+OPENGL_PROC(PFNGLVERTEXATTRIB2FVPROC, VertexAttrib2fv);
+OPENGL_PROC(PFNGLVERTEXATTRIB2DVPROC, VertexAttrib2dv);
+OPENGL_PROC(PFNGLVERTEXATTRIB3FPROC, VertexAttrib3f);
+OPENGL_PROC(PFNGLVERTEXATTRIB3DPROC, VertexAttrib3d);
+OPENGL_PROC(PFNGLVERTEXATTRIB3FVPROC, VertexAttrib3fv);
+OPENGL_PROC(PFNGLVERTEXATTRIB3DVPROC, VertexAttrib3dv);
+OPENGL_PROC(PFNGLVERTEXATTRIB4FPROC, VertexAttrib4f);
+OPENGL_PROC(PFNGLVERTEXATTRIB4DPROC, VertexAttrib4d);
+OPENGL_PROC(PFNGLVERTEXATTRIB4IVPROC, VertexAttrib4iv);
+OPENGL_PROC(PFNGLVERTEXATTRIB4FVPROC, VertexAttrib4fv);
+OPENGL_PROC(PFNGLVERTEXATTRIB4DVPROC, VertexAttrib4dv);
+OPENGL_PROC(PFNGLVERTEXATTRIB4UIVPROC, VertexAttrib4uiv);
+
 OPENGL_PROC(PFNGLUNIFORM1IPROC, Uniform1i);
 OPENGL_PROC(PFNGLUNIFORM1FPROC, Uniform1f);
+OPENGL_PROC(PFNGLUNIFORM1DPROC, Uniform1d);
 OPENGL_PROC(PFNGLUNIFORM1UIPROC, Uniform1ui);
 OPENGL_PROC(PFNGLUNIFORM1IVPROC, Uniform1iv);
 OPENGL_PROC(PFNGLUNIFORM1FVPROC, Uniform1fv);
+OPENGL_PROC(PFNGLUNIFORM1DVPROC, Uniform1dv);
 OPENGL_PROC(PFNGLUNIFORM1UIVPROC, Uniform1uiv);
 OPENGL_PROC(PFNGLUNIFORM2IPROC, Uniform2i);
 OPENGL_PROC(PFNGLUNIFORM2FPROC, Uniform2f);
+OPENGL_PROC(PFNGLUNIFORM2DPROC, Uniform2d);
 OPENGL_PROC(PFNGLUNIFORM2UIPROC, Uniform2ui);
 OPENGL_PROC(PFNGLUNIFORM2IVPROC, Uniform2iv);
 OPENGL_PROC(PFNGLUNIFORM2FVPROC, Uniform2fv);
+OPENGL_PROC(PFNGLUNIFORM2DVPROC, Uniform2dv);
 OPENGL_PROC(PFNGLUNIFORM2UIVPROC, Uniform2uiv);
 OPENGL_PROC(PFNGLUNIFORM3IPROC, Uniform3i);
 OPENGL_PROC(PFNGLUNIFORM3FPROC, Uniform3f);
+OPENGL_PROC(PFNGLUNIFORM3DPROC, Uniform3d);
 OPENGL_PROC(PFNGLUNIFORM3UIPROC, Uniform3ui);
 OPENGL_PROC(PFNGLUNIFORM3IVPROC, Uniform3iv);
 OPENGL_PROC(PFNGLUNIFORM3FVPROC, Uniform3fv);
+OPENGL_PROC(PFNGLUNIFORM3DVPROC, Uniform3dv);
 OPENGL_PROC(PFNGLUNIFORM3UIVPROC, Uniform3uiv);
-OPENGL_PROC(PFNGLUNIFORM4FPROC, Uniform4i);
+OPENGL_PROC(PFNGLUNIFORM4IPROC, Uniform4i);
 OPENGL_PROC(PFNGLUNIFORM4FPROC, Uniform4f);
+OPENGL_PROC(PFNGLUNIFORM4DPROC, Uniform4d);
 OPENGL_PROC(PFNGLUNIFORM4UIPROC, Uniform4ui);
 OPENGL_PROC(PFNGLUNIFORM4IVPROC, Uniform4iv);
 OPENGL_PROC(PFNGLUNIFORM4FVPROC, Uniform4fv);
+OPENGL_PROC(PFNGLUNIFORM4DVPROC, Uniform4dv);
 OPENGL_PROC(PFNGLUNIFORM4UIVPROC, Uniform4uiv);
+OPENGL_PROC(PFNGLUNIFORMMATRIX2FVPROC, UniformMatrix2fv);
+OPENGL_PROC(PFNGLUNIFORMMATRIX2DVPROC, UniformMatrix2dv);
+OPENGL_PROC(PFNGLUNIFORMMATRIX3FVPROC, UniformMatrix3fv);
+OPENGL_PROC(PFNGLUNIFORMMATRIX3DVPROC, UniformMatrix3dv);
+OPENGL_PROC(PFNGLUNIFORMMATRIX4FVPROC, UniformMatrix4fv);
+OPENGL_PROC(PFNGLUNIFORMMATRIX4DVPROC, UniformMatrix4dv);
+
 OPENGL_PROC(PFNGLPROGRAMUNIFORM1IPROC, ProgramUniform1i);
 OPENGL_PROC(PFNGLPROGRAMUNIFORM1FPROC, ProgramUniform1f);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM1DPROC, ProgramUniform1d);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM1UIPROC, ProgramUniform1ui);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM1IVPROC, ProgramUniform1iv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM1FVPROC, ProgramUniform1fv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM1DVPROC, ProgramUniform1dv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM1UIVPROC, ProgramUniform1uiv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM2IPROC, ProgramUniform2i);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM2FPROC, ProgramUniform2f);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM2DPROC, ProgramUniform2d);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM2UIPROC, ProgramUniform2ui);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM2IVPROC, ProgramUniform2iv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM2FVPROC, ProgramUniform2fv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM2DVPROC, ProgramUniform2dv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM2UIVPROC, ProgramUniform2uiv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM3IPROC, ProgramUniform3i);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM3FPROC, ProgramUniform3f);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM3DPROC, ProgramUniform3d);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM3UIPROC, ProgramUniform3ui);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM3IVPROC, ProgramUniform3iv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM3FVPROC, ProgramUniform3fv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM3DVPROC, ProgramUniform3dv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM3UIVPROC, ProgramUniform3uiv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM4IPROC, ProgramUniform4i);
 OPENGL_PROC(PFNGLPROGRAMUNIFORM4FPROC, ProgramUniform4f);
-OPENGL_PROC(PFNGLUNIFORMMATRIX4FVPROC, UniformMatrix4fv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM4DPROC, ProgramUniform4d);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM4UIPROC, ProgramUniform4ui);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM4IVPROC, ProgramUniform4iv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM4FVPROC, ProgramUniform4fv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM4DVPROC, ProgramUniform4dv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORM4UIVPROC, ProgramUniform4uiv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORMMATRIX2FVPROC, ProgramUniformMatrix2fv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORMMATRIX2DVPROC, ProgramUniformMatrix2dv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORMMATRIX3FVPROC, ProgramUniformMatrix3fv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORMMATRIX3DVPROC, ProgramUniformMatrix3dv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORMMATRIX4FVPROC, ProgramUniformMatrix4fv);
+OPENGL_PROC(PFNGLPROGRAMUNIFORMMATRIX4DVPROC, ProgramUniformMatrix4dv);
+
 OPENGL_PROC(PFNGLUSEPROGRAMPROC, UseProgram);
-OPENGL_PROC2(PFNGLDEPTHBOUNDSEXTPROC, DepthBoundsEXT, glDepthBoundsEXT);
+OPENGL_PROC(PFNGLDEPTHBOUNDSEXTPROC, DepthBoundsEXT);
 OPENGL_PROC(PFNGLSTENCILOPSEPARATEPROC, StencilOpSeparate);
 OPENGL_PROC(PFNGLSTENCILFUNCSEPARATEPROC, StencilFuncSeparate);
 OPENGL_PROC(PFNGLSTENCILMASKSEPARATEPROC, StencilMaskSeparate);
@@ -96,13 +153,25 @@ OPENGL_PROC(PFNGLFRAMEBUFFERTEXTURE3DPROC, FramebufferTexture3D);
 OPENGL_PROC(PFNGLFRAMEBUFFERRENDERBUFFERPROC, FramebufferRenderbuffer);
 OPENGL_PROC(PFNGLBLITFRAMEBUFFERPROC, BlitFramebuffer);
 OPENGL_PROC(PFNGLDRAWBUFFERSPROC, DrawBuffers);
+
+OPENGL_PROC(PFNGLENABLEIPROC, Enablei);
+OPENGL_PROC(PFNGLDISABLEIPROC, Disablei);
+
 OPENGL_PROC(PFNGLPRIMITIVERESTARTINDEXPROC, PrimitiveRestartIndex);
 
+OPENGL_PROC(PFNGLGETINTEGER64VPROC, GetInteger64v);
+
+OPENGL_PROC(PFNGLCHECKFRAMEBUFFERSTATUSPROC, CheckFramebufferStatus);
+
+//KHR_debug
+OPENGL_PROC(PFNGLDEBUGMESSAGECONTROLARBPROC, DebugMessageControlARB);
+OPENGL_PROC(PFNGLDEBUGMESSAGEINSERTARBPROC, DebugMessageInsertARB);
+OPENGL_PROC(PFNGLDEBUGMESSAGECALLBACKARBPROC, DebugMessageCallbackARB);
+//...
+
 #ifndef __GNUG__
 OPENGL_PROC(PFNGLBLENDCOLORPROC, BlendColor);
 OPENGL_PROC(PFNGLBLENDEQUATIONPROC, BlendEquation);
 OPENGL_PROC(PFNGLCOMPRESSEDTEXIMAGE2DPROC, CompressedTexImage2D);
 OPENGL_PROC(PFNGLACTIVETEXTUREPROC, ActiveTexture);
-
-OPENGL_PROC2(PFNWGLSWAPINTERVALEXTPROC, SwapInterval, wglSwapIntervalEXT);
 #endif

rpcs3/Emu/RSX/GL/GLProgram.cpp

@@ -3,7 +3,7 @@
 #include "Emu/Memory/Memory.h"
 #include "GLProgram.h"
 #include "GLGSRender.h"
-
+/*
 GLProgram::GLProgram() : id(0)
 {
 }
@@ -116,3 +116,4 @@ void GLProgram::Delete()
 	id = 0;
 	m_locations.clear();
 }
+*/

rpcs3/Emu/RSX/GL/GLProgram.h

@@ -1,7 +1,8 @@
 #pragma once
+
 #include "GLVertexProgram.h"
 #include "GLFragmentProgram.h"
-
+/*
 struct GLProgram
 {
 private:
@@ -27,3 +28,4 @@ public:
 	void SetVTex(u32 index);
 	void Delete();
 };
+*/

rpcs3/Emu/RSX/GL/GLProgramBuffer.h

@@ -7,7 +7,7 @@ struct GLTraits
 {
 	typedef GLVertexProgram VertexProgramData;
 	typedef GLFragmentProgram FragmentProgramData;
-	typedef GLProgram PipelineData;
+	typedef gl::glsl::program PipelineData;
 	typedef void* PipelineProperties;
 	typedef void* ExtraData;
 
@@ -36,12 +36,18 @@ struct GLTraits
 	static
 	PipelineData *BuildProgram(VertexProgramData &vertexProgramData, FragmentProgramData &fragmentProgramData, const PipelineProperties &pipelineProperties, const ExtraData& extraData)
 	{
-		GLProgram *result = new GLProgram();
+		PipelineData *result = new PipelineData();
-		result->Create(vertexProgramData.id, fragmentProgramData.id);
+		__glcheck result->create()
-		//checkForGlError("m_program.Create");
+			.attach(gl::glsl::shader_view(vertexProgramData.id))
-		result->Use();
+			.attach(gl::glsl::shader_view(fragmentProgramData.id))
+			.bind_fragment_data_location("ocol0", 0)
+			.bind_fragment_data_location("ocol1", 1)
+			.bind_fragment_data_location("ocol2", 2)
+			.bind_fragment_data_location("ocol3", 3)
+			.make();
+		__glcheck result->use();
 
-		LOG_NOTICE(RSX, "*** prog id = %d", result->id);
+		LOG_NOTICE(RSX, "*** prog id = %d", result->id());
 		LOG_NOTICE(RSX, "*** vp id = %d", vertexProgramData.id);
 		LOG_NOTICE(RSX, "*** fp id = %d", fragmentProgramData.id);
 
@@ -54,7 +60,7 @@ struct GLTraits
 	static
 	void DeleteProgram(PipelineData *ptr)
 	{
-		ptr->Delete();
+		ptr->remove();
 	}
 };
 

rpcs3/Emu/RSX/GL/GLVertexProgram.cpp

@@ -22,7 +22,7 @@ std::string GLVertexDecompilerThread::compareFunction(COMPARE f, const std::stri
 
 void GLVertexDecompilerThread::insertHeader(std::stringstream &OS)
 {
-	OS << "#version 420" << std::endl << std::endl;
+	OS << "#version 140" << std::endl << std::endl;
 	OS << "uniform mat4 scaleOffsetMat = mat4(1.0);" << std::endl;
 }
 
@@ -31,7 +31,7 @@ void GLVertexDecompilerThread::insertInputs(std::stringstream & OS, const std::v
 	for (const ParamType PT : inputs)
 	{
 		for (const ParamItem &PI : PT.items)
-			OS << "layout(location = " << PI.location << ") in " << PT.type << " " << PI.name << ";" << std::endl;
+			OS << /*"layout(location = " << PI.location << ") "*/  "in " << PT.type << " " << PI.name << ";" << std::endl;
 	}
 }
 

rpcs3/Emu/RSX/GL/OpenGL.cpp

@@ -2,7 +2,7 @@
 #include "Utilities/Log.h"
 #include "OpenGL.h"
 
-void InitProcTable()
+void gl::init()
 {
 #ifdef _WIN32
 #define OPENGL_PROC(p, n) OPENGL_PROC2(p, n, gl##n)

rpcs3/Emu/RSX/GL/OpenGL.h

@@ -25,7 +25,10 @@ typedef BOOL (WINAPI* PFNWGLSWAPINTERVALEXTPROC) (int interval);
 #include <GL/glxext.h>
 #endif
 
-void InitProcTable();
+namespace gl
+{
+	void init();
+}
 
 struct OpenGL
 {

rpcs3/Emu/RSX/GL/gl_helpers.cpp

@@ -0,0 +1,470 @@
+#include "stdafx.h"
+#include "gl_helpers.h"
+
+namespace gl
+{
+	const fbo screen{};
+
+	void fbo::create()
+	{
+		glGenFramebuffers(1, &m_id);
+	}
+
+	void fbo::bind() const
+	{
+		glBindFramebuffer(GL_FRAMEBUFFER, m_id);
+	}
+
+	void fbo::blit(const fbo& dst, areai src_area, areai dst_area, buffers buffers_, filter filter_) const
+	{
+		bind_as(target::read_frame_buffer);
+		dst.bind_as(target::draw_frame_buffer);
+		__glcheck glBlitFramebuffer(
+			src_area.x1, src_area.y1, src_area.x2, src_area.y2,
+			dst_area.x1, dst_area.y1, dst_area.x2, dst_area.y2,
+			(GLbitfield)buffers_, (GLenum)filter_);
+	}
+
+	void fbo::bind_as(target target_) const
+	{
+		glBindFramebuffer((int)target_, id());
+	}
+
+	void fbo::remove()
+	{
+		glDeleteFramebuffers(1, &m_id);
+		m_id = 0;
+	}
+
+	bool fbo::created() const
+	{
+		return m_id != 0;
+	}
+
+	void fbo::check() const
+	{
+		save_binding_state save(*this);
+		GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+
+		if (status != GL_FRAMEBUFFER_COMPLETE)
+		{
+			throw std::logic_error(fmt::format("0x%04x", status));
+		}
+	}
+
+	void fbo::recreate()
+	{
+		if (created())
+			remove();
+
+		create();
+	}
+
+	void fbo::draw_buffer(const attachment& buffer) const
+	{
+		save_binding_state save(*this);
+		GLenum buf = buffer.id();
+		__glcheck glDrawBuffers(1, &buf);
+	}
+
+	void fbo::draw_buffers(const std::initializer_list<attachment>& indexes) const
+	{
+		save_binding_state save(*this);
+		std::vector<GLenum> ids;
+		ids.reserve(indexes.size());
+
+		for (auto &index : indexes)
+			ids.push_back(index.id());
+
+		__glcheck glDrawBuffers((GLsizei)ids.size(), ids.data());
+	}
+
+	void fbo::draw_arrays(draw_mode mode, GLsizei count, GLint first) const
+	{
+		save_binding_state save(*this);
+		__glcheck glDrawArrays((GLenum)mode, first, count);
+	}
+
+	void fbo::draw_arrays(const buffer& buffer, draw_mode mode, GLsizei count, GLint first) const
+	{
+		buffer.bind(buffer::target::array);
+		draw_arrays(mode, count, first);
+	}
+
+	void fbo::draw_arrays(const vao& buffer, draw_mode mode, GLsizei count, GLint first) const
+	{
+		buffer.bind();
+		draw_arrays(mode, count, first);
+	}
+
+	void fbo::draw_elements(draw_mode mode, GLsizei count, indices_type type, const GLvoid *indices) const
+	{
+		save_binding_state save(*this);
+		__glcheck glDrawElements((GLenum)mode, count, (GLenum)type, indices);
+	}
+
+	void fbo::draw_elements(const buffer& buffer, draw_mode mode, GLsizei count, indices_type type, const GLvoid *indices) const
+	{
+		buffer.bind(buffer::target::array);
+		__glcheck glDrawElements((GLenum)mode, count, (GLenum)type, indices);
+	}
+
+	void fbo::draw_elements(draw_mode mode, GLsizei count, indices_type type, const buffer& indices, size_t indices_buffer_offset) const
+	{
+		indices.bind(buffer::target::element_array);
+		__glcheck glDrawElements((GLenum)mode, count, (GLenum)type, (GLvoid*)indices_buffer_offset);
+	}
+
+	void fbo::draw_elements(const buffer& buffer_, draw_mode mode, GLsizei count, indices_type type, const buffer& indices, size_t indices_buffer_offset) const
+	{
+		buffer_.bind(buffer::target::array);
+		draw_elements(mode, count, type, indices, indices_buffer_offset);
+	}
+
+	void fbo::draw_elements(draw_mode mode, GLsizei count, const GLubyte *indices) const
+	{
+		draw_elements(mode, count, indices_type::ubyte, indices);
+	}
+
+	void fbo::draw_elements(const buffer& buffer, draw_mode mode, GLsizei count, const GLubyte *indices) const
+	{
+		draw_elements(buffer, mode, count, indices_type::ubyte, indices);
+	}
+
+	void fbo::draw_elements(draw_mode mode, GLsizei count, const GLushort *indices) const
+	{
+		draw_elements(mode, count, indices_type::ushort, indices);
+	}
+
+	void fbo::draw_elements(const buffer& buffer, draw_mode mode, GLsizei count, const GLushort *indices) const
+	{
+		draw_elements(buffer, mode, count, indices_type::ushort, indices);
+	}
+
+	void fbo::draw_elements(draw_mode mode, GLsizei count, const GLuint *indices) const
+	{
+		draw_elements(mode, count, indices_type::uint, indices);
+	}
+
+	void fbo::draw_elements(const buffer& buffer, draw_mode mode, GLsizei count, const GLuint *indices) const
+	{
+		draw_elements(buffer, mode, count, indices_type::uint, indices);
+	}
+
+	void fbo::clear(buffers buffers_) const
+	{
+		save_binding_state save(*this);
+		glClear((GLbitfield)buffers_);
+	}
+
+	void fbo::clear(buffers buffers_, color4f color_value, double depth_value, u8 stencil_value) const
+	{
+		save_binding_state save(*this);
+		glClearColor(color_value.r, color_value.g, color_value.b, color_value.a);
+		glClearDepth(depth_value);
+		glClearStencil(stencil_value);
+		clear(buffers_);
+	}
+
+	void fbo::copy_from(const void* pixels, sizei size, gl::texture::format format_, gl::texture::type type_, class pixel_unpack_settings pixel_settings) const
+	{
+		save_binding_state save(*this);
+		pixel_settings.apply();
+		glDrawPixels(size.width, size.height, (GLenum)format_, (GLenum)type_, pixels);
+	}
+
+	void fbo::copy_from(const buffer& buf, sizei size, gl::texture::format format_, gl::texture::type type_, class pixel_unpack_settings pixel_settings) const
+	{
+		save_binding_state save(*this);
+		buffer::save_binding_state save_buffer(buffer::target::pixel_unpack, buf);
+		pixel_settings.apply();
+		glDrawPixels(size.width, size.height, (GLenum)format_, (GLenum)type_, nullptr);
+	}
+
+	void fbo::copy_to(void* pixels, coordi coord, gl::texture::format format_, gl::texture::type type_, class pixel_pack_settings pixel_settings) const
+	{
+		save_binding_state save(*this);
+		pixel_settings.apply();
+		glReadPixels(coord.x, coord.y, coord.width, coord.height, (GLenum)format_, (GLenum)type_, pixels);
+	}
+
+	void fbo::copy_to(const buffer& buf, coordi coord, gl::texture::format format_, gl::texture::type type_, class pixel_pack_settings pixel_settings) const
+	{
+		save_binding_state save(*this);
+		buffer::save_binding_state save_buffer(buffer::target::pixel_pack, buf);
+		pixel_settings.apply();
+		glReadPixels(coord.x, coord.y, coord.width, coord.height, (GLenum)format_, (GLenum)type_, nullptr);
+	}
+
+	fbo fbo::get_binded_draw_buffer()
+	{
+		GLint value;
+		glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &value);
+
+		return{ (GLuint)value };
+	}
+
+	fbo fbo::get_binded_read_buffer()
+	{
+		GLint value;
+		glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &value);
+
+		return{ (GLuint)value };
+	}
+
+	fbo fbo::get_binded_buffer()
+	{
+		GLint value;
+		glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value);
+
+		return{ (GLuint)value };
+	}
+
+	GLuint fbo::id() const
+	{
+		return m_id;
+	}
+
+	void fbo::set_id(GLuint id)
+	{
+		m_id = id;
+	}
+
+	void texture::settings::apply(const texture &texture) const
+	{
+		save_binding_state save(texture);
+
+		texture.pixel_unpack_settings().apply();
+
+		if (compressed_format(m_internal_format))
+		{
+			int compressed_image_size = m_compressed_image_size;
+			if (!compressed_image_size)
+			{
+				switch (m_internal_format)
+				{
+				case texture::internal_format::compressed_rgb_s3tc_dxt1:
+					compressed_image_size = ((m_width + 2) / 3) * ((m_height + 2) / 3) * 6;
+					break;
+
+				case texture::internal_format::compressed_rgba_s3tc_dxt1:
+					compressed_image_size = ((m_width + 3) / 4) * ((m_height + 3) / 4) * 8;
+					break;
+
+				case texture::internal_format::compressed_rgba_s3tc_dxt3:
+				case texture::internal_format::compressed_rgba_s3tc_dxt5:
+					compressed_image_size = ((m_width + 3) / 4) * ((m_height + 3) / 4) * 16;
+					break;
+				}
+			}
+
+			__glcheck glCompressedTexImage2D((GLenum)m_parent->get_target(), m_level, (GLint)m_internal_format, m_width, m_height, 0, compressed_image_size, m_pixels);
+		}
+		else
+		{
+			__glcheck glTexImage2D((GLenum)m_parent->get_target(), m_level, (GLint)m_internal_format, m_width, m_height, 0, (GLint)m_format, (GLint)m_type, m_pixels);
+		}
+
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_MAX_LEVEL, m_max_level);
+
+		if (m_pixels)
+		{
+			__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_GENERATE_MIPMAP, m_generate_mipmap ? GL_TRUE : GL_FALSE);
+		}
+
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_WRAP_S, (GLint)m_wrap_s);
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_WRAP_T, (GLint)m_wrap_t);
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_WRAP_R, (GLint)m_wrap_r);
+
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_COMPARE_MODE, (GLint)m_compare_mode);
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_COMPARE_FUNC, (GLint)m_compare_func);
+
+		__glcheck glTexParameterf((GLenum)m_parent->get_target(), GL_TEXTURE_MIN_LOD, m_max_lod);
+		__glcheck glTexParameterf((GLenum)m_parent->get_target(), GL_TEXTURE_MAX_LOD, m_min_lod);
+		__glcheck glTexParameterf((GLenum)m_parent->get_target(), GL_TEXTURE_LOD_BIAS, m_lod);
+
+		__glcheck glTexParameterfv((GLenum)m_parent->get_target(), GL_TEXTURE_BORDER_COLOR, m_border_color.rgba);
+
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_MIN_FILTER, (GLint)m_min_filter);
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_MAG_FILTER, (GLint)m_mag_filter);
+
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_SWIZZLE_R, (GLint)m_swizzle_r);
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_SWIZZLE_G, (GLint)m_swizzle_g);
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_SWIZZLE_B, (GLint)m_swizzle_b);
+		__glcheck glTexParameteri((GLenum)m_parent->get_target(), GL_TEXTURE_SWIZZLE_A, (GLint)m_swizzle_a);
+
+		__glcheck glTexParameterf((GLenum)m_parent->get_target(), GL_TEXTURE_MAX_ANISOTROPY_EXT, m_aniso);
+	}
+
+	void texture::settings::apply()
+	{
+		if (m_parent)
+		{
+			apply(*m_parent);
+			m_parent = nullptr;
+		}
+	}
+
+	texture::settings& texture::settings::swizzle(texture::channel r, texture::channel g, texture::channel b, texture::channel a)
+	{
+		m_swizzle_r = r;
+		m_swizzle_g = g;
+		m_swizzle_b = b;
+		m_swizzle_a = a;
+
+		return *this;
+	}
+
+	texture::settings& texture::settings::format(texture::format format)
+	{
+		m_format = format;
+		return *this;
+	}
+
+	texture::settings& texture::settings::type(texture::type type)
+	{
+		m_type = type;
+		return *this;
+	}
+
+	texture::settings& texture::settings::internal_format(texture::internal_format format)
+	{
+		m_internal_format = format;
+		return *this;
+	}
+
+	texture::settings& texture::settings::filter(min_filter min_filter, gl::filter mag_filter)
+	{
+		m_min_filter = min_filter;
+		m_mag_filter = mag_filter;
+
+		return *this;
+	}
+
+	texture::settings& texture::settings::width(uint width)
+	{
+		m_width = width;
+		return *this;
+	}
+
+	texture::settings& texture::settings::height(uint height)
+	{
+		m_height = height;
+		return *this;
+	}
+
+	texture::settings& texture::settings::size(sizei size)
+	{
+		return width(size.width).height(size.height);
+	}
+
+	texture::settings& texture::settings::level(int value)
+	{
+		m_level = value;
+		return *this;
+	}
+
+	texture::settings& texture::settings::compressed_image_size(int size)
+	{
+		m_compressed_image_size = size;
+		return *this;
+	}
+
+	texture::settings& texture::settings::pixels(const void* pixels)
+	{
+		m_pixels = pixels;
+		return *this;
+	}
+
+	texture::settings& texture::settings::aniso(float value)
+	{
+		m_aniso = value;
+		return *this;
+	}
+
+	texture::settings& texture::settings::compare_mode(texture::compare_mode value)
+	{
+		m_compare_mode = value;
+		return *this;
+	}
+	texture::settings& texture::settings::compare_func(texture::compare_func value)
+	{
+		m_compare_func = value;
+		return *this;
+	}
+	texture::settings& texture::settings::compare(texture::compare_func func, texture::compare_mode mode)
+	{
+		return compare_func(func).compare_mode(mode);
+	}
+
+	texture::settings& texture::settings::wrap_s(texture::wrap value)
+	{
+		m_wrap_s = value;
+		return *this;
+	}
+	texture::settings& texture::settings::wrap_t(texture::wrap value)
+	{
+		m_wrap_t = value;
+		return *this;
+	}
+	texture::settings& texture::settings::wrap_r(texture::wrap value)
+	{
+		m_wrap_r = value;
+		return *this;
+	}
+	texture::settings& texture::settings::wrap(texture::wrap s, texture::wrap t, texture::wrap r)
+	{
+		return wrap_s(s).wrap_t(t).wrap_r(r);
+	}
+
+	texture::settings& texture::settings::max_lod(float value)
+	{
+		m_max_lod = value;
+		return *this;
+	}
+	texture::settings& texture::settings::min_lod(float value)
+	{
+		m_min_lod = value;
+		return *this;
+	}
+	texture::settings& texture::settings::lod(float value)
+	{
+		m_lod = value;
+		return *this;
+	}
+	texture::settings& texture::settings::max_level(int value)
+	{
+		m_max_level = value;
+		return *this;
+	}
+	texture::settings& texture::settings::generate_mipmap(bool value)
+	{
+		m_generate_mipmap = value;
+		return *this;
+	}
+	texture::settings& texture::settings::mipmap(int level, int max_level, float lod, float min_lod, float max_lod, bool generate)
+	{
+		return this->level(level).max_level(max_level).lod(lod).min_lod(min_lod).max_lod(max_lod).generate_mipmap(generate);
+	}
+
+	texture::settings& texture::settings::border_color(color4f value)
+	{
+		m_border_color = value;
+		return *this;
+	}
+
+	texture_view texture::with_level(int level)
+	{
+		return{ get_target(), id() };
+	}
+
+	texture::settings texture::config()
+	{
+		return{ this };
+	}
+
+	void texture::config(const settings& settings_)
+	{
+		settings_.apply(*this);
+	}
+}

rpcs3/Emu/RSX/GSRender.cpp

@@ -5,9 +5,20 @@
 #include "GSManager.h"
 #include "GSRender.h"
 
+
 draw_context_t GSFrameBase::new_context()
 {
-	return std::shared_ptr<void>(make_context(), [this](void* ctxt) { delete_context(ctxt); });
+	if (void* context = make_context())
+	{
+		return std::shared_ptr<void>(context, [this](void* ctxt) { delete_context(ctxt); });
+	}
+
+	return nullptr;
+}
+
+void GSFrameBase::title_message(const std::wstring& msg)
+{
+	m_title_message = msg;
 }
 
 GSRender::GSRender(frame_type type) : m_frame(Emu.GetCallbacks().get_gs_frame(type).release())
@@ -58,29 +69,4 @@ void GSRender::flip(int buffer)
 {
 	if (m_frame)
 		m_frame->flip(m_context);
-}
+}
-
-
-GSLock::GSLock(GSRender& renderer, GSLockType type)
-	: m_renderer(renderer)
-	, m_type(type)
-{
-	switch (m_type)
-	{
-	case GS_LOCK_NOT_WAIT: m_renderer.cs_main.lock(); break;
-	case GS_LOCK_WAIT_FLIP: m_renderer.sem_flip.wait(); break;
-	}
-}
-
-GSLock::~GSLock()
-{
-	switch (m_type)
-	{
-	case GS_LOCK_NOT_WAIT: m_renderer.cs_main.unlock(); break;
-	case GS_LOCK_WAIT_FLIP: m_renderer.sem_flip.try_post(); break;
-	}
-}
-
-GSLockCurrent::GSLockCurrent(GSLockType type) : GSLock(Emu.GetGSManager().GetRender(), type)
-{
-}

rpcs3/Emu/RSX/GSRender.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "Emu/RSX/RSXThread.h"
+#include <memory>
 
 using draw_context_t = std::shared_ptr<void>;
 
@@ -21,6 +22,7 @@ public:
 
 	virtual void set_current(draw_context_t ctx) = 0;
 	virtual void flip(draw_context_t ctx) = 0;
+	virtual size2i client_size() = 0;
 
 	virtual void* handle() const = 0;
 	void title_message(const std::wstring&);
@@ -53,26 +55,3 @@ public:
 	void close();
 	void flip(int buffer) override;
 };
-
-enum GSLockType
-{
-	GS_LOCK_NOT_WAIT,
-	GS_LOCK_WAIT_FLIP,
-};
-
-struct GSLock
-{
-private:
-	GSRender& m_renderer;
-	GSLockType m_type;
-
-public:
-	GSLock(GSRender& renderer, GSLockType type);
-
-	~GSLock();
-};
-
-struct GSLockCurrent : GSLock
-{
-	GSLockCurrent(GSLockType type);
-};

rpcs3/Emu/RSX/Null/NullGSRender.cpp

@@ -0,0 +1,16 @@
+#include "stdafx.h"
+#include "NullGSRender.h"
+#include "Emu/System.h"
+
+NullGSRender::NullGSRender() : GSRender(frame_type::Null)
+{
+}
+
+void NullGSRender::onexit_thread()
+{
+}
+
+bool NullGSRender::domethod(u32 cmd, u32 value)
+{
+	return false;
+}

rpcs3/Emu/RSX/Null/NullGSRender.h

@@ -4,59 +4,9 @@
 class NullGSRender final : public GSRender
 {
 public:
-
+	NullGSRender();
-	NullGSRender() : GSRender(frame_type::Null)
-	{
-	}
-
-	virtual ~NullGSRender() override
-	{
-	}
 
 private:
-	virtual void oninit() override
+	void onexit_thread() override;
-	{
+	bool domethod(u32 cmd, u32 value) override;
-	}
-
-	virtual void oninit_thread() override
-	{
-	}
-
-	virtual void onexit_thread() override
-	{
-	}
-
-	virtual void OnReset() override
-	{
-	}
-
-	virtual bool domethod(u32, u32) override
-	{
-		return false;
-	}
-
-	virtual void end() override
-	{
-	}
-
-	virtual void flip(int buffer) override
-	{
-	}
-
-	virtual void semaphorePGRAPHTextureReadRelease(u32 offset, u32 value) override
-	{
-	}
-
-	virtual void semaphorePGRAPHBackendRelease(u32 offset, u32 value) override
-	{
-	}
-
-	virtual void semaphorePFIFOAcquire(u32 offset, u32 value) override
-	{
-	}
-
-	virtual void notifyProgramChange() override {}
-	virtual void notifyBlendStateChange() override {}
-	virtual void notifyDepthStencilStateChange() override {}
-	virtual void notifyRasterizerStateChange() override {}
 };

rpcs3/Emu/RSX/RSXTexture.cpp

@@ -18,7 +18,7 @@ namespace rsx
 		// Address
 		method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] =
 			((/*wraps*/1) | ((/*anisoBias*/0) << 4) | ((/*wrapt*/1) << 8) | ((/*unsignedRemap*/0) << 12) |
-				((/*wrapr*/3) << 16) | ((/*gamma*/0) << 20) | ((/*signedRemap*/0) << 24) | ((/*zfunc*/0) << 28));
+			((/*wrapr*/3) << 16) | ((/*gamma*/0) << 20) | ((/*signedRemap*/0) << 24) | ((/*zfunc*/0) << 28));
 
 		// Control0
 		method_registers[NV4097_SET_TEXTURE_CONTROL0 + (m_index * 8)] =
@@ -30,7 +30,7 @@ namespace rsx
 		// Filter
 		method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] =
 			((/*bias*/0) | ((/*conv*/1) << 13) | ((/*min*/5) << 16) | ((/*mag*/2) << 24)
-				| ((/*as*/0) << 28) | ((/*rs*/0) << 29) | ((/*gs*/0) << 30) | ((/*bs*/0) << 31));
+			| ((/*as*/0) << 28) | ((/*rs*/0) << 29) | ((/*gs*/0) << 30) | ((/*bs*/0) << 31));
 
 		// Image Rect
 		method_registers[NV4097_SET_TEXTURE_IMAGE_RECT + (m_index * 8)] = (/*height*/1) | ((/*width*/1) << 16);
@@ -222,7 +222,7 @@ namespace rsx
 		// Address
 		method_registers[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 8)] =
 			((/*wraps*/1) | ((/*anisoBias*/0) << 4) | ((/*wrapt*/1) << 8) | ((/*unsignedRemap*/0) << 12) |
-				((/*wrapr*/3) << 16) | ((/*gamma*/0) << 20) | ((/*signedRemap*/0) << 24) | ((/*zfunc*/0) << 28));
+			((/*wrapr*/3) << 16) | ((/*gamma*/0) << 20) | ((/*signedRemap*/0) << 24) | ((/*zfunc*/0) << 28));
 
 		// Control0
 		method_registers[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 8)] =
@@ -234,7 +234,7 @@ namespace rsx
 		// Filter
 		method_registers[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 8)] =
 			((/*bias*/0) | ((/*conv*/1) << 13) | ((/*min*/5) << 16) | ((/*mag*/2) << 24)
-				| ((/*as*/0) << 28) | ((/*rs*/0) << 29) | ((/*gs*/0) << 30) | ((/*bs*/0) << 31));
+			| ((/*as*/0) << 28) | ((/*rs*/0) << 29) | ((/*gs*/0) << 30) | ((/*bs*/0) << 31));
 
 		// Image Rect
 		method_registers[NV4097_SET_VERTEX_TEXTURE_IMAGE_RECT + (m_index * 8)] = (/*height*/1) | ((/*width*/1) << 16);

rpcs3/Emu/RSX/RSXTexture.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "Utilities/types.h"
 
 namespace rsx
 {
@@ -127,4 +128,4 @@ namespace rsx
 		//custom info
 		u8 index() const;
 	};
-}
+}

rpcs3/Emu/RSX/RSXThread.h

@@ -10,42 +10,6 @@
 #include "Utilities/Timer.h"
 #include "Utilities/types.h"
 
-enum Method
-{
-	CELL_GCM_METHOD_FLAG_NON_INCREMENT = 0x40000000,
-	CELL_GCM_METHOD_FLAG_JUMP = 0x20000000,
-	CELL_GCM_METHOD_FLAG_CALL = 0x00000002,
-	CELL_GCM_METHOD_FLAG_RETURN = 0x00020000,
-};
-
-struct RSXIndexArrayData
-{
-	std::vector<u8> m_data;
-	int m_type;
-	u32 m_first;
-	u32 m_count;
-	u32 m_addr;
-	u32 index_max;
-	u32 index_min;
-
-	RSXIndexArrayData()
-	{
-		Reset();
-	}
-
-	void Reset()
-	{
-		m_type = 0;
-		m_first = ~0;
-		m_count = 0;
-		m_addr = 0;
-		index_min = ~0;
-		index_max = 0;
-		m_data.clear();
-	}
-};
-
-
 namespace rsx
 {
 	namespace limits
@@ -62,6 +26,67 @@ namespace rsx
 		};
 	}
 
+	//TODO
+	union alignas(4) method_registers_t
+	{
+		u8 _u8[0x10000];
+		u32 _u32[0x10000 >> 2];
+/*
+		struct alignas(4)
+		{
+			u8 pad[NV4097_SET_TEXTURE_OFFSET - 4];
+
+			struct alignas(4) texture_t
+			{
+				u32 offset;
+
+				union format_t
+				{
+					u32 _u32;
+
+					struct
+					{
+						u32: 1;
+						u32 location : 1;
+						u32 cubemap : 1;
+						u32 border_type : 1;
+						u32 dimension : 4;
+						u32 format : 8;
+						u32 mipmap : 16;
+					};
+				} format;
+
+				union address_t
+				{
+					u32 _u32;
+
+					struct
+					{
+						u32 wrap_s : 4;
+						u32 aniso_bias : 4;
+						u32 wrap_t : 4;
+						u32 unsigned_remap : 4;
+						u32 wrap_r : 4;
+						u32 gamma : 4;
+						u32 signed_remap : 4;
+						u32 zfunc : 4;
+					};
+				} address;
+
+				u32 control0;
+				u32 control1;
+				u32 filter;
+				u32 image_rect;
+				u32 border_color;
+			} textures[limits::textures_count];
+		};
+*/
+		u32& operator[](int index)
+		{
+			return _u32[index >> 2];
+		}
+	};
+
 	extern u32 method_registers[0x10000 >> 2];
 
 	u32 get_address(u32 offset, u32 location);
@@ -120,23 +145,26 @@ namespace rsx
 
 	public:
 		CellGcmControl* ctrl = nullptr;
+
 		Timer timer_sync;
 
 		GcmTileInfo tiles[limits::tiles_count];
 		GcmZcullInfo zculls[limits::zculls_count];
-		texture textures[limits::textures_count];
+
-		vertex_texture m_vertex_textures[limits::vertex_textures_count];
+		rsx::texture textures[limits::textures_count];
+		rsx::vertex_texture vertex_textures[limits::vertex_textures_count];
 
 		data_array_format_info vertex_arrays_info[limits::vertex_count];
 		std::vector<u8> vertex_arrays[limits::vertex_count];
-		RSXIndexArrayData m_indexed_array;
+		std::vector<u8> vertex_index_array;
+		u32 vertex_draw_count = 0;
 
 		std::unordered_map<u32, color4_base<f32>> transform_constants;
-		std::unordered_map<u32, color4_base<f32>> fragment_constants;
 
-		u32 m_shader_ctrl;
+		u32 transform_program[512 * 4] = {};
-		RSXVertexProgram m_vertex_progs[limits::vertex_count];
+
-		RSXVertexProgram* m_cur_vertex_prog;
+		void load_vertex_data(u32 first, u32 count);
+		void load_vertex_index_data(u32 first, u32 count);
 
 	public:
 		u32 ioAddress, ioSize;
@@ -147,7 +175,7 @@ namespace rsx
 
 		u32 tiles_addr;
 		u32 zculls_addr;
-		u32 m_gcm_buffers_addr;
+		vm::ps3::ptr<CellGcmDisplayInfo> gcm_buffers;
 		u32 gcm_buffers_count;
 		u32 gcm_current_buffer;
 		u32 ctxt_addr;
@@ -155,16 +183,13 @@ namespace rsx
 		u32 label_addr;
 		u32 draw_mode;
 
-		// DMA
-		u32 dma_report;
-
 		u32 local_mem_addr, main_mem_addr;
 		bool strict_ordering[0x1000];
 
 	public:
 		u32 draw_array_count;
 		u32 draw_array_first;
-		double m_fps_limit = 59.94;
+		double fps_limit = 59.94;
 
 	public:
 		std::mutex cs_main;
@@ -182,7 +207,7 @@ namespace rsx
 		virtual ~thread() {}
 
 	public:
-		virtual void begin(u32 draw_mode);
+		virtual void begin();
 		virtual void end();
 
 		virtual void oninit() = 0;
@@ -200,293 +225,5 @@ namespace rsx
 
 		u32 ReadIO32(u32 addr);
 		void WriteIO32(u32 addr, u32 value);
-
-	public:
-		u32 m_ctrlAddress;
-		u32 m_width;
-		u32 m_height;
-		float m_width_scale;
-		float m_height_scale;
-		// Dither
-		bool m_set_dither;
-
-		// Clip 
-		bool m_set_clip;
-		float m_clip_min;
-		float m_clip_max;
-
-		// Depth bound test
-		bool m_set_depth_bounds_test;
-		bool m_set_depth_bounds;
-		float m_depth_bounds_min;
-		float m_depth_bounds_max;
-
-		// Primitive restart 
-		bool m_set_restart_index;
-		u32 m_restart_index;
-
-		// Point 
-		bool m_set_point_size;
-		bool m_set_point_sprite_control;
-		float m_point_size;
-		u16 m_point_x;
-		u16 m_point_y;
-
-		// Line smooth
-		bool m_set_line_smooth;
-
-		// Viewport & scissor
-		bool m_set_scissor_horizontal;
-		bool m_set_scissor_vertical;
-		u16 m_scissor_x;
-		u16 m_scissor_y;
-		u16 m_scissor_w;
-		u16 m_scissor_h;
-
-		// Polygon mode/offset
-		bool m_set_poly_smooth;
-		bool m_set_poly_offset_fill;
-		bool m_set_poly_offset_line;
-		bool m_set_poly_offset_point;
-		bool m_set_front_polygon_mode;
-		u32 m_front_polygon_mode;
-		bool m_set_back_polygon_mode;
-		u32 m_back_polygon_mode;
-		bool m_set_poly_offset_mode;
-		float m_poly_offset_scale_factor;
-		float m_poly_offset_bias;
-
-		// Line/Polygon stipple
-		bool m_set_line_stipple;
-		u16 m_line_stipple_pattern;
-		u16 m_line_stipple_factor;
-		bool m_set_polygon_stipple;
-		u32 m_polygon_stipple_pattern[32];
-
-
-		// Clearing
-		u32 m_clear_surface_mask;
-
-		// Stencil Test
-		bool m_set_two_side_light_enable;
-
-		// Line width
-		bool m_set_line_width;
-		float m_line_width;
-
-		// Shader mode
-		bool m_set_shade_mode;
-		u32 m_shade_mode;
-
-		// Lighting 
-		bool m_set_specular;
-
-		// Color
-		u32 m_color_format;
-		u16 m_color_format_src_pitch;
-		u16 m_color_format_dst_pitch;
-		u32 m_color_conv;
-		u32 m_color_conv_fmt;
-		u32 m_color_conv_op;
-		s16 m_color_conv_clip_x;
-		s16 m_color_conv_clip_y;
-		u16 m_color_conv_clip_w;
-		u16 m_color_conv_clip_h;
-		s16 m_color_conv_out_x;
-		s16 m_color_conv_out_y;
-		u16 m_color_conv_out_w;
-		u16 m_color_conv_out_h;
-		s32 m_color_conv_dsdx;
-		s32 m_color_conv_dtdy;
-
-		// Semaphore
-		// PGRAPH
-		u32 m_PGRAPH_semaphore_offset;
-		//PFIFO
-		u32 m_PFIFO_semaphore_offset;
-		u32 m_PFIFO_semaphore_release_value;
-
-		// Fog
-		bool m_set_fog_mode;
-		u32 m_fog_mode;
-		bool m_set_fog_params;
-		float m_fog_param0;
-		float m_fog_param1;
-
-		// Clip plane
-		bool m_set_clip_plane;
-		bool m_clip_plane_0;
-		bool m_clip_plane_1;
-		bool m_clip_plane_2;
-		bool m_clip_plane_3;
-		bool m_clip_plane_4;
-		bool m_clip_plane_5;
-
-		// Surface 
-		rsx::surface_info m_surface;
-		bool m_set_surface_clip_horizontal;
-		bool m_set_surface_clip_vertical;
-
-		// DMA context
-		u32 m_context_surface;
-		u32 m_context_dma_img_src;
-		u32 m_context_dma_img_dst;
-		u32 m_context_dma_buffer_in_src;
-		u32 m_context_dma_buffer_in_dst;
-		u32 m_dst_offset;
-
-		// Swizzle2D?
-		u16 m_swizzle_format;
-		u8 m_swizzle_width;
-		u8 m_swizzle_height;
-		u32 m_swizzle_offset;
-
-		// Shader
-		u16 m_shader_window_height;
-		u8 m_shader_window_origin;
-		u16 m_shader_window_pixel_centers;
-
-		// Vertex Data
-		u32 m_vertex_data_base_index;
-
-		// Frequency divider
-		u32 m_set_frequency_divider_operation;
-
-		u8 m_begin_end;
-		bool m_read_buffer;
-
-	protected:
-		thread()
-			: m_shader_ctrl(0x40)
-			, flip_status(0)
-			, flip_mode(CELL_GCM_DISPLAY_VSYNC)
-			, debug_level(CELL_GCM_DEBUG_LEVEL0)
-			, frequency_mode(CELL_GCM_DISPLAY_FREQUENCY_DISABLE)
-			, report_main_addr(0)
-			, main_mem_addr(0)
-			, local_mem_addr(0)
-			, draw_mode(0)
-			, draw_array_count(0)
-			, draw_array_first(~0)
-			, gcm_current_buffer(0)
-			, m_read_buffer(true)
-		{
-			flip_handler.set(0);
-			vblank_handler.set(0);
-			user_handler.set(0);
-			rsx::method_registers[NV4097_SET_ALPHA_TEST_ENABLE] = false;
-			m_set_depth_bounds_test = false;
-			rsx::method_registers[NV4097_SET_BLEND_ENABLE_MRT] = 0;
-			rsx::method_registers[NV4097_SET_BLEND_ENABLE] = false;
-			m_set_dither = false;
-			m_set_scissor_horizontal = false;
-			m_set_scissor_vertical = false;
-			m_set_line_smooth = false;
-			m_set_poly_smooth = false;
-			m_set_point_sprite_control = false;
-			m_set_specular = false;
-			m_set_two_side_light_enable = false;
-			m_set_surface_clip_horizontal = false;
-			m_set_surface_clip_vertical = false;
-			m_set_poly_offset_fill = false;
-			m_set_poly_offset_line = false;
-			m_set_poly_offset_point = false;
-			m_set_restart_index = false;
-			m_set_line_stipple = false;
-			m_set_polygon_stipple = false;
-
-			// Default value 
-			// TODO: Check against the default value on PS3 
-			rsx::method_registers[NV4097_SET_COLOR_CLEAR_VALUE] = 0;
-			rsx::method_registers[NV4097_SET_ZSTENCIL_CLEAR_VALUE] = 0xffffff << 8;
-			m_poly_offset_scale_factor = 0.0;
-			m_poly_offset_bias = 0.0;
-			m_restart_index = 0xffffffff;
-			m_front_polygon_mode = 0x1b02; // GL_FILL
-			m_back_polygon_mode = 0x1b02; // GL_FILL
-			rsx::method_registers[NV4097_SET_FRONT_FACE] = 0x0901; // GL_CCW
-			rsx::method_registers[NV4097_SET_CULL_FACE] = 0x0405; // GL_BACK
-			rsx::method_registers[NV4097_SET_ALPHA_FUNC] = 0x0207; // GL_ALWAYS
-			rsx::method_registers[NV4097_SET_ALPHA_REF] = 0.0f;
-			m_shade_mode = 0x1D01; // GL_SMOOTH
-
-			m_depth_bounds_min = 0.0;
-			m_depth_bounds_max = 1.0;
-			m_clip_min = 0.0;
-			m_clip_max = 1.0;
-			rsx::method_registers[NV4097_SET_BLEND_EQUATION] = (0x8006) | (0x8006 << 16); // GL_FUNC_ADD
-			rsx::method_registers[NV4097_SET_BLEND_FUNC_SFACTOR] = 1 | (1 << 16);
-			rsx::method_registers[NV4097_SET_BLEND_FUNC_DFACTOR] = 0;
-			m_point_x = 0;
-			m_point_y = 0;
-			m_point_size = 1.0;
-			m_line_width = 1.0;
-			m_line_stipple_pattern = 0xffff;
-			m_line_stipple_factor = 1;
-			rsx::method_registers[NV4097_SET_VERTEX_DATA_BASE_OFFSET] = 0;
-			m_vertex_data_base_index = 0;
-
-			// Construct Stipple Pattern
-			for (size_t i = 0; i < 32; i++)
-			{
-				m_polygon_stipple_pattern[i] = 0xFFFFFFFF;
-			}
-
-			// Construct Textures
-			for (int i = 0; i < 16; i++)
-			{
-				textures[i] = rsx::texture();
-			}
-
-			reset();
-		}
-
-		u32 OutOfArgsCount(const uint x, const u32 cmd, const u32 count, const u32 args_addr);
-		void DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const u32 count);
-
-		virtual void OnReset() = 0;
-
-		/**
-		 * This member is called when RSXThread parse a TEXTURE_READ_SEMAPHORE_RELEASE
-		 * command.
-		 * Backend is expected to write value at offset when current draw textures aren't
-		 * needed anymore by the GPU and can be modified.
-		 */
-		virtual void semaphorePGRAPHTextureReadRelease(u32 offset, u32 value) = 0;
-		/**
-		* This member is called when RSXThread parse a BACK_END_WRITE_SEMAPHORE_RELEASE
-		* command.
-		* Backend is expected to write value at offset when current draw call has completed
-		* and render surface can be used.
-		*/
-		virtual void semaphorePGRAPHBackendRelease(u32 offset, u32 value) = 0;
-		/**
-		* This member is called when RSXThread parse a SEMAPHORE_ACQUIRE command.
-		* Backend and associated GPU is expected to wait that memory at offset is the same
-		* as value. In particular buffer/texture buffers value can change while backend is
-		* waiting.
-		*/
-		virtual void semaphorePFIFOAcquire(u32 offset, u32 value) = 0;
-		/**
-		 * Called when vertex or fragment shader changes.
-		 * Backend can reuse same program if no change has been notified.
-		 */
-		virtual void notifyProgramChange() = 0;
-		/**
-		* Called when blend state changes.
-		* Backend can reuse same program if no change has been notified.
-		*/
-		virtual void notifyBlendStateChange() = 0;
-		/**
-		* Called when depth stencil state changes.
-		* Backend can reuse same program if no change has been notified.
-		*/
-		virtual void notifyDepthStencilStateChange() = 0;
-		/**
-		* Called when rasterizer state changes.
-		* Rasterizer state includes culling, color masking
-		* Backend can reuse same program if no change has been notified.
-		*/
-		virtual void notifyRasterizerStateChange() = 0;
 	};
 }

rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp

@@ -389,7 +389,7 @@ s32 _cellGcmInitBody(vm::pptr<CellGcmContextData> context, u32 cmdSize, u32 ioSi
 
 	auto& render = Emu.GetGSManager().GetRender();
 	render.ctxt_addr = context.addr();
-	render.m_gcm_buffers_addr = vm::alloc(sizeof(CellGcmDisplayInfo) * 8, vm::main);
+	render.gcm_buffers = { vm::alloc(sizeof(CellGcmDisplayInfo) * 8, vm::main) };
 	render.zculls_addr = vm::alloc(sizeof(CellGcmZcullInfo) * 8, vm::main);
 	render.tiles_addr = vm::alloc(sizeof(CellGcmTileInfo) * 15, vm::main);
 	render.gcm_buffers_count = 0;
@@ -438,7 +438,7 @@ s32 cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height
 		return CELL_EINVAL;
 	}
 
-	auto buffers = vm::get_ptr<CellGcmDisplayInfo>(Emu.GetGSManager().GetRender().m_gcm_buffers_addr);
+	auto buffers = Emu.GetGSManager().GetRender().gcm_buffers;
 
 	buffers[id].offset = offset;
 	buffers[id].pitch = pitch;
@@ -504,14 +504,23 @@ s32 cellGcmSetPrepareFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> ctxt, u32
 			return res;
 		}
 	}
-
+#ifdef __GNUC__
-	*ctxt->current++ = 0x3fead | (1 << 18);
+	//gcc internal compiler error, try to avoid it for now
+	*ctxt->current++ = (GCM_FLIP_COMMAND << 2) | (1 << 18);
 	*ctxt->current++ = id;
 
 	if (ctxt.addr() == gcm_info.context_addr)
 	{
-		vm::get_ref<CellGcmControl>(gcm_info.control_addr).put += 8;
+		vm::get_ref<CellGcmControl>(gcm_info.control_addr).put += 2 * sizeof(u32);
 	}
+#else
+	u32 command_size = rsx::make_command(ctxt->current, GCM_FLIP_COMMAND, id);
+
+	if (ctxt.addr() == gcm_info.context_addr)
+	{
+		vm::get_ref<CellGcmControl>(gcm_info.control_addr).put += command_size * sizeof(u32);
+	}
+#endif
 
 	return id;
 }
@@ -535,7 +544,7 @@ s32 cellGcmSetSecondVFrequency(u32 freq)
 	switch (freq)
 	{
 	case CELL_GCM_DISPLAY_FREQUENCY_59_94HZ:
-		Emu.GetGSManager().GetRender().frequency_mode = freq; Emu.GetGSManager().GetRender().m_fps_limit = 59.94; break;
+		Emu.GetGSManager().GetRender().frequency_mode = freq; Emu.GetGSManager().GetRender().fps_limit = 59.94; break;
 	case CELL_GCM_DISPLAY_FREQUENCY_SCANOUT:
 		Emu.GetGSManager().GetRender().frequency_mode = freq; cellGcmSys.Todo("Unimplemented display frequency: Scanout"); break;
 	case CELL_GCM_DISPLAY_FREQUENCY_DISABLE:
@@ -583,7 +592,7 @@ s32 cellGcmSetTileInfo(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u
 	tile.base = base;
 	tile.bank = bank;
 
-	vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().tiles_addr)[index] = tile.Pack();
+	vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().tiles_addr)[index] = tile.pack();
 	return CELL_OK;
 }
 
@@ -644,7 +653,7 @@ s32 cellGcmSetZcull(u8 index, u32 offset, u32 width, u32 height, u32 cullStart,
 	zcull.sRef = sRef;
 	zcull.sMask = sMask;
 
-	vm::get_ptr<CellGcmZcullInfo>(Emu.GetGSManager().GetRender().zculls_addr)[index] = zcull.Pack();
+	vm::get_ptr<CellGcmZcullInfo>(Emu.GetGSManager().GetRender().zculls_addr)[index] = zcull.pack();
 	return CELL_OK;
 }
 
@@ -694,8 +703,8 @@ u32 cellGcmGetZcullInfo()
 
 u32 cellGcmGetDisplayInfo()
 {
-	cellGcmSys.Warning("cellGcmGetDisplayInfo() = 0x%x", Emu.GetGSManager().GetRender().m_gcm_buffers_addr);
+	cellGcmSys.Warning("cellGcmGetDisplayInfo() = 0x%x", Emu.GetGSManager().GetRender().gcm_buffers.addr());
-	return Emu.GetGSManager().GetRender().m_gcm_buffers_addr;
+	return Emu.GetGSManager().GetRender().gcm_buffers.addr();
 }
 
 s32 cellGcmGetCurrentDisplayBufferId(vm::ptr<u8> id)
@@ -1174,7 +1183,7 @@ s32 cellGcmSetTile(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u8 co
 	tile.base = base;
 	tile.bank = bank;
 
-	vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().tiles_addr)[index] = tile.Pack();
+	vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().tiles_addr)[index] = tile.pack();
 	return CELL_OK;
 }
 

rpcs3/Emu/SysCalls/Modules/cellResc.cpp

@@ -475,28 +475,28 @@ void SetupRsxRenderingStates(vm::ptr<CellGcmContextData>& cntxt)
 	rsx::method_registers[NV4097_SET_BLEND_ENABLE_MRT] = false;
 //	r.m_set_logic_op = false;
 	rsx::method_registers[NV4097_SET_CULL_FACE_ENABLE] = false;
-	r.m_set_depth_bounds_test = false;
+//	r.m_set_depth_bounds_test = false;
 	rsx::method_registers[NV4097_SET_DEPTH_TEST_ENABLE] = false;
-	r.m_set_poly_offset_fill = false;
+//	r.m_set_poly_offset_fill = false;
 //	r.m_set_stencil_test = false;
 //	r.m_set_two_sided_stencil_test_enable = false;
-	r.m_set_two_side_light_enable = false;
+//	r.m_set_two_side_light_enable = false;
-	r.m_set_point_sprite_control = false;
+//	r.m_set_point_sprite_control = false;
-	r.m_set_dither = true;
+//	r.m_set_dither = true;
-	r.m_set_shade_mode = true; r.m_shade_mode = CELL_GCM_SMOOTH;
+//	r.m_set_shade_mode = true; r.m_shade_mode = CELL_GCM_SMOOTH;
-	r.m_set_frequency_divider_operation = CELL_GCM_FREQUENCY_DIVIDE;
+//	r.m_set_frequency_divider_operation = CELL_GCM_FREQUENCY_DIVIDE;
 
 	rsx::method_registers[NV4097_SET_SURFACE_CLIP_HORIZONTAL] = s_rescInternalInstance->m_dstWidth << 16;
 	rsx::method_registers[NV4097_SET_SURFACE_CLIP_VERTICAL] = s_rescInternalInstance->m_dstHeight << 16;
 
-	r.m_set_scissor_horizontal = r.m_set_scissor_vertical = true;
+//	r.m_set_scissor_horizontal = r.m_set_scissor_vertical = true;
-	r.m_scissor_x = 0;
+//	r.m_scissor_x = 0;
-	r.m_scissor_y = 0;
+//	r.m_scissor_y = 0;
-	r.m_scissor_w = s_rescInternalInstance->m_dstWidth;
+//	r.m_scissor_w = s_rescInternalInstance->m_dstWidth;
-	r.m_scissor_h = s_rescInternalInstance->m_dstHeight;
+//	r.m_scissor_h = s_rescInternalInstance->m_dstHeight;
 
-	r.m_width = s_rescInternalInstance->m_dstWidth;
+//	r.m_width = s_rescInternalInstance->m_dstWidth;
-	r.m_height = s_rescInternalInstance->m_dstHeight;
+//	r.m_height = s_rescInternalInstance->m_dstHeight;
 
 //	r.m_surface_depth_format = 2;
 	rsx::method_registers[NV4097_SET_SURFACE_COLOR_TARGET] = 1;

rpcs3/Emu/System.cpp

@@ -215,7 +215,8 @@ void Emulator::Load()
 	LOG_NOTICE(LOADER, "Resolution: %s", Ini.ResolutionIdToString(Ini.GSResolution.GetValue()));
 	LOG_NOTICE(LOADER, "Write Depth Buffer: %s", Ini.GSDumpDepthBuffer.GetValue() ? "Yes" : "No");
 	LOG_NOTICE(LOADER, "Write Color Buffers: %s", Ini.GSDumpColorBuffers.GetValue() ? "Yes" : "No");
-	LOG_NOTICE(LOADER, "Read Color Buffer: %s", Ini.GSReadColorBuffer.GetValue() ? "Yes" : "No");
+	LOG_NOTICE(LOADER, "Read Color Buffers: %s", Ini.GSReadColorBuffers.GetValue() ? "Yes" : "No");
+	LOG_NOTICE(LOADER, "Read Depth Buffer: %s", Ini.GSReadDepthBuffer.GetValue() ? "Yes" : "No");
 	LOG_NOTICE(LOADER, "Audio Out: %s", Ini.AudioOutIdToString(Ini.AudioOutMode.GetValue()));
 	LOG_NOTICE(LOADER, "Log Everything: %s", Ini.HLELogging.GetValue() ? "Yes" : "No");
 	LOG_NOTICE(LOADER, "RSX Logging: %s", Ini.RSXLogging.GetValue() ? "Yes" : "No");

rpcs3/Emu/System.h

@@ -3,6 +3,10 @@
 #include "Loader/Loader.h"
 #include "DbgCommand.h"
 
+//just for frame_type
+//TODO: provide better way
+#include "Emu/RSX/GSRender.h"
+
 struct EmuCallbacks
 {
 	std::function<void(std::function<void()>)> call_after;
@@ -11,7 +15,7 @@ struct EmuCallbacks
 	std::function<std::unique_ptr<class KeyboardHandlerBase>()> get_kb_handler;
 	std::function<std::unique_ptr<class MouseHandlerBase>()> get_mouse_handler;
 	std::function<std::unique_ptr<class PadHandlerBase>()> get_pad_handler;
-	std::function<std::unique_ptr<class GSFrameBase>(enum class frame_type)> get_gs_frame;
+	std::function<std::unique_ptr<class GSFrameBase>(frame_type)> get_gs_frame;
 	std::function<std::unique_ptr<class MsgDialogBase>()> get_msg_dialog;
 	std::function<std::unique_ptr<class SaveDialogBase>()> get_save_dialog;
 };

rpcs3/Gui/GLGSFrame.cpp

@@ -1,27 +1,14 @@
 #include "stdafx_gui.h"
-#include "Utilities/Log.h"
-#include "Emu/Memory/Memory.h"
-#include "Emu/System.h"
 #include "GLGSFrame.h"
-#include "Utilities/Timer.h"
-
-#ifndef _WIN32
-#include "frame_icon.xpm"
-#endif
 
 GLGSFrame::GLGSFrame() : GSFrame("OpenGL")
 {
-	SetIcon(wxICON(frame_icon));
 	m_canvas = new wxGLCanvas(this, wxID_ANY, NULL);
 	m_canvas->SetSize(GetClientSize());
 
 	m_canvas->Bind(wxEVT_LEFT_DCLICK, &GSFrame::OnLeftDclick, this);
 }
 
-GLGSFrame::~GLGSFrame()
-{
-}
-
 void* GLGSFrame::make_context()
 {
 	return new wxGLContext(m_canvas);
@@ -40,7 +27,9 @@ void GLGSFrame::delete_context(void* ctx)
 void GLGSFrame::flip(draw_context_t context)
 {
 	GSFrame::flip(context);
+
 	if (!m_canvas) return;
+
 	m_canvas->SetCurrent(*(wxGLContext*)context.get());
 	m_canvas->SwapBuffers();
 }
@@ -49,5 +38,6 @@ void GLGSFrame::OnSize(wxSizeEvent& event)
 {
 	if (m_canvas)
 		m_canvas->SetSize(GetClientSize());
+
 	event.Skip();
 }

rpcs3/Gui/GLGSFrame.h

@@ -1,20 +1,18 @@
 #pragma once
-#include "Emu/RSX/GL/GLGSRender.h"
 #include "Gui/GSFrame.h"
 #include "wx/glcanvas.h"
 
 class GLGSFrame : public GSFrame
 {
 	wxGLCanvas* m_canvas;
-	u32 m_frames;
+
 public:
 	GLGSFrame();
-	~GLGSFrame();
 
-	virtual void* make_context() override;
+	void* make_context() override;
-	virtual void set_current(draw_context_t context) override;
+	void set_current(draw_context_t context) override;
-	virtual void delete_context(void* ctx) override;
+	void delete_context(void* context) override;
-	virtual void flip(draw_context_t context) override;
+	void flip(draw_context_t context) override;
 
 private:
 	virtual void OnSize(wxSizeEvent& event);

rpcs3/Gui/GSFrame.cpp

@@ -3,14 +3,21 @@
 #include "Emu/System.h"
 #include "Emu/SysCalls/Modules/cellVideoOut.h"
 #include "rpcs3.h"
+#include "Utilities/Timer.h"
+
+#ifndef _WIN32
+#include "frame_icon.xpm"
+#endif
 
 BEGIN_EVENT_TABLE(GSFrame, wxFrame)
 	EVT_PAINT(GSFrame::OnPaint)
 	EVT_SIZE(GSFrame::OnSize)
 END_EVENT_TABLE()
 
-GSFrame::GSFrame(const wxString& title) : wxFrame(nullptr, wxID_ANY, title)
+GSFrame::GSFrame(const wxString& title) : wxFrame(nullptr, wxID_ANY, "GSFrame[" + title + "]")
 {
+	SetIcon(wxICON(frame_icon));
+
 	CellVideoOutResolution res = ResolutionTable[ResolutionIdToNum(Ini.GSResolution.GetValue())];
 	SetClientSize(res.width, res.height);
 	wxGetApp().Bind(wxEVT_KEY_DOWN, &GSFrame::OnKeyDown, this);
@@ -27,19 +34,6 @@ void GSFrame::OnClose(wxCloseEvent& event)
 	Emu.Stop();
 }
 
-/*
-void GSFrame::OnSize(wxSizeEvent&)
-{
-const wxSize client = GetClientSize();
-const wxSize viewport = AspectRatio(client, m_size);
-
-const int x = (client.GetX() - viewport.GetX()) / 2;
-const int y = (client.GetY() - viewport.GetY()) / 2;
-
-SetViewport(wxPoint(x, y), viewport);
-}
-*/
-
 void GSFrame::OnKeyDown(wxKeyEvent& event)
 {
 	switch (event.GetKeyCode())
@@ -93,6 +87,12 @@ void GSFrame::delete_context(void* ctx)
 {
 }
 
+size2i GSFrame::client_size()
+{
+	wxSize size = GetClientSize();
+	return{ size.GetWidth(), size.GetHeight() };
+}
+
 void GSFrame::flip(draw_context_t)
 {
 	++m_frames;
@@ -117,4 +117,4 @@ void GSFrame::flip(draw_context_t)
 		m_frames = 0;
 		fps_t.Start();
 	}
-}
+}

rpcs3/Gui/GSFrame.h

@@ -1,10 +1,10 @@
-#pragma once
+#pragma once 
-#include "Emu/Memory/vm.h"
 #include "Emu/RSX/GSRender.h"
 
 class GSFrame : public wxFrame, public GSFrameBase
 {
 	u64 m_frames;
+
 public:
 	GSFrame(const wxString& title);
 
@@ -27,6 +27,7 @@ protected:
 	void set_current(draw_context_t context) override;
 	void delete_context(void* context) override;
 	void flip(draw_context_t context) override;
+	size2i client_size() override;
 
 public:
 	void OnLeftDclick(wxMouseEvent&)

rpcs3/Gui/MainFrame.cpp

@@ -423,27 +423,27 @@ void MainFrame::ConfigLLEModules(wxCommandEvent& event)
 
 void MainFrame::OpenELFCompiler(wxCommandEvent& WXUNUSED(event))
 {
-	(new CompilerELF(this)) -> Show();
+	(new CompilerELF(this))->Show();
 }
 
 void MainFrame::OpenKernelExplorer(wxCommandEvent& WXUNUSED(event))
 {
-	(new KernelExplorer(this)) -> Show();
+	(new KernelExplorer(this))->Show();
 }
 
 void MainFrame::OpenMemoryViewer(wxCommandEvent& WXUNUSED(event))
 {
-	(new MemoryViewerPanel(this)) -> Show();
+	(new MemoryViewerPanel(this))->Show();
 }
 
 void MainFrame::OpenRSXDebugger(wxCommandEvent& WXUNUSED(event))
 {
-	(new RSXDebugger(this)) -> Show();
+	(new RSXDebugger(this))->Show();
 }
 
 void MainFrame::OpenStringSearch(wxCommandEvent& WXUNUSED(event))
 {
-	(new MemoryStringSearcher(this)) -> Show();
+	(new MemoryStringSearcher(this))->Show();
 }
 
 void MainFrame::OpenCgDisasm(wxCommandEvent& WXUNUSED(event))

rpcs3/Gui/RSXDebugger.cpp

@@ -1,11 +1,13 @@
 #include "stdafx_gui.h"
+
+#include "RSXDebugger.h"
+
 #include "rpcs3/Ini.h"
 #include "Utilities/rPlatform.h"
 #include "Utilities/Log.h"
 #include "Emu/Memory/Memory.h"
 #include "Emu/System.h"
 
-#include "RSXDebugger.h"
 #include "Emu/SysCalls/Modules/cellVideoOut.h"
 #include "Emu/RSX/GSManager.h"
 #include "Emu/RSX/GSRender.h"
@@ -296,7 +298,7 @@ void RSXDebugger::OnClickBuffer(wxMouseEvent& event)
 {
 	if (!RSXReady()) return;
 	const GSRender& render = Emu.GetGSManager().GetRender();
-	const auto buffers = vm::ps3::ptr<CellGcmDisplayInfo>::make(render.m_gcm_buffers_addr);
+	const auto buffers = render.gcm_buffers;
 
 	if(!buffers)
 		return;
@@ -331,9 +333,9 @@ void RSXDebugger::OnClickBuffer(wxMouseEvent& event)
 void RSXDebugger::GoToGet(wxCommandEvent& event)
 {
 	if (!RSXReady()) return;
-	auto ctrl = vm::get_ptr<CellGcmControl>(Emu.GetGSManager().GetRender().m_ctrlAddress);
+	//auto ctrl = vm::get_ptr<CellGcmControl>(Emu.GetGSManager().GetRender().ctrlAddress);
 	u32 realAddr;
-	if (RSXIOMem.getRealAddr(ctrl->get.load(), realAddr)) {
+	if (RSXIOMem.getRealAddr(0, realAddr)) {
 		m_addr = realAddr;
 		t_addr->SetValue(wxString::Format("%08x", m_addr));
 		UpdateInformation();
@@ -345,7 +347,7 @@ void RSXDebugger::GoToGet(wxCommandEvent& event)
 void RSXDebugger::GoToPut(wxCommandEvent& event)
 {
 	if (!RSXReady()) return;
-	auto ctrl = vm::get_ptr<CellGcmControl>(Emu.GetGSManager().GetRender().m_ctrlAddress);
+	auto ctrl = Emu.GetGSManager().GetRender().ctrl;
 	u32 realAddr;
 	if (RSXIOMem.getRealAddr(ctrl->put.load(), realAddr)) {
 		m_addr = realAddr;
@@ -410,10 +412,10 @@ void RSXDebugger::GetBuffers()
 	// TODO: Currently it only supports color buffers
 	for (u32 bufferId=0; bufferId < render.gcm_buffers_count; bufferId++)
 	{
-		if(!vm::check_addr(render.m_gcm_buffers_addr))
+		if(!vm::check_addr(render.gcm_buffers.addr()))
 			continue;
 
-		auto buffers = vm::get_ptr<CellGcmDisplayInfo>(render.m_gcm_buffers_addr);
+		auto buffers = render.gcm_buffers;
 		u32 RSXbuffer_addr = render.local_mem_addr + buffers[bufferId].offset;
 
 		if(!vm::check_addr(RSXbuffer_addr))
@@ -492,25 +494,26 @@ void RSXDebugger::GetFlags()
 
 #define LIST_FLAGS_ADD(name, value) \
 	m_list_flags->InsertItem(i, name); m_list_flags->SetItem(i, 1, value ? "Enabled" : "Disabled"); i++;
-
+	/*
-	LIST_FLAGS_ADD("Alpha test",         rsx::method_registers[NV4097_SET_ALPHA_TEST_ENABLE]);
+	LIST_FLAGS_ADD("Alpha test",         render.m_set_alpha_test);
-	LIST_FLAGS_ADD("Blend",              rsx::method_registers[NV4097_SET_BLEND_ENABLE]);
+	LIST_FLAGS_ADD("Blend",              render.m_set_blend);
 	LIST_FLAGS_ADD("Scissor",            render.m_set_scissor_horizontal && render.m_set_scissor_vertical);
-	LIST_FLAGS_ADD("Cull face",          rsx::method_registers[NV4097_SET_CULL_FACE]);
+	LIST_FLAGS_ADD("Cull face",          render.m_set_cull_face);
 	LIST_FLAGS_ADD("Depth bounds test",  render.m_set_depth_bounds_test);
-//	LIST_FLAGS_ADD("Depth test",         render.m_set_depth_test);
+	LIST_FLAGS_ADD("Depth test",         render.m_set_depth_test);
 	LIST_FLAGS_ADD("Dither",             render.m_set_dither);
 	LIST_FLAGS_ADD("Line smooth",        render.m_set_line_smooth);
-//	LIST_FLAGS_ADD("Logic op",           render.m_set_logic_op);
+	LIST_FLAGS_ADD("Logic op",           render.m_set_logic_op);
 	LIST_FLAGS_ADD("Poly smooth",        render.m_set_poly_smooth);
 	LIST_FLAGS_ADD("Poly offset fill",   render.m_set_poly_offset_fill);
 	LIST_FLAGS_ADD("Poly offset line",   render.m_set_poly_offset_line);
 	LIST_FLAGS_ADD("Poly offset point",  render.m_set_poly_offset_point);
-//	LIST_FLAGS_ADD("Stencil test",       render.m_set_stencil_test);
+	LIST_FLAGS_ADD("Stencil test",       render.m_set_stencil_test);
 	LIST_FLAGS_ADD("Primitive restart",  render.m_set_restart_index);
 	LIST_FLAGS_ADD("Two sided lighting", render.m_set_two_side_light_enable);
 	LIST_FLAGS_ADD("Point Sprite",	     render.m_set_point_sprite_control);
 	LIST_FLAGS_ADD("Lighting ",	         render.m_set_specular);
+	*/
 
 #undef LIST_FLAGS_ADD
 }
@@ -540,7 +543,7 @@ void RSXDebugger::GetLightning()
 #define LIST_LIGHTNING_ADD(name, value) \
 	m_list_lightning->InsertItem(i, name); m_list_lightning->SetItem(i, 1, value); i++;
 
-	LIST_LIGHTNING_ADD("Shade model", (render.m_shade_mode == 0x1D00) ? "Flat" : "Smooth");
+	//LIST_LIGHTNING_ADD("Shade model", (render.m_shade_mode == 0x1D00) ? "Flat" : "Smooth");
 
 #undef LIST_LIGHTNING_ADD
 }
@@ -591,85 +594,87 @@ void RSXDebugger::GetSettings()
 
 #define LIST_SETTINGS_ADD(name, value) \
 	m_list_settings->InsertItem(i, name); m_list_settings->SetItem(i, 1, value); i++;
-
+	/*
-	LIST_SETTINGS_ADD("Alpha func", !(rsx::method_registers[NV4097_SET_ALPHA_FUNC]) ? "(none)" : wxString::Format("0x%x (%s)",
+	LIST_SETTINGS_ADD("Alpha func", !(render.m_set_alpha_func) ? "(none)" : wxString::Format("0x%x (%s)",
-		rsx::method_registers[NV4097_SET_ALPHA_FUNC],
+		render.m_alpha_func,
-		ParseGCMEnum(rsx::method_registers[NV4097_SET_ALPHA_FUNC], CELL_GCM_ENUM)));
+		ParseGCMEnum(render.m_alpha_func, CELL_GCM_ENUM)));
-	LIST_SETTINGS_ADD("Blend color", !(rsx::method_registers[NV4097_SET_BLEND_COLOR]) ? "(none)" : wxString::Format("R:%d, G:%d, B:%d, A:%d",
+	LIST_SETTINGS_ADD("Blend color", !(render.m_set_blend_color) ? "(none)" : wxString::Format("R:%d, G:%d, B:%d, A:%d",
-		rsx::method_registers[NV4097_SET_BLEND_COLOR] & 0xFF,
+		render.m_blend_color_r,
-		(rsx::method_registers[NV4097_SET_BLEND_COLOR] >> 8) & 0xFF,
+		render.m_blend_color_g,
-		(rsx::method_registers[NV4097_SET_BLEND_COLOR] >> 16) & 0xFF,
+		render.m_blend_color_b,
-		(rsx::method_registers[NV4097_SET_BLEND_COLOR] >> 24) & 0xFF));
+		render.m_blend_color_a));
 	LIST_SETTINGS_ADD("Clipping", wxString::Format("Min:%f, Max:%f", render.m_clip_min, render.m_clip_max));
-	LIST_SETTINGS_ADD("Color mask", !(rsx::method_registers[NV4097_SET_COLOR_MASK]) ? "(none)" : wxString::Format("R:%d, G:%d, B:%d, A:%d",
+	LIST_SETTINGS_ADD("Color mask", !(render.m_set_color_mask) ? "(none)" : wxString::Format("R:%d, G:%d, B:%d, A:%d",
-		(rsx::method_registers[NV4097_SET_COLOR_MASK] >> 16) & 0xff,
+		render.m_color_mask_r,
-		(rsx::method_registers[NV4097_SET_COLOR_MASK] >> 8) & 0xff,
+		render.m_color_mask_g,
-		(rsx::method_registers[NV4097_SET_COLOR_MASK]) & 0xff,
+		render.m_color_mask_b,
-		(rsx::method_registers[NV4097_SET_COLOR_MASK] >> 24) & 0xff));
+		render.m_color_mask_a));
-	LIST_SETTINGS_ADD("Context DMA Color A", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_A]));
+	LIST_SETTINGS_ADD("Context DMA Color A", wxString::Format("0x%x", render.m_context_dma_color_a));
-	LIST_SETTINGS_ADD("Context DMA Color B", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_B]));
+	LIST_SETTINGS_ADD("Context DMA Color B", wxString::Format("0x%x", render.m_context_dma_color_b));
-	LIST_SETTINGS_ADD("Context DMA Color C", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_C]));
+	LIST_SETTINGS_ADD("Context DMA Color C", wxString::Format("0x%x", render.m_context_dma_color_c));
-	LIST_SETTINGS_ADD("Context DMA Color D", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_D]));
+	LIST_SETTINGS_ADD("Context DMA Color D", wxString::Format("0x%x", render.m_context_dma_color_d));
-	LIST_SETTINGS_ADD("Context DMA Zeta", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_CONTEXT_DMA_ZETA]));
+	LIST_SETTINGS_ADD("Context DMA Zeta", wxString::Format("0x%x", render.m_context_dma_z));
 	LIST_SETTINGS_ADD("Depth bounds", wxString::Format("Min:%f, Max:%f", render.m_depth_bounds_min, render.m_depth_bounds_max));
-//	LIST_SETTINGS_ADD("Depth func", !(render.m_set_depth_func) ? "(none)" : wxString::Format("0x%x (%s)",
+	LIST_SETTINGS_ADD("Depth func", !(render.m_set_depth_func) ? "(none)" : wxString::Format("0x%x (%s)",
-//		render.m_depth_func,
+		render.m_depth_func,
-//		ParseGCMEnum(render.m_depth_func, CELL_GCM_ENUM)));
+		ParseGCMEnum(render.m_depth_func, CELL_GCM_ENUM)));
 	LIST_SETTINGS_ADD("Draw mode", wxString::Format("%d (%s)",
-		render.draw_mode,
+		render.m_draw_mode,
-		ParseGCMEnum(render.draw_mode, CELL_GCM_PRIMITIVE_ENUM)));
+		ParseGCMEnum(render.m_draw_mode, CELL_GCM_PRIMITIVE_ENUM)));
 	LIST_SETTINGS_ADD("Scissor", wxString::Format("X:%d, Y:%d, W:%d, H:%d",
 		render.m_scissor_x,
 		render.m_scissor_y,
 		render.m_scissor_w,
 		render.m_scissor_h));
-//	LIST_SETTINGS_ADD("Stencil func", !(render.m_set_stencil_func) ? "(none)" : wxString::Format("0x%x (%s)",
+	LIST_SETTINGS_ADD("Stencil func", !(render.m_set_stencil_func) ? "(none)" : wxString::Format("0x%x (%s)",
-//		render.m_stencil_func,
+		render.m_stencil_func,
-//		ParseGCMEnum(render.m_stencil_func, CELL_GCM_ENUM)));
+		ParseGCMEnum(render.m_stencil_func, CELL_GCM_ENUM)));
-	LIST_SETTINGS_ADD("Surface Pitch A", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_PITCH_A]));
+	LIST_SETTINGS_ADD("Surface Pitch A", wxString::Format("0x%x", render.m_surface_pitch_a));
-	LIST_SETTINGS_ADD("Surface Pitch B", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_PITCH_B]));
+	LIST_SETTINGS_ADD("Surface Pitch B", wxString::Format("0x%x", render.m_surface_pitch_b));
-	LIST_SETTINGS_ADD("Surface Pitch C", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_PITCH_C]));
+	LIST_SETTINGS_ADD("Surface Pitch C", wxString::Format("0x%x", render.m_surface_pitch_c));
-	LIST_SETTINGS_ADD("Surface Pitch D", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_PITCH_D]));
+	LIST_SETTINGS_ADD("Surface Pitch D", wxString::Format("0x%x", render.m_surface_pitch_d));
-	LIST_SETTINGS_ADD("Surface Pitch Z", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_PITCH_Z]));
+	LIST_SETTINGS_ADD("Surface Pitch Z", wxString::Format("0x%x", render.m_surface_pitch_z));
-	LIST_SETTINGS_ADD("Surface Offset A", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_COLOR_AOFFSET]));
+	LIST_SETTINGS_ADD("Surface Offset A", wxString::Format("0x%x", render.m_surface_offset_a));
-	LIST_SETTINGS_ADD("Surface Offset B", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_COLOR_BOFFSET]));
+	LIST_SETTINGS_ADD("Surface Offset B", wxString::Format("0x%x", render.m_surface_offset_b));
-	LIST_SETTINGS_ADD("Surface Offset C", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_COLOR_COFFSET]));
+	LIST_SETTINGS_ADD("Surface Offset C", wxString::Format("0x%x", render.m_surface_offset_c));
-	LIST_SETTINGS_ADD("Surface Offset D", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_COLOR_DOFFSET]));
+	LIST_SETTINGS_ADD("Surface Offset D", wxString::Format("0x%x", render.m_surface_offset_d));
-	LIST_SETTINGS_ADD("Surface Offset Z", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_ZETA_OFFSET]));
+	LIST_SETTINGS_ADD("Surface Offset Z", wxString::Format("0x%x", render.m_surface_offset_z));
 	LIST_SETTINGS_ADD("Viewport", wxString::Format("X:%d, Y:%d, W:%d, H:%d",
-		rsx::method_registers[NV4097_SET_SURFACE_CLIP_HORIZONTAL] & 0xFFFF,
+		render.m_viewport_x,
-		rsx::method_registers[NV4097_SET_SURFACE_CLIP_VERTICAL] & 0xFFFF,
+		render.m_viewport_y,
-		rsx::method_registers[NV4097_SET_SURFACE_CLIP_HORIZONTAL] >> 16,
+		render.m_viewport_w,
-		rsx::method_registers[NV4097_SET_SURFACE_CLIP_VERTICAL] >> 16));
+		render.m_viewport_h));
-
+		*/
 #undef LIST_SETTINGS_ADD
 }
 
 void RSXDebugger::SetFlags(wxListEvent& event)
 {
+	/*
 	if (!RSXReady()) return;
 	GSRender& render = Emu.GetGSManager().GetRender();
 	switch(event.m_itemIndex)
 	{
-	case 0:  rsx::method_registers[NV4097_SET_ALPHA_TEST_ENABLE] ^= true; break;
+	case 0:  render.m_set_alpha_test		^= true; break;
-	case 1:  rsx::method_registers[NV4097_SET_BLEND_ENABLE] ^= true; break;
+	case 1:  render.m_set_blend			^= true; break;
-	case 2:  rsx::method_registers[NV4097_SET_CULL_FACE] ^= true; break;
+	case 2:  render.m_set_cull_face			^= true; break;
 	case 3:  render.m_set_depth_bounds_test		^= true; break;
-//	case 4:  render.m_set_depth_test		^= true; break;
+	case 4:  render.m_set_depth_test		^= true; break;
 	case 5:  render.m_set_dither			^= true; break;
 	case 6:  render.m_set_line_smooth		^= true; break;
-//	case 7:  render.m_set_logic_op			^= true; break;
+	case 7:  render.m_set_logic_op			^= true; break;
 	case 8:  render.m_set_poly_smooth		^= true; break;
 	case 9:  render.m_set_poly_offset_fill		^= true; break;
 	case 10: render.m_set_poly_offset_line		^= true; break;
 	case 11: render.m_set_poly_offset_point		^= true; break;
-//	case 12: render.m_set_stencil_test		^= true; break;
+	case 12: render.m_set_stencil_test		^= true; break;
 	case 13: render.m_set_point_sprite_control	^= true; break;
 	case 14: render.m_set_restart_index		^= true; break;
 	case 15: render.m_set_specular			^= true; break;
 	case 16: render.m_set_scissor_horizontal	^= true; break;
 	case 17: render.m_set_scissor_vertical		^= true; break;
 	}
+	*/
 
 	UpdateInformation();
 }
@@ -1206,4 +1211,4 @@ wxString RSXDebugger::DisAsmCommand(u32 cmd, u32 count, u32 currentAddr, u32 ioA
 bool RSXDebugger::RSXReady()
 {
 	return Emu.GetGSManager().IsInited();
-}
+}

rpcs3/Gui/RSXDebugger.h

@@ -2,8 +2,6 @@
 
 #include <wx/listctrl.h>
 
-
-
 class RSXDebugger : public wxFrame
 {
 	u32 m_addr;

rpcs3/Gui/SettingsDialog.cpp

@@ -118,7 +118,8 @@ SettingsDialog::SettingsDialog(wxWindow *parent)
 	wxCheckBox* chbox_gs_log_prog = new wxCheckBox(p_graphics, wxID_ANY, "Log shader programs");
 	wxCheckBox* chbox_gs_dump_depth = new wxCheckBox(p_graphics, wxID_ANY, "Write Depth Buffer");
 	wxCheckBox* chbox_gs_dump_color = new wxCheckBox(p_graphics, wxID_ANY, "Write Color Buffers");
-	wxCheckBox* chbox_gs_read_color = new wxCheckBox(p_graphics, wxID_ANY, "Read Color Buffer");
+	wxCheckBox* chbox_gs_read_color = new wxCheckBox(p_graphics, wxID_ANY, "Read Color Buffers");
+	wxCheckBox* chbox_gs_read_depth = new wxCheckBox(p_graphics, wxID_ANY, "Read Depth Buffer");
 	wxCheckBox* chbox_gs_vsync = new wxCheckBox(p_graphics, wxID_ANY, "VSync");
 	wxCheckBox* chbox_gs_debug_output = new wxCheckBox(p_graphics, wxID_ANY, "Debug Output");
 	wxCheckBox* chbox_gs_3dmonitor = new wxCheckBox(p_graphics, wxID_ANY, "3D Monitor");
@@ -256,7 +257,8 @@ SettingsDialog::SettingsDialog(wxWindow *parent)
 	chbox_gs_log_prog->SetValue(Ini.GSLogPrograms.GetValue());
 	chbox_gs_dump_depth->SetValue(Ini.GSDumpDepthBuffer.GetValue());
 	chbox_gs_dump_color->SetValue(Ini.GSDumpColorBuffers.GetValue());
-	chbox_gs_read_color->SetValue(Ini.GSReadColorBuffer.GetValue());
+	chbox_gs_read_color->SetValue(Ini.GSReadColorBuffers.GetValue());
+	chbox_gs_read_depth->SetValue(Ini.GSReadDepthBuffer.GetValue());
 	chbox_gs_vsync->SetValue(Ini.GSVSyncEnable.GetValue());
 	chbox_gs_debug_output->SetValue(Ini.GSDebugOutputEnable.GetValue());
 	chbox_gs_3dmonitor->SetValue(Ini.GS3DTV.GetValue());
@@ -346,9 +348,10 @@ SettingsDialog::SettingsDialog(wxWindow *parent)
 	s_subpanel_graphics1->Add(s_round_gs_render, wxSizerFlags().Border(wxALL, 5).Expand());
 	s_subpanel_graphics1->Add(s_round_gs_res, wxSizerFlags().Border(wxALL, 5).Expand());
 	s_subpanel_graphics1->Add(s_round_gs_d3d_adaptater, wxSizerFlags().Border(wxALL, 5).Expand());
-	s_subpanel_graphics1->Add(chbox_gs_dump_depth, wxSizerFlags().Border(wxALL, 5).Expand());
 	s_subpanel_graphics1->Add(chbox_gs_dump_color, wxSizerFlags().Border(wxALL, 5).Expand());
 	s_subpanel_graphics1->Add(chbox_gs_read_color, wxSizerFlags().Border(wxALL, 5).Expand());
+	s_subpanel_graphics1->Add(chbox_gs_dump_depth, wxSizerFlags().Border(wxALL, 5).Expand());
+	s_subpanel_graphics1->Add(chbox_gs_read_depth, wxSizerFlags().Border(wxALL, 5).Expand());
 	s_subpanel_graphics1->Add(chbox_gs_vsync, wxSizerFlags().Border(wxALL, 5).Expand());
 	s_subpanel_graphics2->Add(s_round_gs_aspect, wxSizerFlags().Border(wxALL, 5).Expand());
 	s_subpanel_graphics2->Add(s_round_gs_frame_limit, wxSizerFlags().Border(wxALL, 5).Expand());
@@ -437,7 +440,8 @@ SettingsDialog::SettingsDialog(wxWindow *parent)
 		Ini.GSLogPrograms.SetValue(chbox_gs_log_prog->GetValue());
 		Ini.GSDumpDepthBuffer.SetValue(chbox_gs_dump_depth->GetValue());
 		Ini.GSDumpColorBuffers.SetValue(chbox_gs_dump_color->GetValue());
-		Ini.GSReadColorBuffer.SetValue(chbox_gs_read_color->GetValue());
+		Ini.GSReadColorBuffers.SetValue(chbox_gs_read_color->GetValue());
+		Ini.GSReadDepthBuffer.SetValue(chbox_gs_read_depth->GetValue());
 		Ini.GSVSyncEnable.SetValue(chbox_gs_vsync->GetValue());
 		Ini.GSDebugOutputEnable.SetValue(chbox_gs_debug_output->GetValue());
 		Ini.GS3DTV.SetValue(chbox_gs_3dmonitor->GetValue());

rpcs3/Ini.h

@@ -111,7 +111,8 @@ public:
 	IniEntry<bool> GSLogPrograms;
 	IniEntry<bool> GSDumpColorBuffers;
 	IniEntry<bool> GSDumpDepthBuffer;
-	IniEntry<bool> GSReadColorBuffer;
+	IniEntry<bool> GSReadColorBuffers;
+	IniEntry<bool> GSReadDepthBuffer;
 	IniEntry<bool> GSVSyncEnable;
 	IniEntry<bool> GS3DTV;
 	IniEntry<bool> GSDebugOutputEnable;
@@ -202,16 +203,17 @@ public:
 		GSLogPrograms.Init("GS_LogPrograms", path);
 		GSDumpColorBuffers.Init("GS_DumpColorBuffers", path);
 		GSDumpDepthBuffer.Init("GS_DumpDepthBuffer", path);
-		GSReadColorBuffer.Init("GS_GSReadColorBuffer", path);
+		GSReadColorBuffers.Init("GS_ReadColorBuffer", path);
+		GSReadDepthBuffer.Init("GS_ReadDepthBuffer", path);
 		GSVSyncEnable.Init("GS_VSyncEnable", path);
 		GSDebugOutputEnable.Init("GS_DebugOutputEnable", path);
 		GS3DTV.Init("GS_3DTV", path);
 		GSOverlay.Init("GS_Overlay", path);
 
 		// Audio
-		AudioOutMode.Init("Audio_AudioOutMode", path);
+		AudioOutMode.Init("Audio_OutMode", path);
-		AudioDumpToFile.Init("Audio_AudioDumpToFile", path);
+		AudioDumpToFile.Init("Audio_DumpToFile", path);
-		AudioConvertToU16.Init("Audio_AudioConvertToU16", path);
+		AudioConvertToU16.Init("Audio_ConvertToU16", path);
 
 		// Camera
 		Camera.Init("Camera", path);
@@ -289,7 +291,8 @@ public:
 		GSLogPrograms.Load(false);
 		GSDumpColorBuffers.Load(false);
 		GSDumpDepthBuffer.Load(false);
-		GSReadColorBuffer.Load(false);
+		GSReadColorBuffers.Load(false);
+		GSReadDepthBuffer.Load(false);
 		GSVSyncEnable.Load(false);
 		GSDebugOutputEnable.Load(false);
 		GS3DTV.Load(false);
@@ -376,7 +379,8 @@ public:
 		GSLogPrograms.Save();
 		GSDumpColorBuffers.Save();
 		GSDumpDepthBuffer.Save();
-		GSReadColorBuffer.Save();
+		GSReadColorBuffers.Save();
+		GSReadDepthBuffer.Save();
 		GSVSyncEnable.Save();
 		GSDebugOutputEnable.Save();
 		GS3DTV.Save();

rpcs3/emucore.vcxproj

@@ -76,6 +76,8 @@
     <ClCompile Include="Emu\RSX\D3D12\D3D12VertexProgramDecompiler.cpp" />
     <ClCompile Include="Emu\RSX\D3D12\D3D12CommonDecompiler.cpp" />
     <ClCompile Include="Emu\RSX\GL\GLCommonDecompiler.cpp" />
+    <ClCompile Include="Emu\RSX\GL\gl_helpers.cpp" />
+    <ClCompile Include="Emu\RSX\Null\NullGSRender.cpp" />
     <ClCompile Include="Emu\SysCalls\lv2\sys_dbg.cpp" />
     <ClCompile Include="Emu\SysCalls\lv2\sys_fs.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellAtracMulti.cpp" />
@@ -557,6 +559,7 @@
     <ClInclude Include="Emu\RSX\GL\GLProgram.h" />
     <ClInclude Include="Emu\RSX\GL\GLProgramBuffer.h" />
     <ClInclude Include="Emu\RSX\GL\GLVertexProgram.h" />
+    <ClInclude Include="Emu\RSX\GL\gl_helpers.h" />
     <ClInclude Include="Emu\RSX\GL\OpenGL.h" />
     <ClInclude Include="Emu\RSX\GSManager.h" />
     <ClInclude Include="Emu\RSX\GSRender.h" />
@@ -834,8 +837,7 @@
       <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
       <ExceptionHandling>Async</ExceptionHandling>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
-      </AdditionalIncludeDirectories>
       <IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
     </ClCompile>
     <Link>
@@ -852,8 +854,7 @@
       <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
       <ExceptionHandling>Async</ExceptionHandling>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
-      </AdditionalIncludeDirectories>
       <IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
     </ClCompile>
     <Link>
@@ -870,8 +871,7 @@
       <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
       <ExceptionHandling>Async</ExceptionHandling>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
-      </AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -891,8 +891,7 @@
       <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
       <ExceptionHandling>Async</ExceptionHandling>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
-      </AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -912,8 +911,7 @@
       <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
       <ExceptionHandling>Async</ExceptionHandling>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
-      </AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -930,8 +928,7 @@
       <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
       <ExceptionHandling>Async</ExceptionHandling>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
-      </AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
@@ -951,8 +948,7 @@
       <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
       <ExceptionHandling>Async</ExceptionHandling>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
-      </AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_UNICODE;UNICODE;DX12_SUPPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <OpenMPSupport>false</OpenMPSupport>
     </ClCompile>
@@ -974,8 +970,7 @@
       <ExceptionHandling>Async</ExceptionHandling>
       <PreprocessorDefinitions>LLVM_AVAILABLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
-      </AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -999,8 +994,7 @@
       <ExceptionHandling>Async</ExceptionHandling>
       <PreprocessorDefinitions>LLVM_AVAILABLE;DX12_SUPPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
-      </AdditionalIncludeDirectories>
       <OpenMPSupport>false</OpenMPSupport>
     </ClCompile>
     <Link>

rpcs3/emucore.vcxproj.filters

@@ -995,6 +995,12 @@
     <ClCompile Include="Emu\RSX\Common\BufferUtils.cpp">
       <Filter>Emu\GPU\RSX\Common</Filter>
     </ClCompile>
+    <ClCompile Include="Emu\RSX\Null\NullGSRender.cpp">
+      <Filter>Emu\GPU\RSX\Null</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\RSX\GL\gl_helpers.cpp">
+      <Filter>Emu\GPU\RSX\GL</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Crypto\aes.h">
@@ -1897,5 +1903,8 @@
     <ClInclude Include="..\Utilities\types.h">
       <Filter>Utilities</Filter>
     </ClInclude>
+    <ClInclude Include="Emu\RSX\GL\gl_helpers.h">
+      <Filter>Emu\GPU\RSX\GL</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

rpcs3/rpcs3.vcxproj

@@ -206,7 +206,7 @@
       <Optimization>Disabled</Optimization>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <PrecompiledHeader>Use</PrecompiledHeader>
-      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc;..\glm</AdditionalIncludeDirectories>
       <ExceptionHandling>Async</ExceptionHandling>
       <PrecompiledHeaderFile>stdafx_gui.h</PrecompiledHeaderFile>
       <PrecompiledHeaderOutputFile>$(IntDir)$(TargetName)_gui.pch</PrecompiledHeaderOutputFile>
@@ -236,7 +236,7 @@
       <Optimization>Disabled</Optimization>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <PrecompiledHeader>Use</PrecompiledHeader>
-      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc;..\glm</AdditionalIncludeDirectories>
       <ExceptionHandling>Async</ExceptionHandling>
       <PrecompiledHeaderFile>stdafx_gui.h</PrecompiledHeaderFile>
       <PrecompiledHeaderOutputFile>$(IntDir)$(TargetName)_gui.pch</PrecompiledHeaderOutputFile>
@@ -266,7 +266,7 @@
       <Optimization>Disabled</Optimization>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <PrecompiledHeader>Use</PrecompiledHeader>
-      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc;..\glm</AdditionalIncludeDirectories>
       <ExceptionHandling>Async</ExceptionHandling>
       <PrecompiledHeaderFile>stdafx_gui.h</PrecompiledHeaderFile>
       <PrecompiledHeaderOutputFile>$(IntDir)$(TargetName)_gui.pch</PrecompiledHeaderOutputFile>
@@ -296,7 +296,7 @@
       <Optimization>Disabled</Optimization>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <PrecompiledHeader>Use</PrecompiledHeader>
-      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc;..\glm</AdditionalIncludeDirectories>
       <ExceptionHandling>Async</ExceptionHandling>
       <PrecompiledHeaderFile>stdafx_gui.h</PrecompiledHeaderFile>
       <PrecompiledHeaderOutputFile>$(IntDir)$(TargetName)_gui.pch</PrecompiledHeaderOutputFile>
@@ -326,7 +326,7 @@
       <Optimization>Disabled</Optimization>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <PrecompiledHeader>Use</PrecompiledHeader>
-      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc;..\glm</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_UNICODE;UNICODE;MSVC_CRT_MEMLEAK_DETECTION;%(PreprocessorDefinitions);DX12_SUPPORT</PreprocessorDefinitions>
       <ExceptionHandling>Async</ExceptionHandling>
       <PrecompiledHeaderFile>stdafx_gui.h</PrecompiledHeaderFile>
@@ -356,7 +356,7 @@
       <Optimization>Full</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc;..\glm</AdditionalIncludeDirectories>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableLanguageExtensions>false</DisableLanguageExtensions>
@@ -394,7 +394,7 @@
       <Optimization>Full</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc;..\glm</AdditionalIncludeDirectories>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;LLVM_AVAILABLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableLanguageExtensions>false</DisableLanguageExtensions>
@@ -432,7 +432,7 @@
       <Optimization>Full</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc;..\glm</AdditionalIncludeDirectories>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;DX12_SUPPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableLanguageExtensions>false</DisableLanguageExtensions>
@@ -471,7 +471,7 @@
       <Optimization>Full</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc;..\glm</AdditionalIncludeDirectories>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;LLVM_AVAILABLE;DX12_SUPPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableLanguageExtensions>false</DisableLanguageExtensions>