archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-05 06:21:26 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Use files from master

Browse source 
- Drop smart vertex storage and use OpenGL's one instead.
This commit is contained in:
Vincent Lejeune 2015-10-11 22:00:51 +02:00
parent 4154a1026f
commit a63fdf6c45
43 changed files with 6485 additions and 5229 deletions
Download patch file Download diff file Expand all files Collapse all files

4
rpcs3/Emu/RSX/Common/BufferUtils.cpp
View file

@ -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)

12
rpcs3/Emu/RSX/Common/VertexProgramDecompiler.cpp
View file

@ -136,13 +136,13 @@ void VertexProgramDecompiler::SetDST(bool is_sca, std::string value)
std::string mask = GetMask(is_sca);
value += mask;
if (is_sca && d0.vec_result)
if (is_sca)
{
//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;

97
rpcs3/Emu/RSX/D3D12/D3D12Buffer.cpp
View file

@ -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)
{
u32 addrRegVal = rsx::method_registers[NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 4 * attributeId];
u32 addr = rsx::get_address(addrRegVal & 0x7fffffff, addrRegVal >> 31);
const rsx::data_array_format_info &vertexData = m_vertex_data[attributeId];
const auto &info = vertex_info[index];
if (!info.size)
continue;
D3D12_INPUT_ELEMENT_DESC IAElement = {};
IAElement.SemanticName = "TEXCOORD";
IAElement.SemanticIndex = (UINT)attributeId;
IAElement.InputSlot = (UINT)inputSlot;
IAElement.Format = getFormat(vertexData.type - 1, vertexData.size);
IAElement.AlignedByteOffset = (UINT)(addr + baseOffset - vertexBufferFormat[inputSlot].range.first);
IAElement.InputSlotClass = (addr > 0) ? D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA : D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
IAElement.InstanceDataStepRate = (addr > 0) ? 0 : 1;
IAElement.SemanticIndex = (UINT)index;
IAElement.InputSlot = (UINT)inputSlot++;
IAElement.Format = getFormat(info.type - 1, info.size);
IAElement.AlignedByteOffset = 0;
IAElement.InputSlotClass = info.array ? D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA : D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
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;
// Make multiple of stride
if (vbf.stride)
subBufferSize = ((subBufferSize + vbf.stride - 1) / vbf.stride) * vbf.stride;
size_t subBufferSize = vertex_data.size();
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(m_device.Get(), vertexBufferFormat, vertex_arrays_info, m_vertex_data_base_offset);
m_IASet = getIALayout(vertex_arrays_info, vertex_arrays);
const u32 data_offset = indexed_draw ? 0 : draw_array_first;
for (size_t buffer = 0; buffer < vertexBufferFormat.size(); buffer++)
for (int index = 0; index < rsx::limits::vertex_count; ++index)
{
const VertexBufferFormat &vbf = vertexBufferFormat[buffer];
// 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;
const auto &info = vertex_arrays_info[index];
D3D12_GPU_VIRTUAL_ADDRESS virtualAddress = createVertexBuffer(vbf, vertex_arrays_info, vertex_arrays, m_vertex_data_base_offset, m_device.Get(), m_vertexIndexData);
m_timers.m_bufferUploadSize += subBufferSize;
if (!info.size)
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.StrideInBytes = (UINT)vbf.stride;
vertexBufferView.SizeInBytes = (UINT)vertex_arrays[index].size();
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_baseVertex = draw_array_first;
m_renderingInfo.m_count = vertex_draw_count;
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[5] *= (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE + (0x4 * 1)] / (clip_h / 2.f);
scaleOffsetMat[10] = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE + (0x4 * 2)];
scaleOffsetMat[0] *= (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE] / (clip_w / 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 + 2];
// Offset
scaleOffsetMat[3] = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET + (0x4 * 0)] - (clip_w / 2.f);
scaleOffsetMat[7] = -((float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET + (0x4 * 1)] - (clip_h / 2.f));
scaleOffsetMat[11] = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET + (0x4 * 2)];
scaleOffsetMat[3] = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET] - (clip_w / 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 + 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);

42
rpcs3/Emu/RSX/D3D12/D3D12GSRender.cpp
View file

@ -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 (m_indexed_array.m_count)
if (!vertex_index_array.empty() || vertex_draw_count)
{
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] = (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);
const std::vector<D3D12_VERTEX_BUFFER_VIEW> &vertexBufferViews = UploadVertexBuffers(!vertex_index_array.empty());
const D3D12_INDEX_BUFFER_VIEW &indexBufferView = uploadIndexBuffers(!vertex_index_array.empty());
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

16
rpcs3/Emu/RSX/D3D12/D3D12GSRender.h
View file

@ -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;
size_t m_vertexBufferSize[32];
std::unordered_map<u32, color4f> local_transform_constants;
struct
{
@ -455,13 +456,9 @@ public:
D3D12GSRender();
virtual ~D3D12GSRender();
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;
virtual void semaphorePGRAPHTextureReadRelease(u32 offset, u32 value);
virtual void semaphorePGRAPHBackendRelease(u32 offset, u32 value);
virtual void semaphorePFIFOAcquire(u32 offset, u32 value);
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;

41
rpcs3/Emu/RSX/D3D12/D3D12PipelineState.cpp
View file

@ -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;
}

2374
rpcs3/Emu/RSX/GCM.h
View file

File diff suppressed because it is too large Load diff

4
rpcs3/Emu/RSX/GL/GLFragmentProgram.cpp
View file

@ -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()

2372
rpcs3/Emu/RSX/GL/GLGSRender.cpp
View file

File diff suppressed because it is too large Load diff

174
rpcs3/Emu/RSX/GL/GLGSRender.h
View file

@ -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 Convert4To8(u8 v)
inline static u8 convert_4_to_8(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);
void Save(rsx::texture& tex);
void Bind();
void Unbind();
void Delete();
u32 id() const;
};
class PostDrawObj
{
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
class GLGSRender : 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;
GLvbo m_vbo;
GLrbo m_rbo;
GLfbo m_fbo;
//TODO: program cache
gl::glsl::program m_program;
void* m_context;
rsx::surface_info m_surface;
public:
u32 m_draw_frames;
u32 m_skip_frames;
bool is_intel_vendor;
GLGSRender();
virtual ~GLGSRender() override;
gl::fbo draw_fbo;
gl::buffers clear_surface_buffers = gl::buffers::none;
private:
void EnableVertexData(bool indexed_draw = false);
void DisableVertexData();
void InitVertexData();
void InitFragmentData();
GLProgramBuffer m_prog_buffer;
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();
void WriteBuffers();
void WriteDepthBuffer();
void WriteColorBuffers();
void WriteColorBufferA();
void WriteColorBufferB();
void WriteColorBufferC();
void WriteColorBufferD();
//buffer
gl::fbo m_flip_fbo;
gl::texture m_flip_tex_color;
void DrawObjects();
void InitDrawBuffers();
public:
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;
virtual void oninit_thread() 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;
void begin() override;
void end() 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 {}
void oninit_thread() override;
void onexit_thread() override;
bool domethod(u32 id, u32 arg) override;
void flip(int buffer) override;
u64 timestamp() const override;
};

109
rpcs3/Emu/RSX/GL/GLProcTable.h
View file

@ -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

3
rpcs3/Emu/RSX/GL/GLProgram.cpp
View file

@ -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();
}
*/

4
rpcs3/Emu/RSX/GL/GLProgram.h
View file

@ -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();
};
*/

20
rpcs3/Emu/RSX/GL/GLProgramBuffer.h
View file

@ -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();
result->Create(vertexProgramData.id, fragmentProgramData.id);
//checkForGlError("m_program.Create");
result->Use();
PipelineData *result = new PipelineData();
__glcheck result->create()
.attach(gl::glsl::shader_view(vertexProgramData.id))
.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();
}
};

4
rpcs3/Emu/RSX/GL/GLVertexProgram.cpp
View file

@ -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;
}
}

2
rpcs3/Emu/RSX/GL/OpenGL.cpp
View file

@ -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)

5
rpcs3/Emu/RSX/GL/OpenGL.h
View file

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

470
rpcs3/Emu/RSX/GL/gl_helpers.cpp Normal file
View file

@ -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);
}
}

2223
rpcs3/Emu/RSX/GL/gl_helpers.h Normal file
View file

File diff suppressed because it is too large Load diff

40
rpcs3/Emu/RSX/GSRender.cpp
View file

@ -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)
{
}
}

25
rpcs3/Emu/RSX/GSRender.h
View file

@ -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);
};

16
rpcs3/Emu/RSX/Null/NullGSRender.cpp Normal file
View file

@ -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;
}

56
rpcs3/Emu/RSX/Null/NullGSRender.h
View file

@ -4,59 +4,9 @@
class NullGSRender final : public GSRender
{
public:
NullGSRender() : GSRender(frame_type::Null)
{
}
virtual ~NullGSRender() override
{
}
NullGSRender();
private:
virtual void oninit() 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 {}
void onexit_thread() override;
bool domethod(u32 cmd, u32 value) override;
};

8
rpcs3/Emu/RSX/RSXTexture.cpp
View file

@ -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);

3
rpcs3/Emu/RSX/RSXTexture.h
View file

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

2816
rpcs3/Emu/RSX/RSXThread.cpp
View file

File diff suppressed because it is too large Load diff

411
rpcs3/Emu/RSX/RSXThread.h
View file

@ -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;
RSXVertexProgram m_vertex_progs[limits::vertex_count];
RSXVertexProgram* m_cur_vertex_prog;
u32 transform_program[512 * 4] = {};
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;
};
}

31
rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
View file

@ -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;
}
}
*ctxt->current++ = 0x3fead | (1 << 18);
#ifdef __GNUC__
//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);
return Emu.GetGSManager().GetRender().m_gcm_buffers_addr;
cellGcmSys.Warning("cellGcmGetDisplayInfo() = 0x%x", Emu.GetGSManager().GetRender().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;
}

28
rpcs3/Emu/SysCalls/Modules/cellResc.cpp
View file

@ -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_point_sprite_control = false;
r.m_set_dither = true;
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_two_side_light_enable = false;
// r.m_set_point_sprite_control = false;
// r.m_set_dither = true;
// r.m_set_shade_mode = true; r.m_shade_mode = CELL_GCM_SMOOTH;
// 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_scissor_x = 0;
r.m_scissor_y = 0;
r.m_scissor_w = s_rescInternalInstance->m_dstWidth;
r.m_scissor_h = s_rescInternalInstance->m_dstHeight;
// r.m_set_scissor_horizontal = r.m_set_scissor_vertical = true;
// r.m_scissor_x = 0;
// r.m_scissor_y = 0;
// r.m_scissor_w = s_rescInternalInstance->m_dstWidth;
// r.m_scissor_h = s_rescInternalInstance->m_dstHeight;
r.m_width = s_rescInternalInstance->m_dstWidth;
r.m_height = s_rescInternalInstance->m_dstHeight;
// r.m_width = s_rescInternalInstance->m_dstWidth;
// r.m_height = s_rescInternalInstance->m_dstHeight;
// r.m_surface_depth_format = 2;
rsx::method_registers[NV4097_SET_SURFACE_COLOR_TARGET] = 1;

3
rpcs3/Emu/System.cpp
View file

@ -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");

6
rpcs3/Emu/System.h
View file

@ -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;
};

16
rpcs3/Gui/GLGSFrame.cpp
View file

@ -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();
}

12
rpcs3/Gui/GLGSFrame.h
View file

@ -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;
virtual void set_current(draw_context_t context) override;
virtual void delete_context(void* ctx) override;
virtual void flip(draw_context_t context) override;
void* make_context() override;
void set_current(draw_context_t context) override;
void delete_context(void* context) override;
void flip(draw_context_t context) override;
private:
virtual void OnSize(wxSizeEvent& event);

30
rpcs3/Gui/GSFrame.cpp
View file

@ -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();
}
}
}

5
rpcs3/Gui/GSFrame.h
View file

@ -1,10 +1,10 @@
#pragma once
#include "Emu/Memory/vm.h"
#pragma once
#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&)

10
rpcs3/Gui/MainFrame.cpp
View file

@ -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))

133
rpcs3/Gui/RSXDebugger.cpp
View file

@ -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("Blend", rsx::method_registers[NV4097_SET_BLEND_ENABLE]);
/*
LIST_FLAGS_ADD("Alpha test", render.m_set_alpha_test);
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)",
rsx::method_registers[NV4097_SET_ALPHA_FUNC],
ParseGCMEnum(rsx::method_registers[NV4097_SET_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",
rsx::method_registers[NV4097_SET_BLEND_COLOR] & 0xFF,
(rsx::method_registers[NV4097_SET_BLEND_COLOR] >> 8) & 0xFF,
(rsx::method_registers[NV4097_SET_BLEND_COLOR] >> 16) & 0xFF,
(rsx::method_registers[NV4097_SET_BLEND_COLOR] >> 24) & 0xFF));
/*
LIST_SETTINGS_ADD("Alpha func", !(render.m_set_alpha_func) ? "(none)" : wxString::Format("0x%x (%s)",
render.m_alpha_func,
ParseGCMEnum(render.m_alpha_func, CELL_GCM_ENUM)));
LIST_SETTINGS_ADD("Blend color", !(render.m_set_blend_color) ? "(none)" : wxString::Format("R:%d, G:%d, B:%d, A:%d",
render.m_blend_color_r,
render.m_blend_color_g,
render.m_blend_color_b,
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",
(rsx::method_registers[NV4097_SET_COLOR_MASK] >> 16) & 0xff,
(rsx::method_registers[NV4097_SET_COLOR_MASK] >> 8) & 0xff,
(rsx::method_registers[NV4097_SET_COLOR_MASK]) & 0xff,
(rsx::method_registers[NV4097_SET_COLOR_MASK] >> 24) & 0xff));
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 B", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_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 D", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_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("Color mask", !(render.m_set_color_mask) ? "(none)" : wxString::Format("R:%d, G:%d, B:%d, A:%d",
render.m_color_mask_r,
render.m_color_mask_g,
render.m_color_mask_b,
render.m_color_mask_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", render.m_context_dma_color_b));
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", render.m_context_dma_color_d));
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)",
// render.m_depth_func,
// ParseGCMEnum(render.m_depth_func, CELL_GCM_ENUM)));
LIST_SETTINGS_ADD("Depth func", !(render.m_set_depth_func) ? "(none)" : wxString::Format("0x%x (%s)",
render.m_depth_func,
ParseGCMEnum(render.m_depth_func, CELL_GCM_ENUM)));
LIST_SETTINGS_ADD("Draw mode", wxString::Format("%d (%s)",
render.draw_mode,
ParseGCMEnum(render.draw_mode, CELL_GCM_PRIMITIVE_ENUM)));
render.m_draw_mode,
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)",
// render.m_stencil_func,
// 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 B", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_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 D", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_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 Offset A", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_COLOR_AOFFSET]));
LIST_SETTINGS_ADD("Surface Offset B", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_COLOR_BOFFSET]));
LIST_SETTINGS_ADD("Surface Offset C", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_COLOR_COFFSET]));
LIST_SETTINGS_ADD("Surface Offset D", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_COLOR_DOFFSET]));
LIST_SETTINGS_ADD("Surface Offset Z", wxString::Format("0x%x", rsx::method_registers[NV4097_SET_SURFACE_ZETA_OFFSET]));
LIST_SETTINGS_ADD("Stencil func", !(render.m_set_stencil_func) ? "(none)" : wxString::Format("0x%x (%s)",
render.m_stencil_func,
ParseGCMEnum(render.m_stencil_func, CELL_GCM_ENUM)));
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", render.m_surface_pitch_b));
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", render.m_surface_pitch_d));
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", render.m_surface_offset_a));
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", render.m_surface_offset_c));
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", 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,
rsx::method_registers[NV4097_SET_SURFACE_CLIP_VERTICAL] & 0xFFFF,
rsx::method_registers[NV4097_SET_SURFACE_CLIP_HORIZONTAL] >> 16,
rsx::method_registers[NV4097_SET_SURFACE_CLIP_VERTICAL] >> 16));
render.m_viewport_x,
render.m_viewport_y,
render.m_viewport_w,
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 1: rsx::method_registers[NV4097_SET_BLEND_ENABLE] ^= true; break;
case 2: rsx::method_registers[NV4097_SET_CULL_FACE] ^= true; break;
case 0: render.m_set_alpha_test ^= true; break;
case 1: render.m_set_blend ^= 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();
}
}

2
rpcs3/Gui/RSXDebugger.h
View file

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

12
rpcs3/Gui/SettingsDialog.cpp
View file

@ -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());

18
rpcs3/Ini.h
View file

@ -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);
AudioDumpToFile.Init("Audio_AudioDumpToFile", path);
AudioConvertToU16.Init("Audio_AudioConvertToU16", path);
AudioOutMode.Init("Audio_OutMode", path);
AudioDumpToFile.Init("Audio_DumpToFile", 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();

30
rpcs3/emucore.vcxproj
View file

@ -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>
<AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
<IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
</ClCompile>
<Link>
@ -852,8 +854,7 @@
<PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
<ExceptionHandling>Async</ExceptionHandling>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<AdditionalIncludeDirectories>
</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
<IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
</ClCompile>
<Link>
@ -870,8 +871,7 @@
<PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
<ExceptionHandling>Async</ExceptionHandling>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<AdditionalIncludeDirectories>
</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
@ -891,8 +891,7 @@
<PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
<ExceptionHandling>Async</ExceptionHandling>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<AdditionalIncludeDirectories>
</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
@ -912,8 +911,7 @@
<PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
<ExceptionHandling>Async</ExceptionHandling>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<AdditionalIncludeDirectories>
</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
@ -930,8 +928,7 @@
<PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
<ExceptionHandling>Async</ExceptionHandling>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<AdditionalIncludeDirectories>
</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
@ -951,8 +948,7 @@
<PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
<ExceptionHandling>Async</ExceptionHandling>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<AdditionalIncludeDirectories>
</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>../glm</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>
<AdditionalIncludeDirectories>../glm</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>
<AdditionalIncludeDirectories>../glm</AdditionalIncludeDirectories>
<OpenMPSupport>false</OpenMPSupport>
</ClCompile>
<Link>

9
rpcs3/emucore.vcxproj.filters
View file

@ -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>

18
rpcs3/rpcs3.vcxproj
View file

@ -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>