archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-15 11:18:36 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Revert "Merge pull request #1245 from DHrpcs3/master"

Browse source 
This reverts commit 5feba39ff7, reversing
changes made to ebf28f8da0.
This commit is contained in:
Vincent Lejeune 2015-10-09 20:04:20 +02:00
parent 5feba39ff7
commit f483c3b9ca
319 changed files with 7402 additions and 72277 deletions
Download patch file Download diff file Expand all files Collapse all files

1
rpcs3/CMakeLists.txt
View file

@ -107,7 +107,6 @@ ${LLVM_INCLUDE_DIRS}
"${RPCS3_SRC_DIR}/Crypto"
"${RPCS3_SRC_DIR}/.."
"${RPCS3_SRC_DIR}/../asmjit/src/asmjit"
"${RPCS3_SRC_DIR}/../glm"
)
if(WIN32)
include_directories(BEFORE "${RPCS3_SRC_DIR}/../minidx9/Include")

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

@ -1,5 +1,4 @@
#include "stdafx.h"
#ifdef DX12_SUPPORT
#include "BufferUtils.h"
@ -244,5 +243,4 @@ void uploadIndexData(unsigned m_draw_mode, unsigned index_type, void* indexBuffe
return;
}
}
}
#endif
}

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

@ -1,4 +1,3 @@
#ifdef DX12_SUPPORT
#pragma once
#include <vector>
#include "Emu/Memory/vm.h"
@ -38,5 +37,4 @@ size_t getIndexCount(unsigned m_draw_mode, unsigned initial_index_count);
/*
* Write index information to bufferMap
*/
void uploadIndexData(unsigned m_draw_mode, unsigned index_type, void* indexBuffer, void* bufferMap, unsigned element_count);
#endif
void uploadIndexData(unsigned m_draw_mode, unsigned index_type, void* indexBuffer, void* bufferMap, unsigned element_count);

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

@ -1,5 +1,4 @@
#include "stdafx.h"
#ifdef DX12_SUPPORT
#include "Emu/Memory/vm.h"
#include "TextureUtils.h"
#include "../RSXThread.h"
@ -542,5 +541,4 @@ std::vector<MipmapLevelInfo> uploadPlacedTexture(const RSXTexture &texture, size
return writeTexelsGeneric((char*)pixels, (char*)textureData, w, h, blockSizeInByte, texture.GetMipmap());
}
}
#endif
}

8
rpcs3/Emu/RSX/Common/TextureUtils.h
View file

@ -1,5 +1,4 @@
#pragma once
#ifdef DX12_SUPPORT
#include "../RSXTexture.h"
#include <vector>
@ -11,16 +10,17 @@ struct MipmapLevelInfo
size_t rowPitch;
};
unsigned LinearToSwizzleAddress(unsigned x, unsigned y, unsigned z, unsigned log2_width, unsigned log2_height, unsigned log2_depth);
/**
* Get size to store texture in a linear fashion.
* Storage is assumed to use a rowPitchAlignement boundary for every row of texture.
*/
size_t getPlacedTextureStorageSpace(const rsx::texture &texture, size_t rowPitchAlignement);
size_t getPlacedTextureStorageSpace(const RSXTexture &texture, size_t rowPitchAlignement);
/**
* Write texture data to textureData.
* Data are not packed, they are stored per rows using rowPitchAlignement.
* Similarly, offset for every mipmaplevel is aligned to rowPitchAlignement boundary.
*/
std::vector<MipmapLevelInfo> uploadPlacedTexture(const rsx::texture &texture, size_t rowPitchAlignement, void* textureData);
#endif
std::vector<MipmapLevelInfo> uploadPlacedTexture(const RSXTexture &texture, size_t rowPitchAlignement, void* textureData);

14
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);
if (is_sca)
{
value = getFloatTypeName(4) + "(" + value + ")";
}
value += mask;
if (is_sca && d0.vec_result)
{
//value = "vec4(" + value + ")";
}
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 + " = " + src + ";");
AddCode("if (" + cond + ".x) " + dst + " = " + getFloatTypeName(4) + "(" + src + ".xxxx).x;");
}
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;

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

@ -33,6 +33,13 @@ static void unloadD3D12FunctionPointers()
FreeLibrary(D3D11Module);
}
GetGSFrameCb2 GetGSFrame = nullptr;
void SetGetD3DGSFrameCallback(GetGSFrameCb2 value)
{
GetGSFrame = value;
}
void D3D12GSRender::ResourceStorage::Reset()
{
m_constantsBufferIndex = 0;
@ -129,7 +136,7 @@ D3D12DLLManagement::~D3D12DLLManagement()
}
D3D12GSRender::D3D12GSRender()
: GSRender(frame_type::DX12), m_D3D12Lib(), m_PSO(nullptr)
: GSRender(), m_D3D12Lib(), m_PSO(nullptr)
{
m_previous_address_a = 0;
m_previous_address_b = 0;
@ -167,14 +174,13 @@ D3D12GSRender::D3D12GSRender()
g_descriptorStrideRTV = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
g_descriptorStrideSamplers = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
DXGI_ADAPTER_DESC adaptaterDesc;
adaptater->GetDesc(&adaptaterDesc);
m_frame->title_message(adaptaterDesc.Description);
m_frame = GetGSFrame();
// Create swap chain and put them in a descriptor heap as rendertarget
DXGI_SWAP_CHAIN_DESC swapChain = {};
swapChain.BufferCount = 2;
swapChain.Windowed = true;
swapChain.OutputWindow = (HWND)m_frame->handle();
swapChain.OutputWindow = m_frame->getHandle();
swapChain.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChain.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChain.SampleDesc.Count = 1;
@ -291,20 +297,40 @@ D3D12GSRender::~D3D12GSRender()
ReleaseD2DStructures();
}
void D3D12GSRender::oninit_thread()
void D3D12GSRender::Close()
{
if (joinable())
{
join();
}
if (m_frame->IsShown())
{
m_frame->Hide();
}
}
void D3D12GSRender::OnInit()
{
m_frame->Show();
}
void D3D12GSRender::OnInitThread()
{
}
void D3D12GSRender::onexit_thread()
void D3D12GSRender::OnExitThread()
{
}
void D3D12GSRender::clear_surface(u32 arg)
void D3D12GSRender::OnReset()
{
if ((arg & 0xf3) == 0)
return;
}
void D3D12GSRender::Clear(u32 cmd)
{
std::chrono::time_point<std::chrono::system_clock> startDuration = std::chrono::system_clock::now();
assert(cmd == NV4097_CLEAR_SURFACE);
std::chrono::time_point<std::chrono::system_clock> rttDurationStart = std::chrono::system_clock::now();
PrepareRenderTargets(getCurrentResourceStorage().m_commandList.Get());
@ -312,77 +338,64 @@ void D3D12GSRender::clear_surface(u32 arg)
std::chrono::time_point<std::chrono::system_clock> rttDurationEnd = std::chrono::system_clock::now();
m_timers.m_rttDuration += std::chrono::duration_cast<std::chrono::microseconds>(rttDurationEnd - rttDurationStart).count();
u32 scissor_horizontal = rsx::method_registers[NV4097_SET_SCISSOR_HORIZONTAL];
u32 scissor_vertical = rsx::method_registers[NV4097_SET_SCISSOR_VERTICAL];
u16 scissor_x = scissor_horizontal;
u16 scissor_w = scissor_horizontal >> 16;
u16 scissor_y = scissor_vertical;
u16 scissor_h = scissor_vertical >> 16;
/* if (m_set_color_mask)
{
glColorMask(m_color_mask_r, m_color_mask_g, m_color_mask_b, m_color_mask_a);
checkForGlError("glColorMask");
}
D3D12_RECT scissor;
scissor.left = scissor_x;
scissor.top = scissor_y;
scissor.right = scissor_x + scissor_w;
scissor.bottom = scissor_y + scissor_h;
if (m_set_scissor_horizontal && m_set_scissor_vertical)
{
glScissor(m_scissor_x, m_scissor_y, m_scissor_w, m_scissor_h);
checkForGlError("glScissor");
}*/
// TODO: Merge depth and stencil clear when possible
if (arg & 0x1)
if (m_clear_surface_mask & 0x1)
{
u32 surface_depth_format = (rsx::method_registers[NV4097_SET_SURFACE_FORMAT] >> 5) & 0x7;
u32 max_depth_value = surface_depth_format == CELL_GCM_SURFACE_Z16 ? 0x0000ffff : 0x00ffffff;
u32 clear_depth = rsx::method_registers[NV4097_SET_ZSTENCIL_CLEAR_VALUE] >> 8;
getCurrentResourceStorage().m_commandList->ClearDepthStencilView(m_rtts.m_depthStencilDescriptorHeap->GetCPUDescriptorHandleForHeapStart(), D3D12_CLEAR_FLAG_DEPTH, clear_depth / (float)max_depth_value, 0, 0, &scissor);
u32 max_depth_value = m_surface_depth_format == CELL_GCM_SURFACE_Z16 ? 0x0000ffff : 0x00ffffff;
getCurrentResourceStorage().m_commandList->ClearDepthStencilView(m_rtts.m_depthStencilDescriptorHeap->GetCPUDescriptorHandleForHeapStart(), D3D12_CLEAR_FLAG_DEPTH, m_clear_surface_z / (float)max_depth_value, 0, 0, nullptr);
}
if (arg & 0x2)
{
u8 clear_stencil = rsx::method_registers[NV4097_SET_ZSTENCIL_CLEAR_VALUE] & 0xff;
getCurrentResourceStorage().m_commandList->ClearDepthStencilView(m_rtts.m_depthStencilDescriptorHeap->GetCPUDescriptorHandleForHeapStart(), D3D12_CLEAR_FLAG_STENCIL, 0.f, clear_stencil, 0, &scissor);
}
if (m_clear_surface_mask & 0x2)
getCurrentResourceStorage().m_commandList->ClearDepthStencilView(m_rtts.m_depthStencilDescriptorHeap->GetCPUDescriptorHandleForHeapStart(), D3D12_CLEAR_FLAG_STENCIL, 0.f, m_clear_surface_s, 0, nullptr);
if (arg & 0xF0)
if (m_clear_surface_mask & 0xF0)
{
u32 clear_color = rsx::method_registers[NV4097_SET_COLOR_CLEAR_VALUE];
u8 clear_a = clear_color >> 24;
u8 clear_r = clear_color >> 16;
u8 clear_g = clear_color >> 8;
u8 clear_b = clear_color;
float clearColor[] =
{
clear_r / 255.0f,
clear_g / 255.0f,
clear_b / 255.0f,
clear_a / 255.0f
m_clear_surface_color_r / 255.0f,
m_clear_surface_color_g / 255.0f,
m_clear_surface_color_b / 255.0f,
m_clear_surface_color_a / 255.0f
};
size_t g_RTTIncrement = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
switch (u32 color_target = rsx::method_registers[NV4097_SET_SURFACE_COLOR_TARGET])
switch (m_surface_color_target)
{
case CELL_GCM_SURFACE_TARGET_NONE: break;
case CELL_GCM_SURFACE_TARGET_NONE: break;
case CELL_GCM_SURFACE_TARGET_0:
case CELL_GCM_SURFACE_TARGET_1:
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()), clearColor, 0, &scissor);
break;
case CELL_GCM_SURFACE_TARGET_MRT1:
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()), clearColor, 0, &scissor);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(1, g_descriptorStrideRTV), clearColor, 0, &scissor);
break;
case CELL_GCM_SURFACE_TARGET_MRT2:
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()), clearColor, 0, &scissor);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(1, g_descriptorStrideRTV), clearColor, 0, &scissor);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(2, g_descriptorStrideRTV), clearColor, 0, &scissor);
break;
case CELL_GCM_SURFACE_TARGET_MRT3:
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()), clearColor, 0, &scissor);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(1, g_descriptorStrideRTV), clearColor, 0, &scissor);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(2, g_descriptorStrideRTV), clearColor, 0, &scissor);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(3, g_descriptorStrideRTV), clearColor, 0, &scissor);
break;
default:
LOG_ERROR(RSX, "Bad surface color target: %d", color_target);
case CELL_GCM_SURFACE_TARGET_0:
case CELL_GCM_SURFACE_TARGET_1:
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()), clearColor, 0, nullptr);
break;
case CELL_GCM_SURFACE_TARGET_MRT1:
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()), clearColor, 0, nullptr);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(1, g_descriptorStrideRTV), clearColor, 0, nullptr);
break;
case CELL_GCM_SURFACE_TARGET_MRT2:
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()), clearColor, 0, nullptr);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(1, g_descriptorStrideRTV), clearColor, 0, nullptr);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(2, g_descriptorStrideRTV), clearColor, 0, nullptr);
break;
case CELL_GCM_SURFACE_TARGET_MRT3:
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()), clearColor, 0, nullptr);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(1, g_descriptorStrideRTV), clearColor, 0, nullptr);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(2, g_descriptorStrideRTV), clearColor, 0, nullptr);
getCurrentResourceStorage().m_commandList->ClearRenderTargetView(CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart()).Offset(3, g_descriptorStrideRTV), clearColor, 0, nullptr);
break;
default:
LOG_ERROR(RSX, "Bad surface color target: %d", m_surface_color_target);
}
}
@ -398,24 +411,7 @@ void D3D12GSRender::clear_surface(u32 arg)
}
}
bool D3D12GSRender::domethod(u32 id, u32 arg)
{
switch (id)
{
case NV4097_CLEAR_SURFACE:
clear_surface(arg);
return true;
default:
return false;
}
}
void D3D12GSRender::begin()
{
}
void D3D12GSRender::end()
void D3D12GSRender::Draw()
{
std::chrono::time_point<std::chrono::system_clock> startDuration = std::chrono::system_clock::now();
@ -428,10 +424,9 @@ void D3D12GSRender::end()
std::chrono::time_point<std::chrono::system_clock> vertexIndexDurationStart = std::chrono::system_clock::now();
// Init vertex count
if (!vertex_index_array.empty())
if (m_indexed_array.m_count)
{
/*
for (u32 i = 0; i < rsx::limits::vertex_count; ++i)
for (u32 i = 0; i < m_vertex_count; ++i)
{
if (!m_vertex_data[i].IsEnabled()) continue;
if (!m_vertex_data[i].addr) continue;
@ -439,25 +434,24 @@ void D3D12GSRender::end()
const u32 tsize = m_vertex_data[i].GetTypeSize();
m_vertexBufferSize[i] = (m_indexed_array.index_min + m_indexed_array.index_max - m_indexed_array.index_min + 1) * tsize * m_vertex_data[i].size;
}
*/
}
else
{
for (u32 i = 0; i < rsx::limits::vertex_count; ++i)
for (u32 i = 0; i < m_vertex_count; ++i)
{
auto &info = vertex_arrays_info[i];
if (info.size == 0)
continue;
if (!m_vertex_data[i].IsEnabled()) continue;
if (!m_vertex_data[i].addr) continue;
m_vertexBufferSize[i] = (draw_array_first + draw_array_count) * rsx::get_vertex_type_size(info.type) * info.size;
const u32 tsize = m_vertex_data[i].GetTypeSize();
m_vertexBufferSize[i] = (m_draw_array_first + m_draw_array_count) * tsize * m_vertex_data[i].size;
}
}
if (draw_array_count)
if (m_indexed_array.m_count || m_draw_array_count)
{
const std::vector<D3D12_VERTEX_BUFFER_VIEW> &vertexBufferViews = UploadVertexBuffers(!vertex_index_array.empty());
const D3D12_INDEX_BUFFER_VIEW &indexBufferView = uploadIndexBuffers(!vertex_index_array.empty());
const std::vector<D3D12_VERTEX_BUFFER_VIEW> &vertexBufferViews = UploadVertexBuffers(m_indexed_array.m_count ? true : false);
const D3D12_INDEX_BUFFER_VIEW &indexBufferView = uploadIndexBuffers(m_indexed_array.m_count ? true : false);
getCurrentResourceStorage().m_commandList->IASetVertexBuffers(0, (UINT)vertexBufferViews.size(), vertexBufferViews.data());
if (m_renderingInfo.m_indexed)
getCurrentResourceStorage().m_commandList->IASetIndexBuffer(&indexBufferView);
@ -477,7 +471,7 @@ void D3D12GSRender::end()
m_timers.m_programLoadDuration += std::chrono::duration_cast<std::chrono::microseconds>(programLoadEnd - programLoadStart).count();
getCurrentResourceStorage().m_commandList->SetGraphicsRootSignature(m_rootSignatures[m_PSO->second].Get());
getCurrentResourceStorage().m_commandList->OMSetStencilRef(rsx::method_registers[NV4097_SET_STENCIL_FUNC_REF]);
getCurrentResourceStorage().m_commandList->OMSetStencilRef(m_stencil_func_ref);
std::chrono::time_point<std::chrono::system_clock> constantsDurationStart = std::chrono::system_clock::now();
@ -559,7 +553,7 @@ void D3D12GSRender::end()
m_timers.m_textureDuration += std::chrono::duration_cast<std::chrono::microseconds>(textureDurationEnd - textureDurationStart).count();
size_t numRTT;
switch (u32 color_target = rsx::method_registers[NV4097_SET_SURFACE_COLOR_TARGET])
switch (m_surface_color_target)
{
case CELL_GCM_SURFACE_TARGET_NONE: break;
case CELL_GCM_SURFACE_TARGET_0:
@ -576,24 +570,18 @@ void D3D12GSRender::end()
numRTT = 4;
break;
default:
LOG_ERROR(RSX, "Bad surface color target: %d", color_target);
LOG_ERROR(RSX, "Bad surface color target: %d", m_surface_color_target);
}
getCurrentResourceStorage().m_commandList->OMSetRenderTargets((UINT)numRTT, &m_rtts.m_renderTargetsDescriptorsHeap->GetCPUDescriptorHandleForHeapStart(), true,
&CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtts.m_depthStencilDescriptorHeap->GetCPUDescriptorHandleForHeapStart()));
u32 clip_horizontal = rsx::method_registers[NV4097_SET_SURFACE_CLIP_HORIZONTAL];
u32 clip_vertical = rsx::method_registers[NV4097_SET_SURFACE_CLIP_VERTICAL];
u32 clip_width = clip_horizontal >> 16;
u32 clip_height = clip_vertical >> 16;
D3D12_VIEWPORT viewport =
{
0.f,
0.f,
(float)clip_width,
(float)clip_height,
(float)m_surface_clip_w,
(float)m_surface_clip_h,
-1.f,
1.f
};
@ -603,12 +591,12 @@ void D3D12GSRender::end()
{
0,
0,
(LONG)clip_width,
(LONG)clip_height,
(LONG)m_surface_clip_w,
(LONG)m_surface_clip_h,
};
getCurrentResourceStorage().m_commandList->RSSetScissorRects(1, &box);
switch (draw_mode - 1)
switch (m_draw_mode - 1)
{
case GL_POINTS:
getCurrentResourceStorage().m_commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_POINTLIST);
@ -645,6 +633,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();
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++;
@ -674,12 +663,12 @@ isFlipSurfaceInLocalMemory(u32 surfaceColorTarget)
}
}
void D3D12GSRender::flip(int buffer)
void D3D12GSRender::Flip()
{
ID3D12Resource *resourceToFlip;
float viewport_w, viewport_h;
if (!isFlipSurfaceInLocalMemory(rsx::method_registers[NV4097_SET_SURFACE_COLOR_TARGET]))
if (!isFlipSurfaceInLocalMemory(m_surface_color_target))
{
ResourceStorage &storage = getCurrentResourceStorage();
assert(storage.m_RAMFramebuffer == nullptr);
@ -687,11 +676,12 @@ void D3D12GSRender::flip(int buffer)
size_t w = 0, h = 0, rowPitch = 0;
size_t offset = 0;
if (false/*m_read_buffer*/)
if (m_read_buffer)
{
u32 addr = rsx::get_address(gcm_buffers[gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL);
w = gcm_buffers[gcm_current_buffer].width;
h = gcm_buffers[gcm_current_buffer].height;
CellGcmDisplayInfo* buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr);
u32 addr = GetAddress(buffers[m_gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL);
w = buffers[m_gcm_current_buffer].width;
h = buffers[m_gcm_current_buffer].height;
u8 *src_buffer = vm::get_ptr<u8>(addr);
rowPitch = align(w * 4, 256);
@ -761,7 +751,7 @@ void D3D12GSRender::flip(int buffer)
srvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MipLevels = 1;
if (isFlipSurfaceInLocalMemory(rsx::method_registers[NV4097_SET_SURFACE_COLOR_TARGET]))
if (isFlipSurfaceInLocalMemory(m_surface_color_target))
srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
else
srvDesc.Shader4ComponentMapping = D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(
@ -802,7 +792,7 @@ void D3D12GSRender::flip(int buffer)
if (!Ini.GSOverlay.GetValue())
getCurrentResourceStorage().m_commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_backBuffer[m_swapChain->GetCurrentBackBufferIndex()].Get(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT));
if (isFlipSurfaceInLocalMemory(rsx::method_registers[NV4097_SET_SURFACE_COLOR_TARGET]) && m_rtts.m_currentlyBoundRenderTargets[0] != nullptr)
if (isFlipSurfaceInLocalMemory(m_surface_color_target) && m_rtts.m_currentlyBoundRenderTargets[0] != nullptr)
getCurrentResourceStorage().m_commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_rtts.m_currentlyBoundRenderTargets[0], D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_RENDER_TARGET));
ThrowIfFailed(getCurrentResourceStorage().m_commandList->Close());
m_commandQueueGraphic->ExecuteCommandLists(1, (ID3D12CommandList**)getCurrentResourceStorage().m_commandList.GetAddressOf());
@ -851,7 +841,8 @@ void D3D12GSRender::flip(int buffer)
m_UAVHeap.m_getPos = newStorage.m_getPosUAVHeap;
}
m_frame->flip(nullptr);
m_frame->Flip(nullptr);
std::chrono::time_point<std::chrono::system_clock> flipEnd = std::chrono::system_clock::now();
m_timers.m_flipDuration += std::chrono::duration_cast<std::chrono::microseconds>(flipEnd - flipStart).count();
@ -883,14 +874,10 @@ D3D12GSRender::ResourceStorage& D3D12GSRender::getNonCurrentResourceStorage()
ID3D12Resource * D3D12GSRender::writeColorBuffer(ID3D12Resource * RTT, ID3D12GraphicsCommandList * cmdlist)
{
ID3D12Resource *Result;
u32 clip_width = rsx::method_registers[NV4097_SET_SURFACE_CLIP_HORIZONTAL] >> 16;
u32 clip_height = rsx::method_registers[NV4097_SET_SURFACE_CLIP_VERTICAL] >> 16;
size_t w = clip_width, h = clip_height;
size_t w = m_surface_clip_w, h = m_surface_clip_h;
DXGI_FORMAT dxgiFormat;
size_t rowPitch;
switch (rsx::method_registers[NV4097_SET_SURFACE_FORMAT] & 0x1f)
switch (m_surface_color_format)
{
case CELL_GCM_SURFACE_A8R8G8B8:
dxgiFormat = DXGI_FORMAT_R8G8B8A8_UNORM;
@ -956,33 +943,17 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
HANDLE handle = CreateEvent(0, FALSE, FALSE, 0);
fence->SetEventOnCompletion(1, handle);
u32 clip_width = rsx::method_registers[NV4097_SET_SURFACE_CLIP_HORIZONTAL] >> 16;
u32 clip_height = rsx::method_registers[NV4097_SET_SURFACE_CLIP_VERTICAL] >> 16;
ComPtr<ID3D12Resource> writeDest, depthConverted;
ComPtr<ID3D12DescriptorHeap> descriptorHeap;
size_t depthRowPitch = clip_width;
size_t depthRowPitch = m_surface_clip_w;
depthRowPitch = (depthRowPitch + 255) & ~255;
u32 dma_color_a = rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_A];
u32 dma_color_b = rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_B];
u32 dma_color_c = rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_C];
u32 dma_color_d = rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_D];
u32 dma_z = rsx::method_registers[NV4097_SET_CONTEXT_DMA_ZETA];
bool needTransfer = (m_set_context_dma_z && Ini.GSDumpDepthBuffer.GetValue()) ||
((m_set_context_dma_color_a || m_set_context_dma_color_b || m_set_context_dma_color_c || m_set_context_dma_color_d) && Ini.GSDumpColorBuffers.GetValue());
u32 offset_color_a = rsx::method_registers[NV4097_SET_SURFACE_COLOR_AOFFSET];
u32 offset_color_b = rsx::method_registers[NV4097_SET_SURFACE_COLOR_BOFFSET];
u32 offset_color_c = rsx::method_registers[NV4097_SET_SURFACE_COLOR_COFFSET];
u32 offset_color_d = rsx::method_registers[NV4097_SET_SURFACE_COLOR_DOFFSET];
u32 offset_z = rsx::method_registers[NV4097_SET_SURFACE_ZETA_OFFSET];
bool needTransfer = (dma_z && Ini.GSDumpDepthBuffer.GetValue()) ||
((dma_color_a || dma_color_b || dma_color_c || dma_color_d) && Ini.GSDumpColorBuffers.GetValue());
if (dma_z && Ini.GSDumpDepthBuffer.GetValue())
if (m_set_context_dma_z && Ini.GSDumpDepthBuffer.GetValue())
{
size_t sizeInByte = clip_width * clip_height * 2;
size_t sizeInByte = m_surface_clip_w * m_surface_clip_h * 2;
assert(m_UAVHeap.canAlloc(sizeInByte));
size_t heapOffset = m_UAVHeap.alloc(sizeInByte);
@ -990,14 +961,14 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
m_device->CreatePlacedResource(
m_UAVHeap.m_heap,
heapOffset,
&CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_R8_UNORM, clip_width, clip_height, 1, 1, 1, 0, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS),
&CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_R8_UNORM, m_surface_clip_w, m_surface_clip_h, 1, 1, 1, 0, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS),
D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
nullptr,
IID_PPV_ARGS(depthConverted.GetAddressOf())
)
);
sizeInByte = depthRowPitch * clip_height;
sizeInByte = depthRowPitch * m_surface_clip_h;
assert(m_readbackResources.canAlloc(sizeInByte));
heapOffset = m_readbackResources.alloc(sizeInByte);
@ -1017,7 +988,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
m_device->CreateDescriptorHeap(&descriptorHeapDesc, IID_PPV_ARGS(descriptorHeap.GetAddressOf()))
);
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
switch (u32 depth_format = ((rsx::method_registers[NV4097_SET_SURFACE_FORMAT] >> 5) & 0x7))
switch (m_surface_depth_format)
{
case 0:
break;
@ -1028,7 +999,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
srvDesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
break;
default:
LOG_ERROR(RSX, "Bad depth format! (%d)", depth_format);
LOG_ERROR(RSX, "Bad depth format! (%d)", m_surface_depth_format);
assert(0);
}
srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
@ -1049,7 +1020,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
getCurrentResourceStorage().m_commandList->SetComputeRootSignature(m_convertRootSignature);
getCurrentResourceStorage().m_commandList->SetDescriptorHeaps(1, descriptorHeap.GetAddressOf());
getCurrentResourceStorage().m_commandList->SetComputeRootDescriptorTable(0, descriptorHeap->GetGPUDescriptorHandleForHeapStart());
getCurrentResourceStorage().m_commandList->Dispatch(clip_width / 8, clip_height / 8, 1);
getCurrentResourceStorage().m_commandList->Dispatch(m_surface_clip_w / 8, m_surface_clip_h / 8, 1);
D3D12_RESOURCE_BARRIER barriers[] =
{
@ -1058,50 +1029,52 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
};
getCurrentResourceStorage().m_commandList->ResourceBarrier(2, barriers);
getCurrentResourceStorage().m_commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(depthConverted.Get(), D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_SOURCE));
getCurrentResourceStorage().m_commandList->CopyTextureRegion(&CD3DX12_TEXTURE_COPY_LOCATION(writeDest.Get(), { 0, { DXGI_FORMAT_R8_UNORM, clip_width, clip_height, 1, (UINT)depthRowPitch } }), 0, 0, 0,
getCurrentResourceStorage().m_commandList->CopyTextureRegion(&CD3DX12_TEXTURE_COPY_LOCATION(writeDest.Get(), { 0, { DXGI_FORMAT_R8_UNORM, m_surface_clip_w, m_surface_clip_h, 1, (UINT)depthRowPitch } }), 0, 0, 0,
&CD3DX12_TEXTURE_COPY_LOCATION(depthConverted.Get(), 0), nullptr);
invalidateTexture(rsx::get_address(offset_z, dma_z - 0xfeed0000)); }
invalidateAddress(GetAddress(m_surface_offset_z, m_context_dma_z - 0xfeed0000));
}
ID3D12Resource *rtt0, *rtt1, *rtt2, *rtt3;
if (Ini.GSDumpColorBuffers.GetValue())
{
switch (u32 color_target = rsx::method_registers[NV4097_SET_SURFACE_COLOR_TARGET])
switch (m_surface_color_target)
{
case CELL_GCM_SURFACE_TARGET_NONE:
break;
case CELL_GCM_SURFACE_TARGET_0:
if (dma_color_a) rtt0 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[0], getCurrentResourceStorage().m_commandList.Get());
if (m_context_dma_color_a) rtt0 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[0], getCurrentResourceStorage().m_commandList.Get());
break;
case CELL_GCM_SURFACE_TARGET_1:
if (dma_color_b) rtt1 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[0], getCurrentResourceStorage().m_commandList.Get());
if (m_context_dma_color_b) rtt1 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[0], getCurrentResourceStorage().m_commandList.Get());
break;
case CELL_GCM_SURFACE_TARGET_MRT1:
if (dma_color_a) rtt0 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[0], getCurrentResourceStorage().m_commandList.Get());
if (dma_color_b) rtt1 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[1], getCurrentResourceStorage().m_commandList.Get());
if (m_context_dma_color_a) rtt0 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[0], getCurrentResourceStorage().m_commandList.Get());
if (m_context_dma_color_b) rtt1 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[1], getCurrentResourceStorage().m_commandList.Get());
break;
case CELL_GCM_SURFACE_TARGET_MRT2:
if (dma_color_a) rtt0 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[0], getCurrentResourceStorage().m_commandList.Get());
if (dma_color_b) rtt1 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[1], getCurrentResourceStorage().m_commandList.Get());
if (dma_color_c) rtt2 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[2], getCurrentResourceStorage().m_commandList.Get());
if (m_context_dma_color_a) rtt0 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[0], getCurrentResourceStorage().m_commandList.Get());
if (m_context_dma_color_b) rtt1 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[1], getCurrentResourceStorage().m_commandList.Get());
if (m_context_dma_color_c) rtt2 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[2], getCurrentResourceStorage().m_commandList.Get());
break;
case CELL_GCM_SURFACE_TARGET_MRT3:
if (dma_color_a) rtt0 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[0], getCurrentResourceStorage().m_commandList.Get());
if (dma_color_b) rtt1 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[1], getCurrentResourceStorage().m_commandList.Get());
if (dma_color_c) rtt2 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[2], getCurrentResourceStorage().m_commandList.Get());
if (dma_color_d) rtt3 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[3], getCurrentResourceStorage().m_commandList.Get());
if (m_context_dma_color_a) rtt0 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[0], getCurrentResourceStorage().m_commandList.Get());
if (m_context_dma_color_b) rtt1 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[1], getCurrentResourceStorage().m_commandList.Get());
if (m_context_dma_color_c) rtt2 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[2], getCurrentResourceStorage().m_commandList.Get());
if (m_context_dma_color_d) rtt3 = writeColorBuffer(m_rtts.m_currentlyBoundRenderTargets[3], getCurrentResourceStorage().m_commandList.Get());
break;
}
if (dma_color_a) invalidateTexture(rsx::get_address(offset_color_a, dma_color_a - 0xfeed0000));
if (dma_color_b) invalidateTexture(rsx::get_address(offset_color_b, dma_color_b - 0xfeed0000));
if (dma_color_c) invalidateTexture(rsx::get_address(offset_color_c, dma_color_c - 0xfeed0000));
if (dma_color_d) invalidateTexture(rsx::get_address(offset_color_d, dma_color_d - 0xfeed0000));
}
if (m_context_dma_color_a) invalidateAddress(GetAddress(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000));
if (m_context_dma_color_b) invalidateAddress(GetAddress(m_surface_offset_b, m_context_dma_color_b - 0xfeed0000));
if (m_context_dma_color_c) invalidateAddress(GetAddress(m_surface_offset_c, m_context_dma_color_c - 0xfeed0000));
if (m_context_dma_color_d) invalidateAddress(GetAddress(m_surface_offset_d, m_context_dma_color_d - 0xfeed0000));
}
if (needTransfer)
{
ThrowIfFailed(getCurrentResourceStorage().m_commandList->Close());
@ -1114,103 +1087,103 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
WaitForSingleObject(handle, INFINITE);
CloseHandle(handle);
if (dma_z && Ini.GSDumpDepthBuffer.GetValue())
if (m_set_context_dma_z && Ini.GSDumpDepthBuffer.GetValue())
{
u32 address = rsx::get_address(offset_z, dma_z - 0xfeed0000);
u32 address = GetAddress(m_surface_offset_z, m_context_dma_z - 0xfeed0000);
auto ptr = vm::get_ptr<void>(address);
char *ptrAsChar = (char*)ptr;
unsigned char *writeDestPtr;
ThrowIfFailed(writeDest->Map(0, nullptr, (void**)&writeDestPtr));
for (unsigned row = 0; row < clip_height; row++)
for (unsigned row = 0; row < m_surface_clip_h; row++)
{
for (unsigned i = 0; i < clip_width; i++)
for (unsigned i = 0; i < m_surface_clip_w; i++)
{
unsigned char c = writeDestPtr[row * depthRowPitch + i];
ptrAsChar[4 * (row * clip_width + i)] = c;
ptrAsChar[4 * (row * clip_width + i) + 1] = c;
ptrAsChar[4 * (row * clip_width + i) + 2] = c;
ptrAsChar[4 * (row * clip_width + i) + 3] = c;
ptrAsChar[4 * (row * m_surface_clip_w + i)] = c;
ptrAsChar[4 * (row * m_surface_clip_w + i) + 1] = c;
ptrAsChar[4 * (row * m_surface_clip_w + i) + 2] = c;
ptrAsChar[4 * (row * m_surface_clip_w + i) + 3] = c;
}
}
}
size_t srcPitch, dstPitch;
switch (rsx::method_registers[NV4097_SET_SURFACE_FORMAT] & 0x1f)
switch (m_surface_color_format)
{
case CELL_GCM_SURFACE_A8R8G8B8:
srcPitch = align(clip_width * 4, 256);
dstPitch = clip_width * 4;
srcPitch = align(m_surface_clip_w * 4, 256);
dstPitch = m_surface_clip_w * 4;
break;
case CELL_GCM_SURFACE_F_W16Z16Y16X16:
srcPitch = align(clip_width * 8, 256);
dstPitch = clip_width * 8;
srcPitch = align(m_surface_clip_w * 8, 256);
dstPitch = m_surface_clip_w * 8;
break;
}
if (Ini.GSDumpColorBuffers.GetValue())
{
switch (u32 color_target = rsx::method_registers[NV4097_SET_SURFACE_COLOR_TARGET])
switch (m_surface_color_target)
{
case CELL_GCM_SURFACE_TARGET_NONE:
break;
case CELL_GCM_SURFACE_TARGET_0:
{
u32 address = rsx::get_address(offset_color_a, dma_color_a - 0xfeed0000);
u32 address = GetAddress(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000);
void *dstAddress = vm::get_ptr<void>(address);
copyToCellRamAndRelease(dstAddress, rtt0, srcPitch, dstPitch, clip_width, clip_height);
copyToCellRamAndRelease(dstAddress, rtt0, srcPitch, dstPitch, m_surface_clip_w, m_surface_clip_h);
}
break;
case CELL_GCM_SURFACE_TARGET_1:
{
u32 address = rsx::get_address(offset_color_b, dma_color_b - 0xfeed0000);
u32 address = GetAddress(m_surface_offset_b, m_context_dma_color_b - 0xfeed0000);
void *dstAddress = vm::get_ptr<void>(address);
copyToCellRamAndRelease(dstAddress, rtt1, srcPitch, dstPitch, clip_width, clip_height);
copyToCellRamAndRelease(dstAddress, rtt1, srcPitch, dstPitch, m_surface_clip_w, m_surface_clip_h);
}
break;
case CELL_GCM_SURFACE_TARGET_MRT1:
{
u32 address = rsx::get_address(offset_color_a, dma_color_a - 0xfeed0000);
u32 address = GetAddress(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000);
void *dstAddress = vm::get_ptr<void>(address);
copyToCellRamAndRelease(dstAddress, rtt0, srcPitch, dstPitch, clip_width, clip_height);
address = rsx::get_address(offset_color_b, dma_color_b - 0xfeed0000);
copyToCellRamAndRelease(dstAddress, rtt0, srcPitch, dstPitch, m_surface_clip_w, m_surface_clip_h);
address = GetAddress(m_surface_offset_b, m_context_dma_color_b - 0xfeed0000);
dstAddress = vm::get_ptr<void>(address);
copyToCellRamAndRelease(dstAddress, rtt1, srcPitch, dstPitch, clip_width, clip_height);
copyToCellRamAndRelease(dstAddress, rtt1, srcPitch, dstPitch, m_surface_clip_w, m_surface_clip_h);
}
break;
case CELL_GCM_SURFACE_TARGET_MRT2:
{
u32 address = rsx::get_address(offset_color_a, dma_color_a - 0xfeed0000);
u32 address = GetAddress(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000);
void *dstAddress = vm::get_ptr<void>(address);
copyToCellRamAndRelease(dstAddress, rtt0, srcPitch, dstPitch, clip_width, clip_height);
address = rsx::get_address(offset_color_b, dma_color_b - 0xfeed0000);
copyToCellRamAndRelease(dstAddress, rtt0, srcPitch, dstPitch, m_surface_clip_w, m_surface_clip_h);
address = GetAddress(m_surface_offset_b, m_context_dma_color_b - 0xfeed0000);
dstAddress = vm::get_ptr<void>(address);
copyToCellRamAndRelease(dstAddress, rtt1, srcPitch, dstPitch, clip_width, clip_height);
address = rsx::get_address(offset_color_c, dma_color_c - 0xfeed0000);
copyToCellRamAndRelease(dstAddress, rtt1, srcPitch, dstPitch, m_surface_clip_w, m_surface_clip_h);
address = GetAddress(m_surface_offset_c, m_context_dma_color_c - 0xfeed0000);
dstAddress = vm::get_ptr<void>(address);
copyToCellRamAndRelease(dstAddress, rtt2, srcPitch, dstPitch, clip_width, clip_height);
copyToCellRamAndRelease(dstAddress, rtt2, srcPitch, dstPitch, m_surface_clip_w, m_surface_clip_h);
}
break;
case CELL_GCM_SURFACE_TARGET_MRT3:
{
u32 address = rsx::get_address(offset_color_a, dma_color_a - 0xfeed0000);
u32 address = GetAddress(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000);
void *dstAddress = vm::get_ptr<void>(address);
copyToCellRamAndRelease(dstAddress, rtt0, srcPitch, dstPitch, clip_width, clip_height);
address = rsx::get_address(offset_color_b, dma_color_b - 0xfeed0000);
copyToCellRamAndRelease(dstAddress, rtt0, srcPitch, dstPitch, m_surface_clip_w, m_surface_clip_h);
address = GetAddress(m_surface_offset_b, m_context_dma_color_b - 0xfeed0000);
dstAddress = vm::get_ptr<void>(address);
copyToCellRamAndRelease(dstAddress, rtt1, srcPitch, dstPitch, clip_width, clip_height);
address = rsx::get_address(offset_color_c, dma_color_c - 0xfeed0000);
copyToCellRamAndRelease(dstAddress, rtt1, srcPitch, dstPitch, m_surface_clip_w, m_surface_clip_h);
address = GetAddress(m_surface_offset_c, m_context_dma_color_c - 0xfeed0000);
dstAddress = vm::get_ptr<void>(address);
copyToCellRamAndRelease(dstAddress, rtt2, srcPitch, dstPitch, clip_width, clip_height);
address = rsx::get_address(offset_color_d, dma_color_d - 0xfeed0000);
copyToCellRamAndRelease(dstAddress, rtt2, srcPitch, dstPitch, m_surface_clip_w, m_surface_clip_h);
address = GetAddress(m_surface_offset_d, m_context_dma_color_d - 0xfeed0000);
dstAddress = vm::get_ptr<void>(address);
copyToCellRamAndRelease(dstAddress, rtt3, srcPitch, dstPitch, clip_width, clip_height);
copyToCellRamAndRelease(dstAddress, rtt3, srcPitch, dstPitch, m_surface_clip_w, m_surface_clip_h);
}
break;
}
}
vm::ps3::write32(label_addr + offset, value);
vm::write32(m_label_addr + offset, value);
}
void D3D12GSRender::semaphorePFIFOAcquire(u32 offset, u32 value)
@ -1218,7 +1191,7 @@ void D3D12GSRender::semaphorePFIFOAcquire(u32 offset, u32 value)
const std::chrono::time_point<std::chrono::system_clock> enterWait = std::chrono::system_clock::now();
while (true)
{
volatile u32 val = vm::ps3::read32(label_addr + offset);
volatile u32 val = vm::read32(m_label_addr + offset);
if (val == value) break;
std::chrono::time_point<std::chrono::system_clock> waitPoint = std::chrono::system_clock::now();
long long elapsedTime = std::chrono::duration_cast<std::chrono::seconds>(waitPoint - enterWait).count();

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

@ -41,6 +41,28 @@
* are not currently correctly signaled which leads to deadlock.
*/
class GSFrameBase2
{
public:
GSFrameBase2() {}
GSFrameBase2(const GSFrameBase2&) = delete;
virtual void Close() = 0;
virtual bool IsShown() = 0;
virtual void Hide() = 0;
virtual void Show() = 0;
virtual void* GetNewContext() = 0;
virtual void SetCurrent(void* ctx) = 0;
virtual void DeleteContext(void* ctx) = 0;
virtual void Flip(void* ctx) = 0;
virtual HWND getHandle() const = 0;
};
typedef GSFrameBase2*(*GetGSFrameCb2)();
void SetGetD3DGSFrameCallback(GetGSFrameCb2 value);
template<typename T>
struct InitHeap
{
@ -448,26 +470,28 @@ private:
u32 m_previous_address_d;
u32 m_previous_address_z;
public:
GSFrameBase2 *m_frame;
u32 m_draw_frames;
u32 m_skip_frames;
std::unordered_map<size_t, color4f> m_vertexConstants;
std::unordered_map<size_t, RSXTransformConstant> m_vertexConstants;
D3D12GSRender();
virtual ~D3D12GSRender();
void semaphorePGRAPHTextureReadRelease(u32 offset, u32 value);
void semaphorePGRAPHBackendRelease(u32 offset, u32 value);
void semaphorePFIFOAcquire(u32 offset, u32 value);
void notifyProgramChange();
void notifyBlendStateChange();
void notifyDepthStencilStateChange();
void notifyRasterizerStateChange();
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;
private:
void InitD2DStructures();
void ReleaseD2DStructures();
ID3D12Resource *writeColorBuffer(ID3D12Resource *RTT, ID3D12GraphicsCommandList *cmdlist);
virtual void Close() override;
bool LoadProgram();
@ -509,19 +533,14 @@ private:
*/
void renderOverlay();
void clear_surface(u32 arg);
protected:
void begin() override;
void end() override;
void oninit_thread() override;
void onexit_thread() override;
bool domethod(u32 id, u32 arg) override;
void flip(int buffer) override;
//TODO
//u64 timestamp() const override;
virtual void OnInit() override;
virtual void OnInitThread() override;
virtual void OnExitThread() override;
virtual void OnReset() override;
virtual void Clear(u32 cmd) override;
virtual void Draw() override;
virtual void Flip() override;
};
#endif

10
rpcs3/Emu/RSX/D3D12/D3D12RenderTargetSets.cpp
View file

@ -29,11 +29,11 @@ void D3D12GSRender::PrepareRenderTargets(ID3D12GraphicsCommandList *copycmdlist)
m_previous_address_z = m_surface_offset_z;
// FBO location has changed, previous data might be copied
u32 address_a = m_set_context_dma_color_a ? rsx::get_address(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000) : 0;
u32 address_b = m_set_context_dma_color_b ? rsx::get_address(m_surface_offset_b, m_context_dma_color_b - 0xfeed0000) : 0;
u32 address_c = m_set_context_dma_color_c ? rsx::get_address(m_surface_offset_c, m_context_dma_color_c - 0xfeed0000) : 0;
u32 address_d = m_set_context_dma_color_d ? rsx::get_address(m_surface_offset_d, m_context_dma_color_d - 0xfeed0000) : 0;
u32 address_z = m_set_context_dma_z ? rsx::get_address(m_surface_offset_z, m_context_dma_z - 0xfeed0000) : 0;
u32 address_a = m_set_context_dma_color_a ? GetAddress(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000) : 0;
u32 address_b = m_set_context_dma_color_b ? GetAddress(m_surface_offset_b, m_context_dma_color_b - 0xfeed0000) : 0;
u32 address_c = m_set_context_dma_color_c ? GetAddress(m_surface_offset_c, m_context_dma_color_c - 0xfeed0000) : 0;
u32 address_d = m_set_context_dma_color_d ? GetAddress(m_surface_offset_d, m_context_dma_color_d - 0xfeed0000) : 0;
u32 address_z = m_set_context_dma_z ? GetAddress(m_surface_offset_z, m_context_dma_z - 0xfeed0000) : 0;
// Make previous RTTs sampleable
for (unsigned i = 0; i < 4; i++)

84
rpcs3/Emu/RSX/D3D12/D3D12Texture.cpp
View file

@ -104,19 +104,19 @@ D3D12_FILTER getSamplerFilter(u32 minFilter, u32 magFilter)
}
static
D3D12_SAMPLER_DESC getSamplerDesc(const rsx::texture &texture)
D3D12_SAMPLER_DESC getSamplerDesc(const RSXTexture &texture)
{
D3D12_SAMPLER_DESC samplerDesc = {};
samplerDesc.Filter = getSamplerFilter(texture.min_filter(), texture.mag_filter());
samplerDesc.AddressU = getSamplerWrap(texture.wrap_s());
samplerDesc.AddressV = getSamplerWrap(texture.wrap_t());
samplerDesc.AddressW = getSamplerWrap(texture.wrap_r());
samplerDesc.ComparisonFunc = getSamplerCompFunc[texture.zfunc()];
samplerDesc.MaxAnisotropy = (UINT)getSamplerMaxAniso(texture.max_aniso());
samplerDesc.MipLODBias = texture.bias();
samplerDesc.BorderColor[4] = (FLOAT)texture.border_color();
samplerDesc.MinLOD = (FLOAT)(texture.min_lod() >> 8);
samplerDesc.MaxLOD = (FLOAT)(texture.max_lod() >> 8);
samplerDesc.Filter = getSamplerFilter(texture.GetMinFilter(), texture.GetMagFilter());
samplerDesc.AddressU = getSamplerWrap(texture.GetWrapS());
samplerDesc.AddressV = getSamplerWrap(texture.GetWrapT());
samplerDesc.AddressW = getSamplerWrap(texture.GetWrapR());
samplerDesc.ComparisonFunc = getSamplerCompFunc[texture.GetZfunc()];
samplerDesc.MaxAnisotropy = (UINT)getSamplerMaxAniso(texture.GetMaxAniso());
samplerDesc.MipLODBias = texture.GetBias();
samplerDesc.BorderColor[4] = (FLOAT)texture.GetBorderColor();
samplerDesc.MinLOD = (FLOAT)(texture.GetMinLOD() >> 8);
samplerDesc.MaxLOD = (FLOAT)(texture.GetMaxLOD() >> 8);
return samplerDesc;
}
@ -127,15 +127,15 @@ D3D12_SAMPLER_DESC getSamplerDesc(const rsx::texture &texture)
*/
static
ComPtr<ID3D12Resource> uploadSingleTexture(
const rsx::texture &texture,
const RSXTexture &texture,
ID3D12Device *device,
ID3D12GraphicsCommandList *commandList,
DataHeap<ID3D12Resource, 65536> &textureBuffersHeap)
{
ComPtr<ID3D12Resource> vramTexture;
size_t w = texture.width(), h = texture.height();
size_t w = texture.GetWidth(), h = texture.GetHeight();
int format = texture.format() & ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN);
int format = texture.GetFormat() & ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN);
DXGI_FORMAT dxgiFormat = getTextureDXGIFormat(format);
size_t textureSize = getPlacedTextureStorageSpace(texture, 256);
@ -148,7 +148,7 @@ ComPtr<ID3D12Resource> uploadSingleTexture(
std::vector<MipmapLevelInfo> mipInfos = uploadPlacedTexture(texture, 256, textureData);
textureBuffersHeap.m_heap->Unmap(0, &CD3DX12_RANGE(heapOffset, heapOffset + textureSize));
D3D12_RESOURCE_DESC texturedesc = CD3DX12_RESOURCE_DESC::Tex2D(dxgiFormat, (UINT)w, (UINT)h, 1, texture.mipmap());
D3D12_RESOURCE_DESC texturedesc = CD3DX12_RESOURCE_DESC::Tex2D(dxgiFormat, (UINT)w, (UINT)h, 1, texture.GetMipmap());
textureSize = device->GetResourceAllocationInfo(0, 1, &texturedesc).SizeInBytes;
ThrowIfFailed(device->CreateCommittedResource(
@ -179,14 +179,14 @@ ComPtr<ID3D12Resource> uploadSingleTexture(
*/
static
void updateExistingTexture(
const rsx::texture &texture,
const RSXTexture &texture,
ID3D12GraphicsCommandList *commandList,
DataHeap<ID3D12Resource, 65536> &textureBuffersHeap,
ID3D12Resource *existingTexture)
{
size_t w = texture.width(), h = texture.height();
size_t w = texture.GetWidth(), h = texture.GetHeight();
int format = texture.format() & ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN);
int format = texture.GetFormat() & ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN);
DXGI_FORMAT dxgiFormat = getTextureDXGIFormat(format);
size_t textureSize = getPlacedTextureStorageSpace(texture, 256);
@ -216,11 +216,11 @@ void updateExistingTexture(
* Get number of bytes occupied by texture in RSX mem
*/
static
size_t getTextureSize(const rsx::texture &texture)
size_t getTextureSize(const RSXTexture &texture)
{
size_t w = texture.width(), h = texture.height();
size_t w = texture.GetWidth(), h = texture.GetHeight();
int format = texture.format() & ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN);
int format = texture.GetFormat() & ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN);
// TODO: Take mipmaps into account
switch (format)
{
@ -288,17 +288,17 @@ size_t D3D12GSRender::UploadTextures(ID3D12GraphicsCommandList *cmdlist)
{
size_t usedTexture = 0;
for (u32 i = 0; i < rsx::limits::textures_count; ++i)
for (u32 i = 0; i < m_textures_count; ++i)
{
if (!textures[i].enabled()) continue;
size_t w = textures[i].width(), h = textures[i].height();
if (!m_textures[i].IsEnabled()) continue;
size_t w = m_textures[i].GetWidth(), h = m_textures[i].GetHeight();
if (!w || !h) continue;
const u32 texaddr = rsx::get_address(textures[i].offset(), textures[i].location());
const u32 texaddr = GetAddress(m_textures[i].GetOffset(), m_textures[i].GetLocation());
int format = textures[i].format() & ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN);
int format = m_textures[i].GetFormat() & ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN);
DXGI_FORMAT dxgiFormat = getTextureDXGIFormat(format);
bool is_swizzled = !(textures[i].format() & CELL_GCM_TEXTURE_LN);
bool is_swizzled = !(m_textures[i].GetFormat() & CELL_GCM_TEXTURE_LN);
ID3D12Resource *vramTexture;
std::unordered_map<u32, ID3D12Resource* >::const_iterator ItRTT = m_rtts.m_renderTargets.find(texaddr);
@ -309,12 +309,12 @@ size_t D3D12GSRender::UploadTextures(ID3D12GraphicsCommandList *cmdlist)
vramTexture = ItRTT->second;
isRenderTarget = true;
}
else if (cachedTex != nullptr && (cachedTex->first == TextureEntry(format, w, h, textures[i].mipmap())))
else if (cachedTex != nullptr && (cachedTex->first == TextureEntry(format, w, h, m_textures[i].GetMipmap())))
{
if (cachedTex->first.m_isDirty)
{
updateExistingTexture(textures[i], cmdlist, m_textureUploadData, cachedTex->second.Get());
m_textureCache.protectData(texaddr, texaddr, getTextureSize(textures[i]));
updateExistingTexture(m_textures[i], cmdlist, m_textureUploadData, cachedTex->second.Get());
m_textureCache.protectData(texaddr, texaddr, getTextureSize(m_textures[i]));
}
vramTexture = cachedTex->second.Get();
}
@ -322,15 +322,15 @@ size_t D3D12GSRender::UploadTextures(ID3D12GraphicsCommandList *cmdlist)
{
if (cachedTex != nullptr)
getCurrentResourceStorage().m_dirtyTextures.push_back(m_textureCache.removeFromCache(texaddr));
ComPtr<ID3D12Resource> tex = uploadSingleTexture(textures[i], m_device.Get(), cmdlist, m_textureUploadData);
ComPtr<ID3D12Resource> tex = uploadSingleTexture(m_textures[i], m_device.Get(), cmdlist, m_textureUploadData);
vramTexture = tex.Get();
m_textureCache.storeAndProtectData(texaddr, texaddr, getTextureSize(textures[i]), format, w, h, textures[i].mipmap(), tex);
m_textureCache.storeAndProtectData(texaddr, texaddr, getTextureSize(m_textures[i]), format, w, h, m_textures[i].GetMipmap(), tex);
}
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
srvDesc.Format = dxgiFormat;
srvDesc.Texture2D.MipLevels = textures[i].mipmap();
srvDesc.Texture2D.MipLevels = m_textures[i].GetMipmap();
switch (format)
{
@ -357,10 +357,10 @@ size_t D3D12GSRender::UploadTextures(ID3D12GraphicsCommandList *cmdlist)
{
u8 remap_a = textures[i].remap() & 0x3;
u8 remap_r = (textures[i].remap() >> 2) & 0x3;
u8 remap_g = (textures[i].remap() >> 4) & 0x3;
u8 remap_b = (textures[i].remap() >> 6) & 0x3;
u8 remap_a = m_textures[i].GetRemap() & 0x3;
u8 remap_r = (m_textures[i].GetRemap() >> 2) & 0x3;
u8 remap_g = (m_textures[i].GetRemap() >> 4) & 0x3;
u8 remap_b = (m_textures[i].GetRemap() >> 6) & 0x3;
if (isRenderTarget)
{
// ARGB format
@ -428,10 +428,10 @@ size_t D3D12GSRender::UploadTextures(ID3D12GraphicsCommandList *cmdlist)
D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1
};
u8 remap_a = textures[i].remap() & 0x3;
u8 remap_r = (textures[i].remap() >> 2) & 0x3;
u8 remap_g = (textures[i].remap() >> 4) & 0x3;
u8 remap_b = (textures[i].remap() >> 6) & 0x3;
u8 remap_a = m_textures[i].GetRemap() & 0x3;
u8 remap_r = (m_textures[i].GetRemap() >> 2) & 0x3;
u8 remap_g = (m_textures[i].GetRemap() >> 4) & 0x3;
u8 remap_b = (m_textures[i].GetRemap() >> 6) & 0x3;
srvDesc.Shader4ComponentMapping = D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(
RemapValue[remap_a],
@ -459,7 +459,7 @@ size_t D3D12GSRender::UploadTextures(ID3D12GraphicsCommandList *cmdlist)
getCurrentResourceStorage().m_samplerDescriptorHeapIndex = 1;
getCurrentResourceStorage().m_currentSamplerIndex = 0;
}
m_device->CreateSampler(&getSamplerDesc(textures[i]),
m_device->CreateSampler(&getSamplerDesc(m_textures[i]),
CD3DX12_CPU_DESCRIPTOR_HANDLE(getCurrentResourceStorage().m_samplerDescriptorHeap[getCurrentResourceStorage().m_samplerDescriptorHeapIndex]->GetCPUDescriptorHandleForHeapStart())
.Offset((UINT)getCurrentResourceStorage().m_currentSamplerIndex + (UINT)usedTexture, g_descriptorStrideSamplers));

2436
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 140" << std::endl;
OS << "#version 420" << 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()

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

File diff suppressed because it is too large Load diff

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

@ -1,101 +1,202 @@
#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 = 0;
u32 m_id;
public:
void create();
GLTexture() : m_id(0)
{
}
int gl_wrap(int wrap);
void Create();
float max_aniso(int aniso);
int GetGlWrap(int wrap);
inline static u8 convert_4_to_8(u8 v)
float GetMaxAniso(int aniso);
inline static u8 Convert4To8(u8 v)
{
// Swizzle bits: 00001234 -> 12341234
return (v << 4) | (v);
}
inline static u8 convert_5_to_8(u8 v)
inline static u8 Convert5To8(u8 v)
{
// Swizzle bits: 00012345 -> 12345123
return (v << 3) | (v >> 2);
}
inline static u8 convert_6_to_8(u8 v)
inline static u8 Convert6To8(u8 v)
{
// Swizzle bits: 00123456 -> 12345612
return (v << 2) | (v >> 4);
}
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 Init(RSXTexture& tex);
u32 id() const;
void Save(RSXTexture& tex, const std::string& name);
void Save(RSXTexture& tex);
void Bind();
void Unbind();
void Delete();
};
class GLGSRender : public GSRender
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 GSFrameBase
{
public:
GSFrameBase() {}
GSFrameBase(const GSFrameBase&) = delete;
virtual void Close() = 0;
virtual bool IsShown() = 0;
virtual void Hide() = 0;
virtual void Show() = 0;
virtual void* GetNewContext() = 0;
virtual void SetCurrent(void* ctx) = 0;
virtual void DeleteContext(void* ctx) = 0;
virtual void Flip(void* ctx) = 0;
};
class GLGSRender final : public GSRender
{
private:
std::vector<u8> m_vdata;
std::vector<PostDrawObj> m_post_draw_objs;
GLProgram m_program;
int m_fp_buf_num;
int m_vp_buf_num;
GLProgramBuffer m_prog_buffer;
GLFragmentProgram m_fragment_prog;
GLVertexProgram m_vertex_prog;
GLTexture m_gl_textures[rsx::limits::textures_count];
GLTexture m_gl_vertex_textures[rsx::limits::vertex_textures_count];
GLTexture m_gl_textures[m_textures_count];
GLTexture m_gl_vertex_textures[m_textures_count];
//TODO: program cache
gl::glsl::program m_program;
GLvao m_vao;
GLvbo m_vbo;
GLrbo m_rbo;
GLfbo m_fbo;
rsx::surface_info m_surface;
public:
gl::fbo draw_fbo;
gl::buffers clear_surface_buffers = gl::buffers::none;
private:
GLProgramBuffer m_prog_buffer;
gl::texture m_draw_tex_color[rsx::limits::color_buffers_count];
gl::texture m_draw_tex_depth_stencil;
//buffer
gl::fbo m_flip_fbo;
gl::texture m_flip_tex_color;
void* m_context;
public:
GSFrameBase* m_frame;
u32 m_draw_frames;
u32 m_skip_frames;
bool is_intel_vendor;
GLGSRender();
virtual ~GLGSRender() override;
private:
static u32 enable(u32 enable, u32 cap);
static u32 enable(u32 enable, u32 cap, u32 index);
void EnableVertexData(bool indexed_draw = false);
void DisableVertexData();
void InitVertexData();
void InitFragmentData();
public:
bool load_program();
void init_buffers();
void read_buffers();
void write_buffers();
void Enable(bool enable, const u32 cap);
virtual void Close() override;
bool LoadProgram();
void WriteBuffers();
void WriteDepthBuffer();
void WriteColorBuffers();
void WriteColorBufferA();
void WriteColorBufferB();
void WriteColorBufferC();
void WriteColorBufferD();
void DrawObjects();
void InitDrawBuffers();
protected:
void begin() override;
void end() override;
virtual void OnInit() override;
virtual void OnInitThread() override;
virtual void OnExitThread() override;
virtual void OnReset() override;
virtual void Clear(u32 cmd) override;
virtual void Draw() override;
virtual void Flip() 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;
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 {}
};

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

@ -23,12 +23,25 @@ OPENGL_PROC(PFNGLATTACHSHADERPROC, AttachShader);
OPENGL_PROC(PFNGLDETACHSHADERPROC, DetachShader);
OPENGL_PROC(PFNGLGETATTRIBLOCATIONPROC, GetAttribLocation);
OPENGL_PROC(PFNGLLINKPROGRAMPROC, LinkProgram);
OPENGL_PROC(PFNGLVALIDATEPROGRAMPROC, ValidateProgram);
OPENGL_PROC(PFNGLBINDFRAGDATALOCATIONPROC, BindFragDataLocation);
//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);
@ -36,106 +49,36 @@ 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(PFNGLUNIFORM4IPROC, Uniform4i);
OPENGL_PROC(PFNGLUNIFORM4FPROC, 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(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(PFNGLUNIFORMMATRIX4FVPROC, UniformMatrix4fv);
OPENGL_PROC(PFNGLUSEPROGRAMPROC, UseProgram);
OPENGL_PROC(PFNGLDEPTHBOUNDSEXTPROC, DepthBoundsEXT);
OPENGL_PROC2(PFNGLDEPTHBOUNDSEXTPROC, DepthBoundsEXT, glDepthBoundsEXT);
OPENGL_PROC(PFNGLSTENCILOPSEPARATEPROC, StencilOpSeparate);
OPENGL_PROC(PFNGLSTENCILFUNCSEPARATEPROC, StencilFuncSeparate);
OPENGL_PROC(PFNGLSTENCILMASKSEPARATEPROC, StencilMaskSeparate);
@ -153,25 +96,13 @@ 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,4 +116,3 @@ void GLProgram::Delete()
id = 0;
m_locations.clear();
}
*/

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

@ -1,8 +1,7 @@
#pragma once
#include "GLVertexProgram.h"
#include "GLFragmentProgram.h"
/*
struct GLProgram
{
private:
@ -28,4 +27,3 @@ 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 gl::glsl::program PipelineData;
typedef GLProgram PipelineData;
typedef void* PipelineProperties;
typedef void* ExtraData;
@ -36,18 +36,12 @@ struct GLTraits
static
PipelineData *BuildProgram(VertexProgramData &vertexProgramData, FragmentProgramData &fragmentProgramData, const PipelineProperties &pipelineProperties, const ExtraData& extraData)
{
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();
GLProgram *result = new GLProgram();
result->Create(vertexProgramData.id, fragmentProgramData.id);
//checkForGlError("m_program.Create");
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);
@ -60,7 +54,7 @@ struct GLTraits
static
void DeleteProgram(PipelineData *ptr)
{
ptr->remove();
ptr->Delete();
}
};

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 140" << std::endl << std::endl;
OS << "#version 420" << 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 gl::init()
void InitProcTable()
{
#ifdef _WIN32
#define OPENGL_PROC(p, n) OPENGL_PROC2(p, n, gl##n)

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

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

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

@ -1,470 +0,0 @@
#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
View file

File diff suppressed because it is too large Load diff

2
rpcs3/Emu/RSX/GSManager.cpp
View file

@ -48,7 +48,7 @@ void GSManager::Close()
{
if(m_render)
{
m_render->close();
m_render->Close();
delete m_render;
m_render = nullptr;
}

2
rpcs3/Emu/RSX/GSManager.h
View file

@ -1,6 +1,6 @@
#pragma once
class GSRender;
struct GSRender;
struct GSInfo
{

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

@ -5,68 +5,26 @@
#include "GSManager.h"
#include "GSRender.h"
draw_context_t GSFrameBase::new_context()
GSLock::GSLock(GSRender& renderer, GSLockType type)
: m_renderer(renderer)
, m_type(type)
{
if (void* context = make_context())
switch (m_type)
{
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())
{
}
GSRender::~GSRender()
{
m_context = nullptr;
if (m_frame)
{
m_frame->close();
case GS_LOCK_NOT_WAIT: m_renderer.m_cs_main.lock(); break;
case GS_LOCK_WAIT_FLIP: m_renderer.m_sem_flip.wait(); break;
}
}
void GSRender::oninit()
GSLock::~GSLock()
{
if (m_frame)
switch (m_type)
{
m_frame->show();
case GS_LOCK_NOT_WAIT: m_renderer.m_cs_main.unlock(); break;
case GS_LOCK_WAIT_FLIP: m_renderer.m_sem_flip.try_post(); break;
}
}
void GSRender::oninit_thread()
GSLockCurrent::GSLockCurrent(GSLockType type) : GSLock(Emu.GetGSManager().GetRender(), type)
{
if (m_frame)
{
m_context = m_frame->new_context();
m_frame->set_current(m_context);
}
}
void GSRender::close()
{
if (m_frame && m_frame->shown())
{
m_frame->hide();
}
if (joinable())
{
join();
}
}
void GSRender::flip(int buffer)
{
if (m_frame)
m_frame->flip(m_context);
}

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

@ -1,57 +1,34 @@
#pragma once
#include "Emu/RSX/RSXThread.h"
#include <memory>
using draw_context_t = std::shared_ptr<void>;
class GSFrameBase
struct GSRender : public RSXThread
{
protected:
std::wstring m_title_message;
virtual ~GSRender() override
{
}
virtual void Close()=0;
};
enum GSLockType
{
GS_LOCK_NOT_WAIT,
GS_LOCK_WAIT_FLIP,
};
struct GSLock
{
private:
GSRender& m_renderer;
GSLockType m_type;
public:
GSFrameBase() = default;
GSFrameBase(const GSFrameBase&) = delete;
GSLock(GSRender& renderer, GSLockType type);
virtual void close() = 0;
virtual bool shown() = 0;
virtual void hide() = 0;
virtual void show() = 0;
draw_context_t new_context();
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&);
protected:
virtual void delete_context(void* ctx) = 0;
virtual void* make_context() = 0;
~GSLock();
};
enum class frame_type
struct GSLockCurrent : GSLock
{
Null,
OpenGL,
DX12
};
class GSRender : public rsx::thread
{
protected:
GSFrameBase* m_frame;
draw_context_t m_context;
public:
GSRender(frame_type type);
virtual ~GSRender();
void oninit() override;
void oninit_thread() override;
void close();
void flip(int buffer) override;
};
GSLockCurrent(GSLockType type);
};

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

@ -1,16 +0,0 @@
#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;
}

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

@ -4,9 +4,66 @@
class NullGSRender final : public GSRender
{
public:
NullGSRender();
NullGSRender()
{
}
virtual ~NullGSRender() override
{
}
private:
void onexit_thread() override;
bool domethod(u32 cmd, u32 value) override;
virtual void OnInit() override
{
}
virtual void OnInitThread() override
{
}
virtual void OnExitThread() override
{
}
virtual void OnReset() override
{
}
virtual void Clear(u32 cmd) override
{
}
virtual void Draw() override
{
}
virtual void Flip() override
{
}
virtual void Close() override
{
if (joinable())
{
join();
}
}
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 {}
};

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

@ -3,416 +3,413 @@
#include "RSXThread.h"
#include "RSXTexture.h"
namespace rsx
RSXTexture::RSXTexture()
{
void texture::init(u8 index)
{
m_index = index;
// Offset
method_registers[NV4097_SET_TEXTURE_OFFSET + (m_index * 8)] = 0;
// Format
method_registers[NV4097_SET_TEXTURE_FORMAT + (m_index * 8)] = 0;
// 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));
// Control0
method_registers[NV4097_SET_TEXTURE_CONTROL0 + (m_index * 8)] =
(((/*alphakill*/0) << 2) | (/*maxaniso*/0) << 4) | ((/*maxlod*/0xc00) << 7) | ((/*minlod*/0) << 19) | ((/*enable*/0) << 31);
// Control1
method_registers[NV4097_SET_TEXTURE_CONTROL1 + (m_index * 8)] = 0xE4;
// 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));
// Image Rect
method_registers[NV4097_SET_TEXTURE_IMAGE_RECT + (m_index * 8)] = (/*height*/1) | ((/*width*/1) << 16);
// Border Color
method_registers[NV4097_SET_TEXTURE_BORDER_COLOR + (m_index * 8)] = 0;
}
u32 texture::offset() const
{
return method_registers[NV4097_SET_TEXTURE_OFFSET + (m_index * 8)];
}
u8 texture::location() const
{
return (method_registers[NV4097_SET_TEXTURE_FORMAT + (m_index * 8)] & 0x3) - 1;
}
bool texture::cubemap() const
{
return ((method_registers[NV4097_SET_TEXTURE_FORMAT + (m_index * 8)] >> 2) & 0x1);
}
u8 texture::border_type() const
{
return ((method_registers[NV4097_SET_TEXTURE_FORMAT + (m_index * 8)] >> 3) & 0x1);
}
u8 texture::dimension() const
{
return ((method_registers[NV4097_SET_TEXTURE_FORMAT + (m_index * 8)] >> 4) & 0xf);
}
u8 texture::format() const
{
return ((method_registers[NV4097_SET_TEXTURE_FORMAT + (m_index * 8)] >> 8) & 0xff);
}
u16 texture::mipmap() const
{
return ((method_registers[NV4097_SET_TEXTURE_FORMAT + (m_index * 8)] >> 16) & 0xffff);
}
u8 texture::wrap_s() const
{
return ((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)]) & 0xf);
}
u8 texture::wrap_t() const
{
return ((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] >> 8) & 0xf);
}
u8 texture::wrap_r() const
{
return ((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] >> 16) & 0xf);
}
u8 texture::unsigned_remap() const
{
return ((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] >> 12) & 0xf);
}
u8 texture::zfunc() const
{
return ((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] >> 28) & 0xf);
}
u8 texture::gamma() const
{
return ((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] >> 20) & 0xf);
}
u8 texture::aniso_bias() const
{
return ((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] >> 4) & 0xf);
}
u8 texture::signed_remap() const
{
return ((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] >> 24) & 0xf);
}
bool texture::enabled() const
{
return location() <= 1 && ((method_registers[NV4097_SET_TEXTURE_CONTROL0 + (m_index * 8)] >> 31) & 0x1);
}
u16 texture::min_lod() const
{
return ((method_registers[NV4097_SET_TEXTURE_CONTROL0 + (m_index * 8)] >> 19) & 0xfff);
}
u16 texture::max_lod() const
{
return ((method_registers[NV4097_SET_TEXTURE_CONTROL0 + (m_index * 8)] >> 7) & 0xfff);
}
u8 texture::max_aniso() const
{
return ((method_registers[NV4097_SET_TEXTURE_CONTROL0 + (m_index * 8)] >> 4) & 0x7);
}
bool texture::alpha_kill_enabled() const
{
return ((method_registers[NV4097_SET_TEXTURE_CONTROL0 + (m_index * 8)] >> 2) & 0x1);
}
u32 texture::remap() const
{
return (method_registers[NV4097_SET_TEXTURE_CONTROL1 + (m_index * 8)]);
}
u16 texture::bias() const
{
return ((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)]) & 0x1fff);
}
u8 texture::min_filter() const
{
return ((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] >> 16) & 0x7);
}
u8 texture::mag_filter() const
{
return ((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] >> 24) & 0x7);
}
u8 texture::convolution_filter() const
{
return ((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] >> 13) & 0xf);
}
bool texture::a_signed() const
{
return ((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] >> 28) & 0x1);
}
bool texture::r_signed() const
{
return ((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] >> 29) & 0x1);
}
bool texture::g_signed() const
{
return ((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] >> 30) & 0x1);
}
bool texture::b_signed() const
{
return ((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] >> 31) & 0x1);
}
u16 texture::width() const
{
return ((method_registers[NV4097_SET_TEXTURE_IMAGE_RECT + (m_index * 8)] >> 16) & 0xffff);
}
u16 texture::height() const
{
return ((method_registers[NV4097_SET_TEXTURE_IMAGE_RECT + (m_index * 8)]) & 0xffff);
}
u32 texture::border_color() const
{
return method_registers[NV4097_SET_TEXTURE_BORDER_COLOR + (m_index * 8)];
}
u16 texture::depth() const
{
return method_registers[NV4097_SET_TEXTURE_CONTROL3] >> 20;
}
u32 texture::pitch() const
{
return method_registers[NV4097_SET_TEXTURE_CONTROL3] & 0xfffff;
}
void vertex_texture::init(u8 index)
{
m_index = index;
// Offset
method_registers[NV4097_SET_VERTEX_TEXTURE_OFFSET + (m_index * 8)] = 0;
// Format
method_registers[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 8)] = 0;
// 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));
// Control0
method_registers[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 8)] =
(((/*alphakill*/0) << 2) | (/*maxaniso*/0) << 4) | ((/*maxlod*/0xc00) << 7) | ((/*minlod*/0) << 19) | ((/*enable*/0) << 31);
// Control1
//method_registers[NV4097_SET_VERTEX_TEXTURE_CONTROL1 + (m_index * 8)] = 0xE4;
// 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));
// Image Rect
method_registers[NV4097_SET_VERTEX_TEXTURE_IMAGE_RECT + (m_index * 8)] = (/*height*/1) | ((/*width*/1) << 16);
// Border Color
method_registers[NV4097_SET_VERTEX_TEXTURE_BORDER_COLOR + (m_index * 8)] = 0;
}
u32 vertex_texture::offset() const
{
return method_registers[NV4097_SET_VERTEX_TEXTURE_OFFSET + (m_index * 8)];
}
u8 vertex_texture::location() const
{
return (method_registers[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 8)] & 0x3) - 1;
}
bool vertex_texture::cubemap() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 8)] >> 2) & 0x1);
}
u8 vertex_texture::border_type() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 8)] >> 3) & 0x1);
}
u8 vertex_texture::dimension() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 8)] >> 4) & 0xf);
}
u8 vertex_texture::format() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 8)] >> 8) & 0xff);
}
u16 vertex_texture::mipmap() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 8)] >> 16) & 0xffff);
}
u8 vertex_texture::wrap_s() const
{
return 1;
//return ((method_registers[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 8)]) & 0xf);
}
u8 vertex_texture::wrap_t() const
{
return 1;
//return ((method_registers[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 8)] >> 8) & 0xf);
}
u8 vertex_texture::wrap_r() const
{
return 1;
//return ((method_registers[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 8)] >> 16) & 0xf);
}
u8 vertex_texture::unsigned_remap() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 8)] >> 12) & 0xf);
}
u8 vertex_texture::zfunc() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 8)] >> 28) & 0xf);
}
u8 vertex_texture::gamma() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 8)] >> 20) & 0xf);
}
u8 vertex_texture::aniso_bias() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 8)] >> 4) & 0xf);
}
u8 vertex_texture::signed_remap() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 8)] >> 24) & 0xf);
}
bool vertex_texture::enabled() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 8)] >> 31) & 0x1);
}
u16 vertex_texture::min_lod() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 8)] >> 19) & 0xfff);
}
u16 vertex_texture::max_lod() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 8)] >> 7) & 0xfff);
}
u8 vertex_texture::max_aniso() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 8)] >> 4) & 0x7);
}
bool vertex_texture::alpha_kill_enabled() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 8)] >> 2) & 0x1);
}
u32 vertex_texture::remap() const
{
return 0 | (1 << 2) | (2 << 4) | (3 << 6);//(method_registers[NV4097_SET_VERTEX_TEXTURE_CONTROL1 + (m_index * 8)]);
}
u16 vertex_texture::bias() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 8)]) & 0x1fff);
}
u8 vertex_texture::min_filter() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 8)] >> 16) & 0x7);
}
u8 vertex_texture::mag_filter() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 8)] >> 24) & 0x7);
}
u8 vertex_texture::convolution_filter() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 8)] >> 13) & 0xf);
}
bool vertex_texture::a_signed() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 8)] >> 28) & 0x1);
}
bool vertex_texture::r_signed() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 8)] >> 29) & 0x1);
}
bool vertex_texture::g_signed() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 8)] >> 30) & 0x1);
}
bool vertex_texture::b_signed() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 8)] >> 31) & 0x1);
}
u16 vertex_texture::width() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_IMAGE_RECT + (m_index * 8)] >> 16) & 0xffff);
}
u16 vertex_texture::height() const
{
return ((method_registers[NV4097_SET_VERTEX_TEXTURE_IMAGE_RECT + (m_index * 8)]) & 0xffff);
}
u32 vertex_texture::border_color() const
{
return method_registers[NV4097_SET_VERTEX_TEXTURE_BORDER_COLOR + (m_index * 8)];
}
u16 vertex_texture::depth() const
{
return method_registers[NV4097_SET_VERTEX_TEXTURE_CONTROL3] >> 20;
}
u32 vertex_texture::pitch() const
{
return method_registers[NV4097_SET_VERTEX_TEXTURE_CONTROL3] & 0xfffff;
}
m_index = 0;
}
RSXTexture::RSXTexture(u8 index)
{
m_index = index;
}
void RSXTexture::Init()
{
// Offset
methodRegisters[NV4097_SET_TEXTURE_OFFSET + (m_index*32)] = 0;
// Format
methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] = 0;
// Address
methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] =
((/*wraps*/1) | ((/*anisoBias*/0) << 4) | ((/*wrapt*/1) << 8) | ((/*unsignedRemap*/0) << 12) |
((/*wrapr*/3) << 16) | ((/*gamma*/0) << 20) |((/*signedRemap*/0) << 24) | ((/*zfunc*/0) << 28));
// Control0
methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] =
(((/*alphakill*/0) << 2) | (/*maxaniso*/0) << 4) | ((/*maxlod*/0xc00) << 7) | ((/*minlod*/0) << 19) | ((/*enable*/0) << 31);
// Control1
methodRegisters[NV4097_SET_TEXTURE_CONTROL1 + (m_index*32)] = 0xE4;
// Filter
methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] =
((/*bias*/0) | ((/*conv*/1) << 13) | ((/*min*/5) << 16) | ((/*mag*/2) << 24)
| ((/*as*/0) << 28) | ((/*rs*/0) << 29) | ((/*gs*/0) << 30) | ((/*bs*/0) << 31) );
// Image Rect
methodRegisters[NV4097_SET_TEXTURE_IMAGE_RECT + (m_index*32)] = (/*height*/1) | ((/*width*/1) << 16);
// Border Color
methodRegisters[NV4097_SET_TEXTURE_BORDER_COLOR + (m_index*32)] = 0;
}
u32 RSXTexture::GetOffset() const
{
return methodRegisters[NV4097_SET_TEXTURE_OFFSET + (m_index*32)];
}
u8 RSXTexture::GetLocation() const
{
return (methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] & 0x3) - 1;
}
bool RSXTexture::isCubemap() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] >> 2) & 0x1);
}
u8 RSXTexture::GetBorderType() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] >> 3) & 0x1);
}
u8 RSXTexture::GetDimension() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] >> 4) & 0xf);
}
u8 RSXTexture::GetFormat() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] >> 8) & 0xff);
}
u16 RSXTexture::GetMipmap() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] >> 16) & 0xffff);
}
u8 RSXTexture::GetWrapS() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)]) & 0xf);
}
u8 RSXTexture::GetWrapT() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 8) & 0xf);
}
u8 RSXTexture::GetWrapR() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 16) & 0xf);
}
u8 RSXTexture::GetUnsignedRemap() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 12) & 0xf);
}
u8 RSXTexture::GetZfunc() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 28) & 0xf);
}
u8 RSXTexture::GetGamma() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 20) & 0xf);
}
u8 RSXTexture::GetAnisoBias() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 4) & 0xf);
}
u8 RSXTexture::GetSignedRemap() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 24) & 0xf);
}
bool RSXTexture::IsEnabled() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] >> 31) & 0x1);
}
u16 RSXTexture::GetMinLOD() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] >> 19) & 0xfff);
}
u16 RSXTexture::GetMaxLOD() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] >> 7) & 0xfff);
}
u8 RSXTexture::GetMaxAniso() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] >> 4) & 0x7);
}
bool RSXTexture::IsAlphaKillEnabled() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] >> 2) & 0x1);
}
u32 RSXTexture::GetRemap() const
{
return (methodRegisters[NV4097_SET_TEXTURE_CONTROL1 + (m_index*32)]);
}
u16 RSXTexture::GetBias() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)]) & 0x1fff);
}
u8 RSXTexture::GetMinFilter() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 16) & 0x7);
}
u8 RSXTexture::GetMagFilter() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 24) & 0x7);
}
u8 RSXTexture::GetConvolutionFilter() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 13) & 0xf);
}
bool RSXTexture::isASigned() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 28) & 0x1);
}
bool RSXTexture::isRSigned() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 29) & 0x1);
}
bool RSXTexture::isGSigned() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 30) & 0x1);
}
bool RSXTexture::isBSigned() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 31) & 0x1);
}
u16 RSXTexture::GetWidth() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_IMAGE_RECT + (m_index*32)] >> 16) & 0xffff);
}
u16 RSXTexture::GetHeight() const
{
return ((methodRegisters[NV4097_SET_TEXTURE_IMAGE_RECT + (m_index*32)]) & 0xffff);
}
u32 RSXTexture::GetBorderColor() const
{
return methodRegisters[NV4097_SET_TEXTURE_BORDER_COLOR + (m_index*32)];
}
void RSXTexture::SetControl3(u16 depth, u32 pitch)
{
m_depth = depth;
m_pitch = pitch;
}
RSXVertexTexture::RSXVertexTexture() : RSXTexture()
{
}
RSXVertexTexture::RSXVertexTexture(u8 index) : RSXTexture(index)
{
}
void RSXVertexTexture::Init()
{
// Offset
methodRegisters[NV4097_SET_VERTEX_TEXTURE_OFFSET + (m_index * 32)] = 0;
// Format
methodRegisters[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 32)] = 0;
// Address
methodRegisters[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 32)] =
((/*wraps*/1) | ((/*anisoBias*/0) << 4) | ((/*wrapt*/1) << 8) | ((/*unsignedRemap*/0) << 12) |
((/*wrapr*/3) << 16) | ((/*gamma*/0) << 20) | ((/*signedRemap*/0) << 24) | ((/*zfunc*/0) << 28));
// Control0
methodRegisters[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 32)] =
(((/*alphakill*/0) << 2) | (/*maxaniso*/0) << 4) | ((/*maxlod*/0xc00) << 7) | ((/*minlod*/0) << 19) | ((/*enable*/0) << 31);
// Control1
//methodRegisters[NV4097_SET_VERTEX_TEXTURE_CONTROL1 + (m_index * 32)] = 0xE4;
// Filter
methodRegisters[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 32)] =
((/*bias*/0) | ((/*conv*/1) << 13) | ((/*min*/5) << 16) | ((/*mag*/2) << 24)
| ((/*as*/0) << 28) | ((/*rs*/0) << 29) | ((/*gs*/0) << 30) | ((/*bs*/0) << 31));
// Image Rect
methodRegisters[NV4097_SET_VERTEX_TEXTURE_IMAGE_RECT + (m_index * 32)] = (/*height*/1) | ((/*width*/1) << 16);
// Border Color
methodRegisters[NV4097_SET_VERTEX_TEXTURE_BORDER_COLOR + (m_index * 32)] = 0;
}
u32 RSXVertexTexture::GetOffset() const
{
return methodRegisters[NV4097_SET_VERTEX_TEXTURE_OFFSET + (m_index * 32)];
}
u8 RSXVertexTexture::GetLocation() const
{
return (methodRegisters[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 32)] & 0x3) - 1;
}
bool RSXVertexTexture::isCubemap() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 32)] >> 2) & 0x1);
}
u8 RSXVertexTexture::GetBorderType() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 32)] >> 3) & 0x1);
}
u8 RSXVertexTexture::GetDimension() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 32)] >> 4) & 0xf);
}
u8 RSXVertexTexture::GetFormat() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 32)] >> 8) & 0xff);
}
u16 RSXVertexTexture::GetMipmap() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FORMAT + (m_index * 32)] >> 16) & 0xffff);
}
u8 RSXVertexTexture::GetWrapS() const
{
return 1;
//return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 32)]) & 0xf);
}
u8 RSXVertexTexture::GetWrapT() const
{
return 1;
//return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 32)] >> 8) & 0xf);
}
u8 RSXVertexTexture::GetWrapR() const
{
return 1;
//return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 32)] >> 16) & 0xf);
}
u8 RSXVertexTexture::GetUnsignedRemap() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 32)] >> 12) & 0xf);
}
u8 RSXVertexTexture::GetZfunc() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 32)] >> 28) & 0xf);
}
u8 RSXVertexTexture::GetGamma() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 32)] >> 20) & 0xf);
}
u8 RSXVertexTexture::GetAnisoBias() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 32)] >> 4) & 0xf);
}
u8 RSXVertexTexture::GetSignedRemap() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_ADDRESS + (m_index * 32)] >> 24) & 0xf);
}
bool RSXVertexTexture::IsEnabled() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 32)] >> 31) & 0x1);
}
u16 RSXVertexTexture::GetMinLOD() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 32)] >> 19) & 0xfff);
}
u16 RSXVertexTexture::GetMaxLOD() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 32)] >> 7) & 0xfff);
}
u8 RSXVertexTexture::GetMaxAniso() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 32)] >> 4) & 0x7);
}
bool RSXVertexTexture::IsAlphaKillEnabled() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_CONTROL0 + (m_index * 32)] >> 2) & 0x1);
}
u32 RSXVertexTexture::GetRemap() const
{
return 0 | (1 << 2) | (2 << 4) | (3 << 6);//(methodRegisters[NV4097_SET_VERTEX_TEXTURE_CONTROL1 + (m_index * 32)]);
}
u16 RSXVertexTexture::GetBias() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 32)]) & 0x1fff);
}
u8 RSXVertexTexture::GetMinFilter() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 32)] >> 16) & 0x7);
}
u8 RSXVertexTexture::GetMagFilter() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 32)] >> 24) & 0x7);
}
u8 RSXVertexTexture::GetConvolutionFilter() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 32)] >> 13) & 0xf);
}
bool RSXVertexTexture::isASigned() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 32)] >> 28) & 0x1);
}
bool RSXVertexTexture::isRSigned() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 32)] >> 29) & 0x1);
}
bool RSXVertexTexture::isGSigned() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 32)] >> 30) & 0x1);
}
bool RSXVertexTexture::isBSigned() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_FILTER + (m_index * 32)] >> 31) & 0x1);
}
u16 RSXVertexTexture::GetWidth() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_IMAGE_RECT + (m_index * 32)] >> 16) & 0xffff);
}
u16 RSXVertexTexture::GetHeight() const
{
return ((methodRegisters[NV4097_SET_VERTEX_TEXTURE_IMAGE_RECT + (m_index * 32)]) & 0xffff);
}
u32 RSXVertexTexture::GetBorderColor() const
{
return methodRegisters[NV4097_SET_VERTEX_TEXTURE_BORDER_COLOR + (m_index * 32)];
}

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

@ -1,131 +1,122 @@
#pragma once
#include "Utilities/types.h"
namespace rsx
class RSXTexture
{
class texture
{
protected:
u8 m_index;
protected:
u8 m_index;
public:
//initialize texture registers with default values
void init(u8 index);
public:
u32 m_pitch;
u16 m_depth;
// Offset
u32 offset() const;
public:
RSXTexture();
RSXTexture(u8 index);
virtual void Init();
// Format
u8 location() const;
bool cubemap() const;
u8 border_type() const;
u8 dimension() const;
u8 format() const;
u16 mipmap() const;
// Offset
virtual u32 GetOffset() const;
// Address
u8 wrap_s() const;
u8 wrap_t() const;
u8 wrap_r() const;
u8 unsigned_remap() const;
u8 zfunc() const;
u8 gamma() const;
u8 aniso_bias() const;
u8 signed_remap() const;
// Format
virtual u8 GetLocation() const;
virtual bool isCubemap() const;
virtual u8 GetBorderType() const;
virtual u8 GetDimension() const;
virtual u8 GetFormat() const;
virtual u16 GetMipmap() const;
// Control0
bool enabled() const;
u16 min_lod() const;
u16 max_lod() const;
u8 max_aniso() const;
bool alpha_kill_enabled() const;
// Address
virtual u8 GetWrapS() const;
virtual u8 GetWrapT() const;
virtual u8 GetWrapR() const;
virtual u8 GetUnsignedRemap() const;
virtual u8 GetZfunc() const;
virtual u8 GetGamma() const;
virtual u8 GetAnisoBias() const;
virtual u8 GetSignedRemap() const;
// Control1
u32 remap() const;
// Control0
virtual bool IsEnabled() const;
virtual u16 GetMinLOD() const;
virtual u16 GetMaxLOD() const;
virtual u8 GetMaxAniso() const;
virtual bool IsAlphaKillEnabled() const;
// Filter
u16 bias() const;
u8 min_filter() const;
u8 mag_filter() const;
u8 convolution_filter() const;
bool a_signed() const;
bool r_signed() const;
bool g_signed() const;
bool b_signed() const;
// Control1
virtual u32 GetRemap() const;
// Image Rect
u16 width() const;
u16 height() const;
// Filter
virtual u16 GetBias() const;
virtual u8 GetMinFilter() const;
virtual u8 GetMagFilter() const;
virtual u8 GetConvolutionFilter() const;
virtual bool isASigned() const;
virtual bool isRSigned() const;
virtual bool isGSigned() const;
virtual bool isBSigned() const;
// Border Color
u32 border_color() const;
u16 depth() const;
u32 pitch() const;
// Image Rect
virtual u16 GetWidth() const;
virtual u16 GetHeight() const;
//custom info
u8 index() const;
};
// Border Color
virtual u32 GetBorderColor() const;
class vertex_texture
{
protected:
u8 m_index;
void SetControl3(u16 depth, u32 pitch);
};
public:
//initialize texture registers with default values
void init(u8 index);
class RSXVertexTexture : public RSXTexture
{
public:
RSXVertexTexture();
RSXVertexTexture(u8 index);
void Init();
// Offset
u32 offset() const;
// Offset
u32 GetOffset() const;
// Format
u8 location() const;
bool cubemap() const;
u8 border_type() const;
u8 dimension() const;
u8 format() const;
u16 mipmap() const;
// Format
u8 GetLocation() const;
bool isCubemap() const;
u8 GetBorderType() const;
u8 GetDimension() const;
u8 GetFormat() const;
u16 GetMipmap() const;
// Address
u8 wrap_s() const;
u8 wrap_t() const;
u8 wrap_r() const;
u8 unsigned_remap() const;
u8 zfunc() const;
u8 gamma() const;
u8 aniso_bias() const;
u8 signed_remap() const;
// Address
u8 GetWrapS() const;
u8 GetWrapT() const;
u8 GetWrapR() const;
u8 GetUnsignedRemap() const;
u8 GetZfunc() const;
u8 GetGamma() const;
u8 GetAnisoBias() const;
u8 GetSignedRemap() const;
// Control0
bool enabled() const;
u16 min_lod() const;
u16 max_lod() const;
u8 max_aniso() const;
bool alpha_kill_enabled() const;
// Control0
bool IsEnabled() const;
u16 GetMinLOD() const;
u16 GetMaxLOD() const;
u8 GetMaxAniso() const;
bool IsAlphaKillEnabled() const;
// Control1
u32 remap() const;
// Control1
u32 GetRemap() const;
// Filter
u16 bias() const;
u8 min_filter() const;
u8 mag_filter() const;
u8 convolution_filter() const;
bool a_signed() const;
bool r_signed() const;
bool g_signed() const;
bool b_signed() const;
// Filter
u16 GetBias() const;
u8 GetMinFilter() const;
u8 GetMagFilter() const;
u8 GetConvolutionFilter() const;
bool isASigned() const;
bool isRSigned() const;
bool isGSigned() const;
bool isBSigned() const;
// Image Rect
u16 width() const;
u16 height() const;
// Image Rect
u16 GetWidth() const;
u16 GetHeight() const;
// Border Color
u32 border_color() const;
u16 depth() const;
u32 pitch() const;
//custom info
u8 index() const;
};
}
// Border Color
u32 GetBorderColor() const;
};

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

File diff suppressed because it is too large Load diff

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

@ -8,222 +8,721 @@
#include "Utilities/Semaphore.h"
#include "Utilities/Thread.h"
#include "Utilities/Timer.h"
#include "Utilities/types.h"
namespace rsx
enum Method
{
namespace limits
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,
};
extern u32 methodRegisters[0xffff];
u32 GetAddress(u32 offset, u32 location);
struct RSXVertexData
{
u32 frequency;
u32 stride;
u32 size;
u32 type;
u32 addr;
u32 constant_count;
std::vector<u8> data;
RSXVertexData();
void Reset();
bool IsEnabled() const { return size > 0; }
void Load(u32 start, u32 count, u32 baseOffset, u32 baseIndex);
u32 GetTypeSize() const;
};
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()
{
enum
{
textures_count = 16,
vertex_textures_count = 4,
vertex_count = 16,
fragment_count = 32,
tiles_count = 15,
zculls_count = 8,
color_buffers_count = 4
};
Reset();
}
//TODO
union alignas(4) method_registers_t
void Reset()
{
u8 _u8[0x10000];
u32 _u32[0x10000 >> 2];
/*
struct alignas(4)
m_type = 0;
m_first = ~0;
m_count = 0;
m_addr = 0;
index_min = ~0;
index_max = 0;
m_data.clear();
}
};
struct RSXTransformConstant
{
u32 id;
float x, y, z, w;
RSXTransformConstant()
: x(0.0f)
, y(0.0f)
, z(0.0f)
, w(0.0f)
{
}
RSXTransformConstant(u32 id, float x, float y, float z, float w)
: id(id)
, x(x)
, y(y)
, z(z)
, w(w)
{
}
};
class RSXThread : protected named_thread_t
{
public:
static const uint m_textures_count = 16;
static const uint m_vertex_count = 32;
static const uint m_fragment_count = 32;
static const uint m_tiles_count = 15;
static const uint m_zculls_count = 8;
protected:
std::stack<u32> m_call_stack;
CellGcmControl* m_ctrl;
Timer m_timer_sync;
public:
GcmTileInfo m_tiles[m_tiles_count];
GcmZcullInfo m_zculls[m_zculls_count];
RSXTexture m_textures[m_textures_count];
RSXVertexTexture m_vertex_textures[m_textures_count];
RSXVertexData m_vertex_data[m_vertex_count];
RSXIndexArrayData m_indexed_array;
std::vector<RSXTransformConstant> m_fragment_constants;
std::vector<RSXTransformConstant> m_transform_constants;
u32 m_shader_ctrl, m_cur_fragment_prog_num;
RSXFragmentProgram m_fragment_progs[m_fragment_count];
RSXFragmentProgram* m_cur_fragment_prog;
RSXVertexProgram m_vertex_progs[m_vertex_count];
RSXVertexProgram* m_cur_vertex_prog;
public:
u32 m_ioAddress, m_ioSize, m_ctrlAddress;
int m_flip_status;
int m_flip_mode;
int m_debug_level;
int m_frequency_mode;
u32 m_tiles_addr;
u32 m_zculls_addr;
u32 m_gcm_buffers_addr;
u32 m_gcm_buffers_count;
u32 m_gcm_current_buffer;
u32 m_ctxt_addr;
u32 m_report_main_addr;
u32 m_label_addr;
// DMA
u32 dma_report;
u32 m_local_mem_addr, m_main_mem_addr;
bool m_strict_ordering[0x1000];
public:
uint m_draw_mode;
u32 m_width;
u32 m_height;
float m_width_scale;
float m_height_scale;
u32 m_draw_array_count;
u32 m_draw_array_first;
double m_fps_limit = 59.94;
public:
std::mutex m_cs_main;
semaphore_t m_sem_flip;
u64 m_last_flip_time;
vm::ptr<void(u32)> m_flip_handler;
vm::ptr<void(u32)> m_user_handler;
u64 m_vblank_count;
vm::ptr<void(u32)> m_vblank_handler;
public:
// Dither
bool m_set_dither;
// Color mask
bool m_set_color_mask;
bool m_color_mask_r;
bool m_color_mask_g;
bool m_color_mask_b;
bool m_color_mask_a;
// Clip
bool m_set_clip;
float m_clip_min;
float m_clip_max;
// Depth test
bool m_set_depth_test;
bool m_set_depth_func;
int m_depth_func;
bool m_set_depth_mask;
u32 m_depth_mask;
// 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_viewport_horizontal;
bool m_set_viewport_vertical;
u16 m_viewport_x;
u16 m_viewport_y;
u16 m_viewport_w;
u16 m_viewport_h;
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];
// Logic Ops
bool m_set_logic_op;
u32 m_logic_op;
// Clearing
u32 m_clear_surface_mask;
u32 m_clear_surface_z;
u8 m_clear_surface_s;
u8 m_clear_surface_color_r;
u8 m_clear_surface_color_g;
u8 m_clear_surface_color_b;
u8 m_clear_surface_color_a;
u8 m_clear_color_r;
u8 m_clear_color_g;
u8 m_clear_color_b;
u8 m_clear_color_a;
u8 m_clear_s;
u32 m_clear_z;
// Blending
bool m_set_blend;
bool m_set_blend_dfactor;
u16 m_blend_dfactor_rgb;
u16 m_blend_dfactor_alpha;
bool m_set_blend_sfactor;
u16 m_blend_sfactor_rgb;
u16 m_blend_sfactor_alpha;
bool m_set_blend_equation;
u16 m_blend_equation_rgb;
u16 m_blend_equation_alpha;
bool m_set_blend_color;
u8 m_blend_color_r;
u8 m_blend_color_g;
u8 m_blend_color_b;
u8 m_blend_color_a;
bool m_set_blend_mrt1;
bool m_set_blend_mrt2;
bool m_set_blend_mrt3;
// Stencil Test
bool m_set_stencil_test;
bool m_set_stencil_mask;
u32 m_stencil_mask;
bool m_set_stencil_func;
u32 m_stencil_func;
bool m_set_stencil_func_ref;
u32 m_stencil_func_ref;
bool m_set_stencil_func_mask;
u32 m_stencil_func_mask;
bool m_set_stencil_fail;
u32 m_stencil_fail;
bool m_set_stencil_zfail;
u32 m_stencil_zfail;
bool m_set_stencil_zpass;
u32 m_stencil_zpass;
bool m_set_two_sided_stencil_test_enable;
bool m_set_two_side_light_enable;
bool m_set_back_stencil_mask;
u32 m_back_stencil_mask;
bool m_set_back_stencil_func;
u32 m_back_stencil_func;
bool m_set_back_stencil_func_ref;
u32 m_back_stencil_func_ref;
bool m_set_back_stencil_func_mask;
u32 m_back_stencil_func_mask;
bool m_set_back_stencil_fail;
u32 m_back_stencil_fail;
bool m_set_back_stencil_zfail;
u32 m_back_stencil_zfail;
bool m_set_back_stencil_zpass;
u32 m_back_stencil_zpass;
bool m_set_stencil_op_fail;
// 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
bool m_set_surface_format;
u8 m_surface_color_format;
u8 m_surface_depth_format;
u8 m_surface_type;
u8 m_surface_antialias;
u8 m_surface_width;
u8 m_surface_height;
bool m_set_surface_clip_horizontal;
u16 m_surface_clip_x;
u16 m_surface_clip_w;
bool m_set_surface_clip_vertical;
u16 m_surface_clip_y;
u16 m_surface_clip_h;
u32 m_surface_pitch_a;
u32 m_surface_pitch_b;
u32 m_surface_pitch_c;
u32 m_surface_pitch_d;
u32 m_surface_pitch_z;
u32 m_surface_offset_a;
u32 m_surface_offset_b;
u32 m_surface_offset_c;
u32 m_surface_offset_d;
u32 m_surface_offset_z;
u32 m_surface_color_target;
// DMA context
bool m_set_context_dma_color_a;
u32 m_context_dma_color_a;
bool m_set_context_dma_color_b;
u32 m_context_dma_color_b;
bool m_set_context_dma_color_c;
u32 m_context_dma_color_c;
bool m_set_context_dma_color_d;
u32 m_context_dma_color_d;
bool m_set_context_dma_z;
u32 m_context_dma_z;
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;
// Cull face
bool m_set_cull_face;
u32 m_cull_face;
// Alpha test
bool m_set_alpha_test;
bool m_set_alpha_func;
u32 m_alpha_func;
bool m_set_alpha_ref;
float m_alpha_ref;
// Shader
u16 m_shader_window_height;
u8 m_shader_window_origin;
u16 m_shader_window_pixel_centers;
// Vertex Data
u32 m_vertex_data_base_offset;
u32 m_vertex_data_base_index;
// Front face
bool m_set_front_face;
u32 m_front_face;
// Frequency divider
u32 m_set_frequency_divider_operation;
u8 m_begin_end;
bool m_read_buffer;
std::set<u32> m_used_gcm_commands;
protected:
RSXThread()
: m_ctrl(nullptr)
, m_shader_ctrl(0x40)
, m_flip_status(0)
, m_flip_mode(CELL_GCM_DISPLAY_VSYNC)
, m_debug_level(CELL_GCM_DEBUG_LEVEL0)
, m_frequency_mode(CELL_GCM_DISPLAY_FREQUENCY_DISABLE)
, m_report_main_addr(0)
, m_main_mem_addr(0)
, m_local_mem_addr(0)
, m_draw_mode(0)
, m_draw_array_count(0)
, m_draw_array_first(~0)
, m_gcm_current_buffer(0)
, m_read_buffer(true)
{
m_flip_handler.set(0);
m_vblank_handler.set(0);
m_user_handler.set(0);
m_set_depth_test = false;
m_set_alpha_test = false;
m_set_depth_bounds_test = false;
m_set_blend = false;
m_set_blend_mrt1 = false;
m_set_blend_mrt2 = false;
m_set_blend_mrt3 = false;
m_set_logic_op = false;
m_set_cull_face = false;
m_set_dither = false;
m_set_stencil_test = 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_sided_stencil_test_enable = 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
m_clear_color_r = 0;
m_clear_color_g = 0;
m_clear_color_b = 0;
m_clear_color_a = 0;
m_clear_z = 0xffffff;
m_clear_s = 0;
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
m_front_face = 0x0901; // GL_CCW
m_cull_face = 0x0405; // GL_BACK
m_alpha_func = 0x0207; // GL_ALWAYS
m_alpha_ref = 0.0f;
m_logic_op = 0x1503; // GL_COPY
m_shade_mode = 0x1D01; // GL_SMOOTH
m_depth_mask = 1;
m_depth_func = 0x0201; // GL_LESS
m_depth_bounds_min = 0.0;
m_depth_bounds_max = 1.0;
m_clip_min = 0.0;
m_clip_max = 1.0;
m_blend_equation_rgb = 0x8006; // GL_FUNC_ADD
m_blend_equation_alpha = 0x8006; // GL_FUNC_ADD
m_blend_sfactor_rgb = 1; // GL_ONE
m_blend_dfactor_rgb = 0; // GL_ZERO
m_blend_sfactor_alpha = 1; // GL_ONE
m_blend_dfactor_alpha = 0; // GL_ZERO
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;
m_vertex_data_base_offset = 0;
m_vertex_data_base_index = 0;
// Construct Stipple Pattern
for (size_t i = 0; i < 32; i++)
{
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];
m_polygon_stipple_pattern[i] = 0xFFFFFFFF;
}
};
extern u32 method_registers[0x10000 >> 2];
u32 get_address(u32 offset, u32 location);
u32 linear_to_swizzle(u32 x, u32 y, u32 z, u32 log2_width, u32 log2_height, u32 log2_depth);
u32 get_vertex_type_size(u32 type);
struct surface_info
{
u8 log2height;
u8 log2width;
u8 antialias;
u8 depth_format;
u8 color_format;
u32 width;
u32 height;
u32 format;
void unpack(u32 surface_format)
// Construct Textures
for (int i = 0; i < 16; i++)
{
format = surface_format;
log2height = surface_format >> 24;
log2width = (surface_format >> 16) & 0xff;
antialias = (surface_format >> 12) & 0xf;
depth_format = (surface_format >> 5) & 0x7;
color_format = surface_format & 0x1f;
width = 1 << (u32(log2width) + 1);
height = 1 << (u32(log2width) + 1);
m_textures[i] = RSXTexture(i);
}
};
struct data_array_format_info
Reset();
}
virtual ~RSXThread() override
{
u16 frequency = 0;
u8 stride = 0;
u8 size = 0;
u8 type = CELL_GCM_VERTEX_F;
bool array = false;
}
void unpack(u32 data_array_format)
void Reset()
{
m_set_dither = false;
m_set_color_mask = false;
m_set_clip = false;
m_set_depth_test = false;
m_set_depth_func = false;
m_set_depth_mask = false;
m_set_depth_bounds_test = false;
m_set_depth_bounds = false;
m_set_viewport_horizontal = false;
m_set_viewport_vertical = false;
m_set_scissor_horizontal = false;
m_set_scissor_vertical = false;
m_set_front_polygon_mode = false;
m_set_back_polygon_mode = false;
m_set_blend = false;
m_set_blend_mrt1 = false;
m_set_blend_mrt2 = false;
m_set_blend_mrt3 = false;
m_set_blend_sfactor = false;
m_set_blend_dfactor = false;
m_set_blend_equation = false;
m_set_blend_color = false;
m_set_stencil_test = false;
m_set_two_sided_stencil_test_enable = false;
m_set_two_side_light_enable = false;
m_set_stencil_mask = false;
m_set_stencil_func = false;
m_set_stencil_func_ref = false;
m_set_stencil_func_mask = false;
m_set_stencil_fail = false;
m_set_stencil_zfail = false;
m_set_stencil_zpass = false;
m_set_back_stencil_mask = false;
m_set_back_stencil_func = false;
m_set_back_stencil_func_ref = false;
m_set_back_stencil_func_mask = false;
m_set_back_stencil_fail = false;
m_set_back_stencil_zfail = false;
m_set_back_stencil_zpass = false;
m_set_stencil_op_fail = false;
m_set_point_sprite_control = false;
m_set_point_size = false;
m_set_line_width = false;
m_set_line_smooth = false;
m_set_shade_mode = false;
m_set_fog_mode = false;
m_set_fog_params = false;
m_set_clip_plane = false;
m_set_context_dma_color_a = false;
m_set_context_dma_color_b = false;
m_set_context_dma_color_c = false;
m_set_context_dma_color_d = false;
m_set_context_dma_z = false;
m_set_cull_face = false;
m_set_front_face = false;
m_set_alpha_test = false;
m_set_alpha_func = false;
m_set_alpha_ref = false;
m_set_poly_smooth = false;
m_set_poly_offset_fill = false;
m_set_poly_offset_line = false;
m_set_poly_offset_point = false;
m_set_poly_offset_mode = false;
m_set_restart_index = false;
m_set_specular = false;
m_set_line_stipple = false;
m_set_polygon_stipple = false;
m_set_logic_op = false;
m_set_surface_format = false;
m_set_surface_clip_horizontal = false;
m_set_surface_clip_vertical = false;
m_clear_surface_mask = 0;
m_begin_end = 0;
for (uint i = 0; i < m_textures_count; ++i)
{
frequency = data_array_format >> 16;
stride = (data_array_format >> 8) & 0xff;
size = (data_array_format >> 4) & 0xf;
type = data_array_format & 0xf;
m_textures[i].Init();
}
};
}
class thread : protected named_thread_t
void Begin(u32 draw_mode);
void End();
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 OnInit() = 0;
virtual void OnInitThread() = 0;
virtual void OnExitThread() = 0;
virtual void OnReset() = 0;
/**
* This member is called when the backend is expected to render a draw call, either
* indexed or not.
*/
virtual void Draw() = 0;
/**
* This member is called when the backend is expected to clear a target surface.
*/
virtual void Clear(u32 cmd) = 0;
/**
* This member is called when the backend is expected to present a target surface in
* either local or main memory.
*/
virtual void Flip() = 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;
void LoadVertexData(u32 first, u32 count)
{
protected:
std::stack<u32> m_call_stack;
for (u32 i = 0; i < m_vertex_count; ++i)
{
if (!m_vertex_data[i].IsEnabled()) continue;
public:
CellGcmControl* ctrl = nullptr;
m_vertex_data[i].Load(first, count, m_vertex_data_base_offset, m_vertex_data_base_index);
}
}
Timer timer_sync;
virtual void Task();
GcmTileInfo tiles[limits::tiles_count];
GcmZcullInfo zculls[limits::zculls_count];
public:
void Init(const u32 ioAddress, const u32 ioSize, const u32 ctrlAddress, const u32 localAddress);
rsx::texture textures[limits::textures_count];
rsx::vertex_texture vertex_textures[limits::vertex_textures_count];
u32 ReadIO32(u32 addr);
data_array_format_info vertex_arrays_info[limits::vertex_count];
std::vector<u8> vertex_arrays[limits::vertex_count];
std::vector<u8> vertex_index_array;
u32 vertex_draw_count = 0;
std::unordered_map<u32, color4_base<f32>> transform_constants;
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;
int flip_status;
int flip_mode;
int debug_level;
int frequency_mode;
u32 tiles_addr;
u32 zculls_addr;
vm::ps3::ptr<CellGcmDisplayInfo> gcm_buffers;
u32 gcm_buffers_count;
u32 gcm_current_buffer;
u32 ctxt_addr;
u32 report_main_addr;
u32 label_addr;
u32 draw_mode;
u32 local_mem_addr, main_mem_addr;
bool strict_ordering[0x1000];
public:
u32 draw_array_count;
u32 draw_array_first;
double fps_limit = 59.94;
public:
std::mutex cs_main;
semaphore_t sem_flip;
u64 last_flip_time;
vm::ps3::ptr<void(u32)> flip_handler = { 0 };
vm::ps3::ptr<void(u32)> user_handler = { 0 };
vm::ps3::ptr<void(u32)> vblank_handler = { 0 };
u64 vblank_count;
public:
std::set<u32> m_used_gcm_commands;
protected:
virtual ~thread() {}
public:
virtual void begin();
virtual void end();
virtual void oninit() = 0;
virtual void oninit_thread() = 0;
virtual void onexit_thread() = 0;
virtual bool domethod(u32 cmd, u32 value) { return false; }
virtual void flip(int buffer) = 0;
virtual u64 timestamp() const;
void task();
public:
void reset();
void init(const u32 ioAddress, const u32 ioSize, const u32 ctrlAddress, const u32 localAddress);
u32 ReadIO32(u32 addr);
void WriteIO32(u32 addr, u32 value);
};
}
void WriteIO32(u32 addr, u32 value);
};

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

@ -102,7 +102,7 @@ vm::ptr<CellGcmReportData> cellGcmGetReportDataAddressLocation(u32 index, u32 lo
return vm::null;
}
// TODO: It seems m_report_main_addr is not initialized
return vm::ptr<CellGcmReportData>::make(Emu.GetGSManager().GetRender().report_main_addr + index * 0x10);
return vm::ptr<CellGcmReportData>::make(Emu.GetGSManager().GetRender().m_report_main_addr + index * 0x10);
}
cellGcmSys.Error("cellGcmGetReportDataAddressLocation: Wrong location (%d)", location);
@ -201,7 +201,7 @@ u64 cellGcmGetTimeStampLocation(u32 index, u32 location)
return 0;
}
// TODO: It seems m_report_main_addr is not initialized
return vm::read64(Emu.GetGSManager().GetRender().report_main_addr + index * 0x10);
return vm::read64(Emu.GetGSManager().GetRender().m_report_main_addr + index * 0x10);
}
cellGcmSys.Error("cellGcmGetTimeStampLocation: Wrong location (%d)", location);
@ -251,14 +251,14 @@ s32 cellGcmBindTile(u8 index)
{
cellGcmSys.Warning("cellGcmBindTile(index=%d)", index);
if (index >= rsx::limits::tiles_count)
if (index >= RSXThread::m_tiles_count)
{
cellGcmSys.Error("cellGcmBindTile: CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
auto& tile = Emu.GetGSManager().GetRender().tiles[index];
tile.binded = true;
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index];
tile.m_binded = true;
return CELL_OK;
}
@ -267,14 +267,14 @@ s32 cellGcmBindZcull(u8 index)
{
cellGcmSys.Warning("cellGcmBindZcull(index=%d)", index);
if (index >= rsx::limits::zculls_count)
if (index >= RSXThread::m_zculls_count)
{
cellGcmSys.Error("cellGcmBindZcull: CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
auto& zcull = Emu.GetGSManager().GetRender().zculls[index];
zcull.binded = true;
auto& zcull = Emu.GetGSManager().GetRender().m_zculls[index];
zcull.m_binded = true;
return CELL_OK;
}
@ -290,7 +290,7 @@ s32 cellGcmGetConfiguration(vm::ptr<CellGcmConfig> config)
s32 cellGcmGetFlipStatus()
{
s32 status = Emu.GetGSManager().GetRender().flip_status;
s32 status = Emu.GetGSManager().GetRender().m_flip_status;
cellGcmSys.Log("cellGcmGetFlipStatus() -> %d", status);
@ -388,15 +388,15 @@ s32 _cellGcmInitBody(vm::pptr<CellGcmContextData> context, u32 cmdSize, u32 ioSi
ctrl.ref = -1;
auto& render = Emu.GetGSManager().GetRender();
render.ctxt_addr = context.addr();
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;
render.gcm_current_buffer = 0;
render.main_mem_addr = 0;
render.label_addr = gcm_info.label_addr;
render.init(g_defaultCommandBufferBegin, cmdSize, gcm_info.control_addr, local_addr);
render.m_ctxt_addr = context.addr();
render.m_gcm_buffers_addr = vm::alloc(sizeof(CellGcmDisplayInfo) * 8, vm::main);
render.m_zculls_addr = vm::alloc(sizeof(CellGcmZcullInfo) * 8, vm::main);
render.m_tiles_addr = vm::alloc(sizeof(CellGcmTileInfo) * 15, vm::main);
render.m_gcm_buffers_count = 0;
render.m_gcm_current_buffer = 0;
render.m_main_mem_addr = 0;
render.m_label_addr = gcm_info.label_addr;
render.Init(g_defaultCommandBufferBegin, cmdSize, gcm_info.control_addr, local_addr);
return CELL_OK;
}
@ -405,7 +405,7 @@ s32 cellGcmResetFlipStatus()
{
cellGcmSys.Log("cellGcmResetFlipStatus()");
Emu.GetGSManager().GetRender().flip_status = CELL_GCM_DISPLAY_FLIP_STATUS_WAITING;
Emu.GetGSManager().GetRender().m_flip_status = CELL_GCM_DISPLAY_FLIP_STATUS_WAITING;
return CELL_OK;
}
@ -419,7 +419,7 @@ s32 cellGcmSetDebugOutputLevel(s32 level)
case CELL_GCM_DEBUG_LEVEL0:
case CELL_GCM_DEBUG_LEVEL1:
case CELL_GCM_DEBUG_LEVEL2:
Emu.GetGSManager().GetRender().debug_level = level;
Emu.GetGSManager().GetRender().m_debug_level = level;
break;
default: return CELL_EINVAL;
@ -438,16 +438,16 @@ s32 cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height
return CELL_EINVAL;
}
auto buffers = Emu.GetGSManager().GetRender().gcm_buffers;
auto buffers = vm::get_ptr<CellGcmDisplayInfo>(Emu.GetGSManager().GetRender().m_gcm_buffers_addr);
buffers[id].offset = offset;
buffers[id].pitch = pitch;
buffers[id].width = width;
buffers[id].height = height;
if (id + 1 > Emu.GetGSManager().GetRender().gcm_buffers_count)
if (id + 1 > Emu.GetGSManager().GetRender().m_gcm_buffers_count)
{
Emu.GetGSManager().GetRender().gcm_buffers_count = id + 1;
Emu.GetGSManager().GetRender().m_gcm_buffers_count = id + 1;
}
return CELL_OK;
@ -457,7 +457,7 @@ void cellGcmSetFlipHandler(vm::ptr<void(u32)> handler)
{
cellGcmSys.Warning("cellGcmSetFlipHandler(handler=*0x%x)", handler);
Emu.GetGSManager().GetRender().flip_handler = handler;
Emu.GetGSManager().GetRender().m_flip_handler = handler;
}
s32 cellGcmSetFlipMode(u32 mode)
@ -469,7 +469,7 @@ s32 cellGcmSetFlipMode(u32 mode)
case CELL_GCM_DISPLAY_HSYNC:
case CELL_GCM_DISPLAY_VSYNC:
case CELL_GCM_DISPLAY_HSYNC_WITH_NOISE:
Emu.GetGSManager().GetRender().flip_mode = mode;
Emu.GetGSManager().GetRender().m_flip_mode = mode;
break;
default:
@ -483,7 +483,7 @@ void cellGcmSetFlipStatus()
{
cellGcmSys.Warning("cellGcmSetFlipStatus()");
Emu.GetGSManager().GetRender().flip_status = 0;
Emu.GetGSManager().GetRender().m_flip_status = 0;
}
s32 cellGcmSetPrepareFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> ctxt, u32 id)
@ -504,23 +504,14 @@ s32 cellGcmSetPrepareFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> ctxt, u32
return res;
}
}
#ifdef __GNUC__
//gcc internal compiler error, try to avoid it for now
*ctxt->current++ = (GCM_FLIP_COMMAND << 2) | (1 << 18);
*ctxt->current++ = 0x3fead | (1 << 18);
*ctxt->current++ = id;
if (ctxt.addr() == gcm_info.context_addr)
{
vm::get_ref<CellGcmControl>(gcm_info.control_addr).put += 2 * sizeof(u32);
vm::get_ref<CellGcmControl>(gcm_info.control_addr).put += 8;
}
#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;
}
@ -544,11 +535,11 @@ s32 cellGcmSetSecondVFrequency(u32 freq)
switch (freq)
{
case CELL_GCM_DISPLAY_FREQUENCY_59_94HZ:
Emu.GetGSManager().GetRender().frequency_mode = freq; Emu.GetGSManager().GetRender().fps_limit = 59.94; break;
Emu.GetGSManager().GetRender().m_frequency_mode = freq; Emu.GetGSManager().GetRender().m_fps_limit = 59.94; break;
case CELL_GCM_DISPLAY_FREQUENCY_SCANOUT:
Emu.GetGSManager().GetRender().frequency_mode = freq; cellGcmSys.Todo("Unimplemented display frequency: Scanout"); break;
Emu.GetGSManager().GetRender().m_frequency_mode = freq; cellGcmSys.Todo("Unimplemented display frequency: Scanout"); break;
case CELL_GCM_DISPLAY_FREQUENCY_DISABLE:
Emu.GetGSManager().GetRender().frequency_mode = freq; cellGcmSys.Todo("Unimplemented display frequency: Disabled"); break;
Emu.GetGSManager().GetRender().m_frequency_mode = freq; cellGcmSys.Todo("Unimplemented display frequency: Disabled"); break;
default: cellGcmSys.Error("Improper display frequency specified!"); return CELL_OK;
}
@ -560,7 +551,7 @@ s32 cellGcmSetTileInfo(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u
cellGcmSys.Warning("cellGcmSetTileInfo(index=%d, location=%d, offset=%d, size=%d, pitch=%d, comp=%d, base=%d, bank=%d)",
index, location, offset, size, pitch, comp, base, bank);
if (index >= rsx::limits::tiles_count || base >= 800 || bank >= 4)
if (index >= RSXThread::m_tiles_count || base >= 800 || bank >= 4)
{
cellGcmSys.Error("cellGcmSetTileInfo: CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
@ -583,16 +574,16 @@ s32 cellGcmSetTileInfo(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u
cellGcmSys.Error("cellGcmSetTileInfo: bad compression mode! (%d)", comp);
}
auto& tile = Emu.GetGSManager().GetRender().tiles[index];
tile.location = location;
tile.offset = offset;
tile.size = size;
tile.pitch = pitch;
tile.comp = comp;
tile.base = base;
tile.bank = bank;
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index];
tile.m_location = location;
tile.m_offset = offset;
tile.m_size = size;
tile.m_pitch = pitch;
tile.m_comp = comp;
tile.m_base = base;
tile.m_bank = bank;
vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().tiles_addr)[index] = tile.pack();
vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().m_tiles_addr)[index] = tile.Pack();
return CELL_OK;
}
@ -600,7 +591,7 @@ void cellGcmSetUserHandler(vm::ptr<void(u32)> handler)
{
cellGcmSys.Warning("cellGcmSetUserHandler(handler=*0x%x)", handler);
Emu.GetGSManager().GetRender().user_handler = handler;
Emu.GetGSManager().GetRender().m_user_handler = handler;
}
s32 cellGcmSetUserCommand()
@ -612,7 +603,7 @@ void cellGcmSetVBlankHandler(vm::ptr<void(u32)> handler)
{
cellGcmSys.Warning("cellGcmSetVBlankHandler(handler=*0x%x)", handler);
Emu.GetGSManager().GetRender().vblank_handler = handler;
Emu.GetGSManager().GetRender().m_vblank_handler = handler;
}
s32 cellGcmSetWaitFlip(vm::ptr<CellGcmContextData> ctxt)
@ -634,26 +625,26 @@ s32 cellGcmSetZcull(u8 index, u32 offset, u32 width, u32 height, u32 cullStart,
cellGcmSys.Todo("cellGcmSetZcull(index=%d, offset=0x%x, width=%d, height=%d, cullStart=0x%x, zFormat=0x%x, aaFormat=0x%x, zCullDir=0x%x, zCullFormat=0x%x, sFunc=0x%x, sRef=0x%x, sMask=0x%x)",
index, offset, width, height, cullStart, zFormat, aaFormat, zCullDir, zCullFormat, sFunc, sRef, sMask);
if (index >= rsx::limits::zculls_count)
if (index >= RSXThread::m_zculls_count)
{
cellGcmSys.Error("cellGcmSetZcull: CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
auto& zcull = Emu.GetGSManager().GetRender().zculls[index];
zcull.offset = offset;
zcull.width = width;
zcull.height = height;
zcull.cullStart = cullStart;
zcull.zFormat = zFormat;
zcull.aaFormat = aaFormat;
zcull.zcullDir = zCullDir;
zcull.zcullFormat = zCullFormat;
zcull.sFunc = sFunc;
zcull.sRef = sRef;
zcull.sMask = sMask;
auto& zcull = Emu.GetGSManager().GetRender().m_zculls[index];
zcull.m_offset = offset;
zcull.m_width = width;
zcull.m_height = height;
zcull.m_cullStart = cullStart;
zcull.m_zFormat = zFormat;
zcull.m_aaFormat = aaFormat;
zcull.m_zcullDir = zCullDir;
zcull.m_zcullFormat = zCullFormat;
zcull.m_sFunc = sFunc;
zcull.m_sRef = sRef;
zcull.m_sMask = sMask;
vm::get_ptr<CellGcmZcullInfo>(Emu.GetGSManager().GetRender().zculls_addr)[index] = zcull.pack();
vm::get_ptr<CellGcmZcullInfo>(Emu.GetGSManager().GetRender().m_zculls_addr)[index] = zcull.Pack();
return CELL_OK;
}
@ -661,14 +652,14 @@ s32 cellGcmUnbindTile(u8 index)
{
cellGcmSys.Warning("cellGcmUnbindTile(index=%d)", index);
if (index >= rsx::limits::tiles_count)
if (index >= RSXThread::m_tiles_count)
{
cellGcmSys.Error("cellGcmUnbindTile: CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
}
auto& tile = Emu.GetGSManager().GetRender().tiles[index];
tile.binded = false;
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index];
tile.m_binded = false;
return CELL_OK;
}
@ -683,8 +674,8 @@ s32 cellGcmUnbindZcull(u8 index)
return CELL_EINVAL;
}
auto& zcull = Emu.GetGSManager().GetRender().zculls[index];
zcull.binded = false;
auto& zcull = Emu.GetGSManager().GetRender().m_zculls[index];
zcull.m_binded = false;
return CELL_OK;
}
@ -692,31 +683,31 @@ s32 cellGcmUnbindZcull(u8 index)
u32 cellGcmGetTileInfo()
{
cellGcmSys.Warning("cellGcmGetTileInfo()");
return Emu.GetGSManager().GetRender().tiles_addr;
return Emu.GetGSManager().GetRender().m_tiles_addr;
}
u32 cellGcmGetZcullInfo()
{
cellGcmSys.Warning("cellGcmGetZcullInfo()");
return Emu.GetGSManager().GetRender().zculls_addr;
return Emu.GetGSManager().GetRender().m_zculls_addr;
}
u32 cellGcmGetDisplayInfo()
{
cellGcmSys.Warning("cellGcmGetDisplayInfo() = 0x%x", Emu.GetGSManager().GetRender().gcm_buffers.addr());
return Emu.GetGSManager().GetRender().gcm_buffers.addr();
cellGcmSys.Warning("cellGcmGetDisplayInfo() = 0x%x", Emu.GetGSManager().GetRender().m_gcm_buffers_addr);
return Emu.GetGSManager().GetRender().m_gcm_buffers_addr;
}
s32 cellGcmGetCurrentDisplayBufferId(vm::ptr<u8> id)
{
cellGcmSys.Warning("cellGcmGetCurrentDisplayBufferId(id=*0x%x)", id);
if (Emu.GetGSManager().GetRender().gcm_current_buffer > UINT8_MAX)
if (Emu.GetGSManager().GetRender().m_gcm_current_buffer > UINT8_MAX)
{
throw EXCEPTION("Unexpected");
}
*id = Emu.GetGSManager().GetRender().gcm_current_buffer;
*id = Emu.GetGSManager().GetRender().m_gcm_current_buffer;
return CELL_OK;
}
@ -748,7 +739,7 @@ u64 cellGcmGetLastFlipTime()
{
cellGcmSys.Log("cellGcmGetLastFlipTime()");
return Emu.GetGSManager().GetRender().last_flip_time;
return Emu.GetGSManager().GetRender().m_last_flip_time;
}
u64 cellGcmGetLastSecondVTime()
@ -761,7 +752,7 @@ u64 cellGcmGetVBlankCount()
{
cellGcmSys.Log("cellGcmGetVBlankCount()");
return Emu.GetGSManager().GetRender().vblank_count;
return Emu.GetGSManager().GetRender().m_vblank_count;
}
s32 cellGcmSysGetLastVBlankTime()
@ -904,7 +895,7 @@ s32 gcmMapEaIoAddress(u32 ea, u32 io, u32 size, bool is_strict)
{
offsetTable.ioAddress[(ea >> 20) + i] = (io >> 20) + i;
offsetTable.eaAddress[(io >> 20) + i] = (ea >> 20) + i;
Emu.GetGSManager().GetRender().strict_ordering[(io >> 20) + i] = is_strict;
Emu.GetGSManager().GetRender().m_strict_ordering[(io >> 20) + i] = is_strict;
}
}
else
@ -966,7 +957,7 @@ s32 cellGcmMapMainMemory(u32 ea, u32 size, vm::ptr<u32> offset)
{
offsetTable.ioAddress[(ea >> 20) + i] = (u16)((io >> 20) + i);
offsetTable.eaAddress[(io >> 20) + i] = (u16)((ea >> 20) + i);
Emu.GetGSManager().GetRender().strict_ordering[(io >> 20) + i] = false;
Emu.GetGSManager().GetRender().m_strict_ordering[(io >> 20) + i] = false;
}
*offset = io;
@ -977,7 +968,7 @@ s32 cellGcmMapMainMemory(u32 ea, u32 size, vm::ptr<u32> offset)
return CELL_GCM_ERROR_NO_IO_PAGE_TABLE;
}
Emu.GetGSManager().GetRender().main_mem_addr = Emu.GetGSManager().GetRender().ioAddress;
Emu.GetGSManager().GetRender().m_main_mem_addr = Emu.GetGSManager().GetRender().m_ioAddress;
return CELL_OK;
}
@ -1117,7 +1108,7 @@ s32 cellGcmSetCursorImageOffset(u32 offset)
void cellGcmSetDefaultCommandBuffer()
{
cellGcmSys.Warning("cellGcmSetDefaultCommandBuffer()");
vm::write32(Emu.GetGSManager().GetRender().ctxt_addr, gcm_info.context_addr);
vm::write32(Emu.GetGSManager().GetRender().m_ctxt_addr, gcm_info.context_addr);
}
s32 cellGcmSetDefaultCommandBufferAndSegmentWordSize()
@ -1151,7 +1142,7 @@ s32 cellGcmSetTile(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u8 co
index, location, offset, size, pitch, comp, base, bank);
// Copied form cellGcmSetTileInfo
if (index >= rsx::limits::tiles_count || base >= 800 || bank >= 4)
if (index >= RSXThread::m_tiles_count || base >= 800 || bank >= 4)
{
cellGcmSys.Error("cellGcmSetTile: CELL_GCM_ERROR_INVALID_VALUE");
return CELL_GCM_ERROR_INVALID_VALUE;
@ -1174,16 +1165,16 @@ s32 cellGcmSetTile(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u8 co
cellGcmSys.Error("cellGcmSetTile: bad compression mode! (%d)", comp);
}
auto& tile = Emu.GetGSManager().GetRender().tiles[index];
tile.location = location;
tile.offset = offset;
tile.size = size;
tile.pitch = pitch;
tile.comp = comp;
tile.base = base;
tile.bank = bank;
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index];
tile.m_location = location;
tile.m_offset = offset;
tile.m_size = size;
tile.m_pitch = pitch;
tile.m_comp = comp;
tile.m_base = base;
tile.m_bank = bank;
vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().tiles_addr)[index] = tile.pack();
vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().m_tiles_addr)[index] = tile.Pack();
return CELL_OK;
}

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

@ -467,7 +467,7 @@ void InitMembers()
void SetupRsxRenderingStates(vm::ptr<CellGcmContextData>& cntxt)
{
//TODO: use cntxt
/*GSRender& r = Emu.GetGSManager().GetRender();
GSRender& r = Emu.GetGSManager().GetRender();
r.m_set_color_mask = true; r.m_color_mask_a = r.m_color_mask_r = r.m_color_mask_g = r.m_color_mask_b = true;
r.m_set_depth_mask = true; r.m_depth_mask = 0;
r.m_set_alpha_test = false;
@ -502,7 +502,7 @@ void SetupRsxRenderingStates(vm::ptr<CellGcmContextData>& cntxt)
r.m_height = s_rescInternalInstance->m_dstHeight;
r.m_surface_depth_format = 2;
r.m_surface_color_target = 1;*/
r.m_surface_color_target = 1;
if (IsPalInterpolate())
{
@ -536,32 +536,32 @@ void SetupSurfaces(vm::ptr<CellGcmContextData>& cntxt)
dstOffset1 = s_rescInternalInstance->m_dstOffsets[s_rescInternalInstance->m_bufIdPalMidNow];
}
//GSRender& r = Emu.GetGSManager().GetRender();
GSRender& r = Emu.GetGSManager().GetRender();
//r.m_surface_type = CELL_GCM_SURFACE_PITCH;
//r.m_surface_antialias = CELL_GCM_SURFACE_CENTER_1;
//r.m_surface_color_format = (u8)s_rescInternalInstance->m_pRescDsts->format;
//r.m_surface_color_target = (!isMrt) ? CELL_GCM_SURFACE_TARGET_0 : CELL_GCM_SURFACE_TARGET_MRT1;
////surface.colorLocation[0] = CELL_GCM_LOCATION_LOCAL;
//r.m_surface_offset_a = dstOffset0;
//r.m_surface_pitch_a = s_rescInternalInstance->m_dstPitch;
////surface.colorLocation[1] = CELL_GCM_LOCATION_LOCAL;
//r.m_surface_offset_b = (!isMrt) ? 0 : dstOffset1;
//r.m_surface_pitch_b = (!isMrt) ? 64 : s_rescInternalInstance->m_dstPitch;
////surface.colorLocation[2] = CELL_GCM_LOCATION_LOCAL;
//r.m_surface_offset_c = 0;
//r.m_surface_pitch_c = 64;
////surface.colorLocation[3] = CELL_GCM_LOCATION_LOCAL;
//r.m_surface_offset_d = 0;
//r.m_surface_pitch_d = 64;
//r.m_surface_depth_format = CELL_GCM_SURFACE_Z24S8;
////surface.depthLocation = CELL_GCM_LOCATION_LOCAL;
//r.m_surface_offset_z = 0;
//r.m_surface_pitch_z = 64;
//r.m_surface_width = s_rescInternalInstance->m_dstWidth;
//r.m_surface_height = s_rescInternalInstance->m_dstHeight;
//r.m_surface_clip_x = 0;
//r.m_surface_clip_y = 0;
r.m_surface_type = CELL_GCM_SURFACE_PITCH;
r.m_surface_antialias = CELL_GCM_SURFACE_CENTER_1;
r.m_surface_color_format = (u8)s_rescInternalInstance->m_pRescDsts->format;
r.m_surface_color_target = (!isMrt) ? CELL_GCM_SURFACE_TARGET_0 : CELL_GCM_SURFACE_TARGET_MRT1;
//surface.colorLocation[0] = CELL_GCM_LOCATION_LOCAL;
r.m_surface_offset_a = dstOffset0;
r.m_surface_pitch_a = s_rescInternalInstance->m_dstPitch;
//surface.colorLocation[1] = CELL_GCM_LOCATION_LOCAL;
r.m_surface_offset_b = (!isMrt) ? 0 : dstOffset1;
r.m_surface_pitch_b = (!isMrt) ? 64 : s_rescInternalInstance->m_dstPitch;
//surface.colorLocation[2] = CELL_GCM_LOCATION_LOCAL;
r.m_surface_offset_c = 0;
r.m_surface_pitch_c = 64;
//surface.colorLocation[3] = CELL_GCM_LOCATION_LOCAL;
r.m_surface_offset_d = 0;
r.m_surface_pitch_d = 64;
r.m_surface_depth_format = CELL_GCM_SURFACE_Z24S8;
//surface.depthLocation = CELL_GCM_LOCATION_LOCAL;
r.m_surface_offset_z = 0;
r.m_surface_pitch_z = 64;
r.m_surface_width = s_rescInternalInstance->m_dstWidth;
r.m_surface_height = s_rescInternalInstance->m_dstHeight;
r.m_surface_clip_x = 0;
r.m_surface_clip_y = 0;
}
// Module<> Functions
@ -1075,21 +1075,21 @@ void cellRescSetFlipHandler(vm::ptr<void(u32)> handler)
{
cellResc.Warning("cellRescSetFlipHandler(handler=*0x%x)", handler);
Emu.GetGSManager().GetRender().flip_handler = handler;
Emu.GetGSManager().GetRender().m_flip_handler = handler;
}
void cellRescResetFlipStatus()
{
cellResc.Log("cellRescResetFlipStatus()");
Emu.GetGSManager().GetRender().flip_status = 1;
Emu.GetGSManager().GetRender().m_flip_status = 1;
}
s32 cellRescGetFlipStatus()
{
cellResc.Log("cellRescGetFlipStatus()");
return Emu.GetGSManager().GetRender().flip_status;
return Emu.GetGSManager().GetRender().m_flip_status;
}
s32 cellRescGetRegisterCount()
@ -1102,7 +1102,7 @@ u64 cellRescGetLastFlipTime()
{
cellResc.Log("cellRescGetLastFlipTime()");
return Emu.GetGSManager().GetRender().last_flip_time;
return Emu.GetGSManager().GetRender().m_last_flip_time;
}
s32 cellRescSetRegisterCount()
@ -1115,7 +1115,7 @@ void cellRescSetVBlankHandler(vm::ptr<void(u32)> handler)
{
cellResc.Warning("cellRescSetVBlankHandler(handler=*0x%x)", handler);
Emu.GetGSManager().GetRender().vblank_handler = handler;
Emu.GetGSManager().GetRender().m_vblank_handler = handler;
}
u16 FloatToHalf(float val)
@ -1142,7 +1142,7 @@ u16 FloatToHalf(float val)
return ((s >> 16) & 0x8000) | ((e << 10) & 0x7c00) | ((m >> 13) & 0x03ff);
}
static void blackman(float (&window)[4])
static void blackman(float window[])
{
const float x0 = ((1.f * 2.f*PI) / 5.f) - PI;
const float x1 = ((2.f * 2.f*PI) / 5.f) - PI;

3
rpcs3/Emu/System.cpp
View file

@ -215,8 +215,7 @@ 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 Buffers: %s", Ini.GSReadColorBuffers.GetValue() ? "Yes" : "No");
LOG_NOTICE(LOADER, "Read Depth Buffer: %s", Ini.GSReadDepthBuffer.GetValue() ? "Yes" : "No");
LOG_NOTICE(LOADER, "Read Color Buffer: %s", Ini.GSReadColorBuffer.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,10 +3,6 @@
#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;
@ -15,7 +11,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>(frame_type)> get_gs_frame;
std::function<std::unique_ptr<class GSFrameBase>()> get_gs_frame;
std::function<std::unique_ptr<class MsgDialogBase>()> get_msg_dialog;
std::function<std::unique_ptr<class SaveDialogBase>()> get_save_dialog;
};

103
rpcs3/Gui/D3DGSFrame.cpp Normal file
View file

@ -0,0 +1,103 @@
#include "stdafx_gui.h"
#if defined(DX12_SUPPORT)
#include "Emu/Memory/Memory.h"
#include "Emu/System.h"
#include "D3DGSFrame.h"
#include "Utilities/Timer.h"
D3DGSFrame::D3DGSFrame()
: GSFrame(nullptr, "GSFrame[DirectX 12]")
, m_frames(0)
{
SetIcon(wxICON(frame_icon));
canvas = new wxWindow(this, wxID_ANY);
canvas->SetSize(GetClientSize());
canvas->Bind(wxEVT_LEFT_DCLICK, &GSFrame::OnLeftDclick, this);
}
D3DGSFrame::~D3DGSFrame()
{
}
void D3DGSFrame::Close()
{
GSFrame::Close();
}
bool D3DGSFrame::IsShown()
{
return GSFrame::IsShown();
}
void D3DGSFrame::Hide()
{
GSFrame::Hide();
}
void D3DGSFrame::Show()
{
GSFrame::Show();
}
void* D3DGSFrame::GetNewContext()
{
return nullptr;//new wxGLContext(GetCanvas());
}
void D3DGSFrame::SetCurrent(void* ctx)
{
// GetCanvas()->SetCurrent(*(wxGLContext*)ctx);
}
void D3DGSFrame::DeleteContext(void* ctx)
{
// delete (wxGLContext*)ctx;
}
void D3DGSFrame::Flip(void* context)
{
if (!canvas) return;
// canvas->SetCurrent(*(wxGLContext*)context);
static Timer fps_t;
// canvas->SwapBuffers();
m_frames++;
const std::string sub_title = Emu.GetTitle() + (Emu.GetTitleID().length() ? " [" + Emu.GetTitleID() + "] | " : " | ") + " | ";
if (fps_t.GetElapsedTimeInSec() >= 0.5)
{
// can freeze on exit
SetTitle(wxString(sub_title.c_str(), wxConvUTF8) + wxString::Format("FPS: %.2f", (double)m_frames / fps_t.GetElapsedTimeInSec()));
m_frames = 0;
fps_t.Start();
}
}
void D3DGSFrame::OnSize(wxSizeEvent& event)
{
if (canvas) canvas->SetSize(GetClientSize());
event.Skip();
}
void D3DGSFrame::SetViewport(int x, int y, u32 w, u32 h)
{
/*
//ConLog.Warning("SetViewport(x=%d, y=%d, w=%d, h=%d)", x, y, w, h);
const wxSize client = GetClientSize();
const wxSize viewport = AspectRatio(client, wxSize(w, h));
const int vx = (client.GetX() - viewport.GetX()) / 2;
const int vy = (client.GetY() - viewport.GetY()) / 2;
glViewport(vx + x, vy + y, viewport.GetWidth(), viewport.GetHeight());
*/
}
HWND D3DGSFrame::getHandle() const
{
return canvas->GetHandle();
}
#endif

36
rpcs3/Gui/D3DGSFrame.h Normal file
View file

@ -0,0 +1,36 @@
#pragma once
#if defined(DX12_SUPPORT)
#include "Emu/RSX/D3D12/D3D12GSRender.h"
#include "Gui/GSFrame.h"
#include "wx/window.h"
struct D3DGSFrame : public GSFrame, public GSFrameBase2
{
wxWindow* canvas;
u32 m_frames;
D3DGSFrame();
~D3DGSFrame();
virtual void Close() override;
virtual bool IsShown() override;
virtual void Hide() override;
virtual void Show() override;
virtual void* GetNewContext() override;
virtual void SetCurrent(void* ctx) override;
virtual void DeleteContext(void* ctx) override;
virtual void Flip(void* context) override;
wxWindow* GetCanvas() const { return canvas; }
virtual void SetViewport(int x, int y, u32 w, u32 h) override;
virtual HWND getHandle() const override;
private:
virtual void OnSize(wxSizeEvent& event);
};
#endif

93
rpcs3/Gui/GLGSFrame.cpp
View file

@ -1,43 +1,102 @@
#include "stdafx_gui.h"
#include "Utilities/Log.h"
#include "Emu/Memory/Memory.h"
#include "Emu/System.h"
#include "GLGSFrame.h"
#include "D3DGSFrame.h"
#include "Utilities/Timer.h"
GLGSFrame::GLGSFrame() : GSFrame("OpenGL")
#ifndef _WIN32
#include "frame_icon.xpm"
#endif
GLGSFrame::GLGSFrame()
: GSFrame(nullptr, "GSFrame[OpenGL]")
, m_frames(0)
{
m_canvas = new wxGLCanvas(this, wxID_ANY, NULL);
m_canvas->SetSize(GetClientSize());
SetIcon(wxICON(frame_icon));
canvas = new wxGLCanvas(this, wxID_ANY, NULL);
canvas->SetSize(GetClientSize());
m_canvas->Bind(wxEVT_LEFT_DCLICK, &GSFrame::OnLeftDclick, this);
canvas->Bind(wxEVT_LEFT_DCLICK, &GSFrame::OnLeftDclick, this);
}
void* GLGSFrame::make_context()
GLGSFrame::~GLGSFrame()
{
return new wxGLContext(m_canvas);
}
void GLGSFrame::set_current(draw_context_t ctx)
void GLGSFrame::Close()
{
m_canvas->SetCurrent(*(wxGLContext*)ctx.get());
GSFrame::Close();
}
void GLGSFrame::delete_context(void* ctx)
bool GLGSFrame::IsShown()
{
return GSFrame::IsShown();
}
void GLGSFrame::Hide()
{
GSFrame::Hide();
}
void GLGSFrame::Show()
{
GSFrame::Show();
}
void* GLGSFrame::GetNewContext()
{
return new wxGLContext(GetCanvas());
}
void GLGSFrame::SetCurrent(void* ctx)
{
GetCanvas()->SetCurrent(*(wxGLContext*)ctx);
}
void GLGSFrame::DeleteContext(void* ctx)
{
delete (wxGLContext*)ctx;
}
void GLGSFrame::flip(draw_context_t context)
void GLGSFrame::Flip(void* context)
{
GSFrame::flip(context);
if (!canvas) return;
canvas->SetCurrent(*(wxGLContext*)context);
if (!m_canvas) return;
static Timer fps_t;
canvas->SwapBuffers();
m_frames++;
m_canvas->SetCurrent(*(wxGLContext*)context.get());
m_canvas->SwapBuffers();
const std::string sub_title = Emu.GetTitle() + (Emu.GetTitleID().length() ? " [" + Emu.GetTitleID() + "] | " : " | ");
if (fps_t.GetElapsedTimeInSec() >= 0.5)
{
// can freeze on exit
SetTitle(wxString(sub_title.c_str(), wxConvUTF8) + wxString::Format("FPS: %.2f", (double)m_frames / fps_t.GetElapsedTimeInSec()));
m_frames = 0;
fps_t.Start();
}
}
void GLGSFrame::OnSize(wxSizeEvent& event)
{
if (m_canvas)
m_canvas->SetSize(GetClientSize());
if (canvas) canvas->SetSize(GetClientSize());
event.Skip();
}
void GLGSFrame::SetViewport(int x, int y, u32 w, u32 h)
{
/*
//ConLog.Warning("SetViewport(x=%d, y=%d, w=%d, h=%d)", x, y, w, h);
const wxSize client = GetClientSize();
const wxSize viewport = AspectRatio(client, wxSize(w, h));
const int vx = (client.GetX() - viewport.GetX()) / 2;
const int vy = (client.GetY() - viewport.GetY()) / 2;
glViewport(vx + x, vy + y, viewport.GetWidth(), viewport.GetHeight());
*/
}

26
rpcs3/Gui/GLGSFrame.h
View file

@ -1,18 +1,30 @@
#pragma once
#include "Emu/RSX/GL/GLGSRender.h"
#include "Gui/GSFrame.h"
#include "wx/glcanvas.h"
class GLGSFrame : public GSFrame
struct GLGSFrame : public GSFrame, public GSFrameBase
{
wxGLCanvas* m_canvas;
wxGLCanvas* canvas;
u32 m_frames;
public:
GLGSFrame();
~GLGSFrame();
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;
virtual void Close() override;
virtual bool IsShown() override;
virtual void Hide() override;
virtual void Show() override;
virtual void* GetNewContext() override;
virtual void SetCurrent(void* ctx) override;
virtual void DeleteContext(void* ctx) override;
virtual void Flip(void* context) override;
wxGLCanvas* GetCanvas() const { return canvas; }
virtual void SetViewport(int x, int y, u32 w, u32 h) override;
private:
virtual void OnSize(wxSizeEvent& event);

113
rpcs3/Gui/GSFrame.cpp
View file

@ -3,21 +3,32 @@
#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, "GSFrame[" + title + "]")
wxSize AspectRatio(wxSize rs, const wxSize as)
{
SetIcon(wxICON(frame_icon));
const double aq = (double)as.x / as.y;
const double rq = (double)rs.x / rs.y;
const double q = aq / rq;
if (q > 1.0)
{
rs.y /= q;
}
else if (q < 1.0)
{
rs.x *= q;
}
return rs;
}
GSFrame::GSFrame(wxWindow* parent, const wxString& title) : wxFrame(parent, wxID_ANY, title)
{
CellVideoOutResolution res = ResolutionTable[ResolutionIdToNum(Ini.GSResolution.GetValue())];
SetClientSize(res.width, res.height);
wxGetApp().Bind(wxEVT_KEY_DOWN, &GSFrame::OnKeyDown, this);
@ -34,6 +45,19 @@ 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())
@ -49,72 +73,13 @@ void GSFrame::OnFullScreen()
ShowFullScreen(!IsFullScreen());
}
void GSFrame::close()
/*
void GSFrame::SetSize(int width, int height)
{
wxFrame::Close();
}
bool GSFrame::shown()
{
return wxFrame::IsShown();
}
void GSFrame::hide()
{
wxFrame::Hide();
}
void GSFrame::show()
{
wxFrame::Show();
}
void* GSFrame::handle() const
{
return GetHandle();
}
void* GSFrame::make_context()
{
return nullptr;
}
void GSFrame::set_current(draw_context_t ctx)
{
}
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;
static Timer fps_t;
if (fps_t.GetElapsedTimeInSec() >= 0.5)
{
std::string title = fmt::format("FPS: %.2f", (double)m_frames / fps_t.GetElapsedTimeInSec());
if (!m_title_message.empty())
title += " | " + m_title_message;
if (!Emu.GetTitle().empty())
title += " | " + Emu.GetTitle();
if (!Emu.GetTitleID().empty())
title += " | [" + Emu.GetTitleID() + "]";
// can freeze on exit
SetTitle(wxString(title.c_str(), wxConvUTF8));
m_frames = 0;
fps_t.Start();
}
m_size.SetWidth(width);
m_size.SetHeight(height);
//wxFrame::SetSize(width, height);
OnSize(wxSizeEvent());
}
*/

29
rpcs3/Gui/GSFrame.h
View file

@ -1,34 +1,21 @@
#pragma once
#include "Emu/RSX/GSRender.h"
class GSFrame : public wxFrame, public GSFrameBase
wxSize AspectRatio(wxSize rs, const wxSize as);
class GSFrame : public wxFrame
{
u64 m_frames;
public:
GSFrame(const wxString& title);
protected:
GSFrame(wxWindow* parent, const wxString& title);
virtual void SetViewport(int x, int y, u32 w, u32 h) {}
virtual void OnPaint(wxPaintEvent& event);
virtual void OnClose(wxCloseEvent& event);
//virtual void OnSize(wxSizeEvent&);
void OnKeyDown(wxKeyEvent& event);
void OnFullScreen();
void close() override;
bool shown() override;
void hide() override;
void show() override;
void* handle() const 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;
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))

91
rpcs3/Gui/RSXDebugger.cpp
View file

@ -1,13 +1,11 @@
#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"
@ -271,7 +269,7 @@ void RSXDebugger::OnScrollMemory(wxMouseEvent& event)
u32 offset;
if(vm::check_addr(m_addr))
{
u32 cmd = vm::ps3::read32(m_addr);
u32 cmd = vm::read32(m_addr);
u32 count = (cmd & (CELL_GCM_METHOD_FLAG_JUMP | CELL_GCM_METHOD_FLAG_CALL))
|| cmd == CELL_GCM_METHOD_FLAG_RETURN ? 0 : (cmd >> 18) & 0x7ff;
@ -298,7 +296,7 @@ void RSXDebugger::OnClickBuffer(wxMouseEvent& event)
{
if (!RSXReady()) return;
const GSRender& render = Emu.GetGSManager().GetRender();
const auto buffers = render.gcm_buffers;
const auto buffers = vm::ptr<CellGcmDisplayInfo>::make(render.m_gcm_buffers_addr);
if(!buffers)
return;
@ -306,7 +304,7 @@ void RSXDebugger::OnClickBuffer(wxMouseEvent& event)
// TODO: Is there any better way to choose the color buffers
#define SHOW_BUFFER(id) \
{ \
u32 addr = render.local_mem_addr + buffers[id].offset; \
u32 addr = render.m_local_mem_addr + buffers[id].offset; \
if (vm::check_addr(addr) && buffers[id].width && buffers[id].height) \
MemoryViewerPanel::ShowImage(this, addr, 3, buffers[id].width, buffers[id].height, true); \
return; \
@ -318,13 +316,13 @@ void RSXDebugger::OnClickBuffer(wxMouseEvent& event)
if (event.GetId() == p_buffer_colorD->GetId()) SHOW_BUFFER(3);
if (event.GetId() == p_buffer_tex->GetId())
{
u8 location = render.textures[m_cur_texture].location();
if(location <= 1 && vm::check_addr(rsx::get_address(render.textures[m_cur_texture].offset(), location))
&& render.textures[m_cur_texture].width() && render.textures[m_cur_texture].height())
u8 location = render.m_textures[m_cur_texture].GetLocation();
if(location <= 1 && vm::check_addr(GetAddress(render.m_textures[m_cur_texture].GetOffset(), location))
&& render.m_textures[m_cur_texture].GetWidth() && render.m_textures[m_cur_texture].GetHeight())
MemoryViewerPanel::ShowImage(this,
rsx::get_address(render.textures[m_cur_texture].offset(), location), 1,
render.textures[m_cur_texture].width(),
render.textures[m_cur_texture].height(), false);
GetAddress(render.m_textures[m_cur_texture].GetOffset(), location), 1,
render.m_textures[m_cur_texture].GetWidth(),
render.m_textures[m_cur_texture].GetHeight(), false);
}
#undef SHOW_BUFFER
@ -333,9 +331,9 @@ void RSXDebugger::OnClickBuffer(wxMouseEvent& event)
void RSXDebugger::GoToGet(wxCommandEvent& event)
{
if (!RSXReady()) return;
//auto ctrl = vm::get_ptr<CellGcmControl>(Emu.GetGSManager().GetRender().ctrlAddress);
auto ctrl = vm::get_ptr<CellGcmControl>(Emu.GetGSManager().GetRender().m_ctrlAddress);
u32 realAddr;
if (RSXIOMem.getRealAddr(0, realAddr)) {
if (RSXIOMem.getRealAddr(ctrl->get.load(), realAddr)) {
m_addr = realAddr;
t_addr->SetValue(wxString::Format("%08x", m_addr));
UpdateInformation();
@ -347,7 +345,7 @@ void RSXDebugger::GoToGet(wxCommandEvent& event)
void RSXDebugger::GoToPut(wxCommandEvent& event)
{
if (!RSXReady()) return;
auto ctrl = Emu.GetGSManager().GetRender().ctrl;
auto ctrl = vm::get_ptr<CellGcmControl>(Emu.GetGSManager().GetRender().m_ctrlAddress);
u32 realAddr;
if (RSXIOMem.getRealAddr(ctrl->put.load(), realAddr)) {
m_addr = realAddr;
@ -385,7 +383,7 @@ void RSXDebugger::GetMemory()
if (isReady && vm::check_addr(addr))
{
u32 cmd = vm::ps3::read32(addr);
u32 cmd = vm::read32(addr);
u32 count = (cmd >> 18) & 0x7ff;
m_list_commands->SetItem(i, 1, wxString::Format("%08x", cmd));
m_list_commands->SetItem(i, 3, wxString::Format("%d", count));
@ -410,13 +408,13 @@ void RSXDebugger::GetBuffers()
// Draw Buffers
// TODO: Currently it only supports color buffers
for (u32 bufferId=0; bufferId < render.gcm_buffers_count; bufferId++)
for (u32 bufferId=0; bufferId < render.m_gcm_buffers_count; bufferId++)
{
if(!vm::check_addr(render.gcm_buffers.addr()))
if(!vm::check_addr(render.m_gcm_buffers_addr))
continue;
auto buffers = render.gcm_buffers;
u32 RSXbuffer_addr = render.local_mem_addr + buffers[bufferId].offset;
auto buffers = vm::get_ptr<CellGcmDisplayInfo>(render.m_gcm_buffers_addr);
u32 RSXbuffer_addr = render.m_local_mem_addr + buffers[bufferId].offset;
if(!vm::check_addr(RSXbuffer_addr))
continue;
@ -455,28 +453,28 @@ void RSXDebugger::GetBuffers()
}
// Draw Texture
if(!render.textures[m_cur_texture].enabled())
if(!render.m_textures[m_cur_texture].IsEnabled())
return;
u32 offset = render.textures[m_cur_texture].offset();
u32 offset = render.m_textures[m_cur_texture].GetOffset();
if(!offset)
return;
u8 location = render.textures[m_cur_texture].location();
u8 location = render.m_textures[m_cur_texture].GetLocation();
if(location > 1)
return;
u32 TexBuffer_addr = rsx::get_address(offset, location);
u32 TexBuffer_addr = GetAddress(offset, location);
if(!vm::check_addr(TexBuffer_addr))
return;
unsigned char* TexBuffer = vm::get_ptr<unsigned char>(TexBuffer_addr);
u32 width = render.textures[m_cur_texture].width();
u32 height = render.textures[m_cur_texture].height();
u32 width = render.m_textures[m_cur_texture].GetWidth();
u32 height = render.m_textures[m_cur_texture].GetHeight();
unsigned char* buffer = (unsigned char*)malloc(width * height * 3);
memcpy(buffer, TexBuffer, width * height * 3);
@ -494,7 +492,7 @@ 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", 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);
@ -513,7 +511,6 @@ void RSXDebugger::GetFlags()
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
}
@ -543,7 +540,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
}
@ -554,31 +551,31 @@ void RSXDebugger::GetTexture()
const GSRender& render = Emu.GetGSManager().GetRender();
m_list_texture->DeleteAllItems();
for(uint i=0; i<rsx::limits::textures_count; ++i)
for(uint i=0; i<RSXThread::m_textures_count; ++i)
{
if(render.textures[i].enabled())
if(render.m_textures[i].IsEnabled())
{
m_list_texture->InsertItem(i, wxString::Format("%d", i));
u8 location = render.textures[i].location();
u8 location = render.m_textures[i].GetLocation();
if(location > 1)
{
m_list_texture->SetItem(i, 1,
wxString::Format("Bad address (offset=0x%x, location=%d)", render.textures[i].offset(), location));
wxString::Format("Bad address (offset=0x%x, location=%d)", render.m_textures[i].GetOffset(), location));
}
else
{
m_list_texture->SetItem(i, 1, wxString::Format("0x%x", rsx::get_address(render.textures[i].offset(), location)));
m_list_texture->SetItem(i, 1, wxString::Format("0x%x", GetAddress(render.m_textures[i].GetOffset(), location)));
}
m_list_texture->SetItem(i, 2, render.textures[i].cubemap() ? "True" : "False");
m_list_texture->SetItem(i, 3, wxString::Format("%dD", render.textures[i].dimension()));
m_list_texture->SetItem(i, 4, render.textures[i].enabled() ? "True" : "False");
m_list_texture->SetItem(i, 5, wxString::Format("0x%x", render.textures[i].format()));
m_list_texture->SetItem(i, 6, wxString::Format("0x%x", render.textures[i].mipmap()));
m_list_texture->SetItem(i, 7, wxString::Format("0x%x", render.textures[i].pitch()));
m_list_texture->SetItem(i, 2, render.m_textures[i].isCubemap() ? "True" : "False");
m_list_texture->SetItem(i, 3, wxString::Format("%dD", render.m_textures[i].GetDimension()));
m_list_texture->SetItem(i, 4, render.m_textures[i].IsEnabled() ? "True" : "False");
m_list_texture->SetItem(i, 5, wxString::Format("0x%x", render.m_textures[i].GetFormat()));
m_list_texture->SetItem(i, 6, wxString::Format("0x%x", render.m_textures[i].GetMipmap()));
m_list_texture->SetItem(i, 7, wxString::Format("0x%x", render.m_textures[i].m_pitch));
m_list_texture->SetItem(i, 8, wxString::Format("%dx%d",
render.textures[i].width(),
render.textures[i].height()));
render.m_textures[i].GetWidth(),
render.m_textures[i].GetHeight()));
m_list_texture->SetItemBackgroundColour(i, wxColour(m_cur_texture == i ? "Wheat" : "White"));
}
@ -594,7 +591,7 @@ 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", !(render.m_set_alpha_func) ? "(none)" : wxString::Format("0x%x (%s)",
render.m_alpha_func,
ParseGCMEnum(render.m_alpha_func, CELL_GCM_ENUM)));
@ -644,13 +641,12 @@ void RSXDebugger::GetSettings()
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)
@ -674,7 +670,6 @@ void RSXDebugger::SetFlags(wxListEvent& event)
case 16: render.m_set_scissor_horizontal ^= true; break;
case 17: render.m_set_scissor_vertical ^= true; break;
}
*/
UpdateInformation();
}
@ -837,7 +832,7 @@ wxString RSXDebugger::DisAsmCommand(u32 cmd, u32 count, u32 currentAddr, u32 ioA
}
else if(!(cmd & (CELL_GCM_METHOD_FLAG_JUMP | CELL_GCM_METHOD_FLAG_CALL)) && cmd != CELL_GCM_METHOD_FLAG_RETURN)
{
auto args = vm::ps3::ptr<u32>::make(currentAddr + 4);
auto args = vm::ptr<u32>::make(currentAddr + 4);
u32 index = 0;
switch(cmd & 0x3ffff)
@ -1211,4 +1206,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,6 +2,8 @@
#include <wx/listctrl.h>
class RSXDebugger : public wxFrame
{
u32 m_addr;

12
rpcs3/Gui/SettingsDialog.cpp
View file

@ -118,8 +118,7 @@ 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 Buffers");
wxCheckBox* chbox_gs_read_depth = new wxCheckBox(p_graphics, wxID_ANY, "Read Depth Buffer");
wxCheckBox* chbox_gs_read_color = new wxCheckBox(p_graphics, wxID_ANY, "Read Color 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");
@ -257,8 +256,7 @@ 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.GSReadColorBuffers.GetValue());
chbox_gs_read_depth->SetValue(Ini.GSReadDepthBuffer.GetValue());
chbox_gs_read_color->SetValue(Ini.GSReadColorBuffer.GetValue());
chbox_gs_vsync->SetValue(Ini.GSVSyncEnable.GetValue());
chbox_gs_debug_output->SetValue(Ini.GSDebugOutputEnable.GetValue());
chbox_gs_3dmonitor->SetValue(Ini.GS3DTV.GetValue());
@ -348,10 +346,9 @@ 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());
@ -440,8 +437,7 @@ 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.GSReadColorBuffers.SetValue(chbox_gs_read_color->GetValue());
Ini.GSReadDepthBuffer.SetValue(chbox_gs_read_depth->GetValue());
Ini.GSReadColorBuffer.SetValue(chbox_gs_read_color->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,8 +111,7 @@ public:
IniEntry<bool> GSLogPrograms;
IniEntry<bool> GSDumpColorBuffers;
IniEntry<bool> GSDumpDepthBuffer;
IniEntry<bool> GSReadColorBuffers;
IniEntry<bool> GSReadDepthBuffer;
IniEntry<bool> GSReadColorBuffer;
IniEntry<bool> GSVSyncEnable;
IniEntry<bool> GS3DTV;
IniEntry<bool> GSDebugOutputEnable;
@ -203,17 +202,16 @@ public:
GSLogPrograms.Init("GS_LogPrograms", path);
GSDumpColorBuffers.Init("GS_DumpColorBuffers", path);
GSDumpDepthBuffer.Init("GS_DumpDepthBuffer", path);
GSReadColorBuffers.Init("GS_ReadColorBuffer", path);
GSReadDepthBuffer.Init("GS_ReadDepthBuffer", path);
GSReadColorBuffer.Init("GS_GSReadColorBuffer", 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_OutMode", path);
AudioDumpToFile.Init("Audio_DumpToFile", path);
AudioConvertToU16.Init("Audio_ConvertToU16", path);
AudioOutMode.Init("Audio_AudioOutMode", path);
AudioDumpToFile.Init("Audio_AudioDumpToFile", path);
AudioConvertToU16.Init("Audio_AudioConvertToU16", path);
// Camera
Camera.Init("Camera", path);
@ -291,8 +289,7 @@ public:
GSLogPrograms.Load(false);
GSDumpColorBuffers.Load(false);
GSDumpDepthBuffer.Load(false);
GSReadColorBuffers.Load(false);
GSReadDepthBuffer.Load(false);
GSReadColorBuffer.Load(false);
GSVSyncEnable.Load(false);
GSDebugOutputEnable.Load(false);
GS3DTV.Load(false);
@ -379,8 +376,7 @@ public:
GSLogPrograms.Save();
GSDumpColorBuffers.Save();
GSDumpDepthBuffer.Save();
GSReadColorBuffers.Save();
GSReadDepthBuffer.Save();
GSReadColorBuffer.Save();
GSVSyncEnable.Save();
GSDebugOutputEnable.Save();
GS3DTV.Save();

26
rpcs3/emucore.vcxproj
View file

@ -60,8 +60,10 @@
<ClCompile Include="Emu\IdManager.cpp" />
<ClCompile Include="Emu\RSX\CgBinaryFragmentProgram.cpp" />
<ClCompile Include="Emu\RSX\CgBinaryVertexProgram.cpp" />
<ClCompile Include="Emu\RSX\Common\BufferUtils.cpp" />
<ClCompile Include="Emu\RSX\Common\FragmentProgramDecompiler.cpp" />
<ClCompile Include="Emu\RSX\Common\ShaderParam.cpp" />
<ClCompile Include="Emu\RSX\Common\TextureUtils.cpp" />
<ClCompile Include="Emu\RSX\Common\VertexProgramDecompiler.cpp" />
<ClCompile Include="Emu\RSX\D3D12\D3D12Buffer.cpp" />
<ClCompile Include="Emu\RSX\D3D12\D3D12FragmentProgramDecompiler.cpp" />
@ -74,8 +76,6 @@
<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" />
@ -393,7 +393,6 @@
<ClInclude Include="..\Utilities\StrFmt.h" />
<ClInclude Include="..\Utilities\Thread.h" />
<ClInclude Include="..\Utilities\Timer.h" />
<ClInclude Include="..\Utilities\types.h" />
<ClInclude Include="..\Utilities\VirtualMemory.h" />
<ClInclude Include="Crypto\aes.h" />
<ClInclude Include="Crypto\ec.h" />
@ -532,9 +531,11 @@
<ClInclude Include="Emu\Memory\Memory.h" />
<ClInclude Include="Emu\Memory\MemoryBlock.h" />
<ClInclude Include="Emu\RSX\CgBinaryProgram.h" />
<ClInclude Include="Emu\RSX\Common\BufferUtils.h" />
<ClInclude Include="Emu\RSX\Common\FragmentProgramDecompiler.h" />
<ClInclude Include="Emu\RSX\Common\ProgramStateCache.h" />
<ClInclude Include="Emu\RSX\Common\ShaderParam.h" />
<ClInclude Include="Emu\RSX\Common\TextureUtils.h" />
<ClInclude Include="Emu\RSX\Common\VertexProgramDecompiler.h" />
<ClInclude Include="Emu\RSX\D3D12\D3D12.h" />
<ClInclude Include="Emu\RSX\D3D12\D3D12Buffer.h" />
@ -555,7 +556,6 @@
<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" />
@ -770,55 +770,55 @@
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include;..\glm</IncludePath>
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include</IncludePath>
<IntDir>$(Platform)\$(Configuration)\emucore\</IntDir>
<LibraryPath>$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<ExcludePath>$(ExcludePath)</ExcludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - DX12|x64'">
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include;..\glm</IncludePath>
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include</IncludePath>
<IntDir>$(Platform)\$(Configuration)\emucore\</IntDir>
<LibraryPath>$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<ExcludePath>$(ExcludePath)</ExcludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include;..\glm</IncludePath>
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include</IncludePath>
<IntDir>$(Platform)\$(Configuration)\emucore\</IntDir>
<LibraryPath>$(LibraryPath)</LibraryPath>
<ExcludePath>$(ExcludePath)</ExcludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM DX12|x64'">
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include;..\glm</IncludePath>
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include</IncludePath>
<IntDir>$(Platform)\$(Configuration)\emucore\</IntDir>
<LibraryPath>$(LibraryPath)</LibraryPath>
<ExcludePath>$(ExcludePath)</ExcludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|x64'">
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include;..\glm</IncludePath>
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include</IncludePath>
<IntDir>$(Platform)\$(Configuration)\emucore\</IntDir>
<LibraryPath>$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<ExcludePath>$(ExcludePath)</ExcludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include;..\glm</IncludePath>
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include</IncludePath>
<IntDir>$(Platform)\$(Configuration)\emucore\</IntDir>
<LibraryPath>$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<ExcludePath>$(ExcludePath)</ExcludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release - DX12|x64'">
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include;..\glm</IncludePath>
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include</IncludePath>
<IntDir>$(Platform)\$(Configuration)\emucore\</IntDir>
<LibraryPath>$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<ExcludePath>$(ExcludePath)</ExcludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include;..\glm</IncludePath>
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include</IncludePath>
<IntDir>$(Platform)\$(Configuration)\emucore\</IntDir>
<LibraryPath>$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<ExcludePath>$(ExcludePath)</ExcludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release - LLVM DX12|x64'">
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include;..\glm</IncludePath>
<IncludePath>.\;..\;..\asmjit\src\asmjit;..\wxWidgets\include\msvc;..\wxWidgets\include;.\OpenAL\include;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;$(VC_IncludePath);$(WindowsSDK_IncludePath);..\llvm\include;..\llvm_build\include;$(UniversalCRT_IncludePath);..\minidx9\Include</IncludePath>
<IntDir>$(Platform)\$(Configuration)\emucore\</IntDir>
<LibraryPath>$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<ExcludePath>$(ExcludePath)</ExcludePath>

16
rpcs3/emucore.vcxproj.filters
View file

@ -989,11 +989,11 @@
<ClCompile Include="..\Utilities\SharedMutex.cpp">
<Filter>Utilities</Filter>
</ClCompile>
<ClCompile Include="Emu\RSX\GL\gl_helpers.cpp">
<Filter>Emu\GPU\RSX\GL</Filter>
<ClCompile Include="Emu\RSX\Common\TextureUtils.cpp">
<Filter>Emu\GPU\RSX\Common</Filter>
</ClCompile>
<ClCompile Include="Emu\RSX\Null\NullGSRender.cpp">
<Filter>Emu\GPU\RSX\Null</Filter>
<ClCompile Include="Emu\RSX\Common\BufferUtils.cpp">
<Filter>Emu\GPU\RSX\Common</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
@ -1888,11 +1888,11 @@
<ClInclude Include="Emu\RSX\D3D12\d3dx12.h">
<Filter>Emu\GPU\RSX\D3D12</Filter>
</ClInclude>
<ClInclude Include="Emu\RSX\GL\gl_helpers.h">
<Filter>Emu\GPU\RSX\GL</Filter>
<ClInclude Include="Emu\RSX\Common\TextureUtils.h">
<Filter>Emu\GPU\RSX\Common</Filter>
</ClInclude>
<ClInclude Include="..\Utilities\types.h">
<Filter>Utilities</Filter>
<ClInclude Include="Emu\RSX\Common\BufferUtils.h">
<Filter>Emu\GPU\RSX\Common</Filter>
</ClInclude>
</ItemGroup>
</Project>

23
rpcs3/rpcs3.cpp
View file

@ -26,6 +26,7 @@
#include "Gui/SaveDataDialog.h"
#include "Gui/GLGSFrame.h"
#include "Gui/D3DGSFrame.h"
#include <wx/stdpaths.h>
#ifdef _WIN32
@ -111,21 +112,19 @@ bool Rpcs3App::OnInit()
}
};
callbacks.get_gs_frame = [](frame_type type) -> std::unique_ptr<GSFrameBase>
callbacks.get_gs_frame = []() -> std::unique_ptr<GSFrameBase>
{
switch (type)
{
case frame_type::OpenGL:
return std::make_unique<GLGSFrame>();
case frame_type::DX12:
return std::make_unique<GSFrame>("DirectX 12");
case frame_type::Null:
return std::make_unique<GSFrame>("Null");
}
return std::make_unique<GLGSFrame>();
};
// TODO: unify with get_gs_frame callback
#if defined(DX12_SUPPORT)
SetGetD3DGSFrameCallback([]() ->GSFrameBase2*
{
return new D3DGSFrame();
});
#endif
callbacks.get_msg_dialog = []() -> std::unique_ptr<MsgDialogBase>
{
return std::make_unique<MsgDialogFrame>();

20
rpcs3/rpcs3.vcxproj
View file

@ -139,38 +139,38 @@
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath);..\glm</IncludePath>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath)</IncludePath>
<OutDir>$(SolutionDir)bin\</OutDir>
<LibraryPath>..\libs\$(Configuration)\;$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<TargetName>$(ProjectName)-dbg</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath);..\glm</IncludePath>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath)</IncludePath>
<OutDir>$(SolutionDir)bin\</OutDir>
<LibraryPath>..\libs\$(Configuration)\;$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<TargetName>$(ProjectName)-dbg</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - DX12|x64'">
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath);..\glm</IncludePath>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath)</IncludePath>
<OutDir>$(SolutionDir)bin\</OutDir>
<LibraryPath>..\libs\Debug\;$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<TargetName>$(ProjectName)-dbg</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM DX12|x64'">
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath);..\glm</IncludePath>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath)</IncludePath>
<OutDir>$(SolutionDir)bin\</OutDir>
<LibraryPath>..\libs\Debug\;$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<TargetName>$(ProjectName)-dbg</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|x64'">
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(UniversalCRT_IncludePath);$(IncludePath);..\glm</IncludePath>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(UniversalCRT_IncludePath);$(IncludePath)</IncludePath>
<OutDir>$(SolutionDir)bin\</OutDir>
<LibraryPath>..\libs\Debug\;$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<TargetName>$(ProjectName)-dbg</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath);..\glm</IncludePath>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath)</IncludePath>
<OutDir>$(SolutionDir)bin\</OutDir>
<LibraryPath>..\libs\$(Configuration)\;$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<LinkIncremental>false</LinkIncremental>
@ -178,7 +178,7 @@
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release - LLVM|x64'">
<LinkIncremental>false</LinkIncremental>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath);..\glm</IncludePath>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath)</IncludePath>
<OutDir>$(SolutionDir)bin\</OutDir>
<LibraryPath>..\libs\$(Configuration)\;$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<LinkIncremental>false</LinkIncremental>
@ -186,7 +186,7 @@
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release - DX12|x64'">
<LinkIncremental>false</LinkIncremental>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath);..\glm</IncludePath>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath)</IncludePath>
<OutDir>$(SolutionDir)bin\</OutDir>
<LibraryPath>..\libs\Release\;$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<LinkIncremental>false</LinkIncremental>
@ -194,7 +194,7 @@
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release - LLVM DX12|x64'">
<LinkIncremental>false</LinkIncremental>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath);..\glm</IncludePath>
<IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit;$(UniversalCRT_IncludePath)</IncludePath>
<OutDir>$(SolutionDir)bin\</OutDir>
<LibraryPath>..\libs\Release\;$(UniversalCRT_LibraryPath_x64);$(LibraryPath)</LibraryPath>
<LinkIncremental>false</LinkIncremental>
@ -511,6 +511,7 @@
<ClCompile Include="Gui\CgDisasm.cpp" />
<ClCompile Include="Gui\CompilerELF.cpp" />
<ClCompile Include="Gui\ConLogFrame.cpp" />
<ClCompile Include="Gui\D3DGSFrame.cpp" />
<ClCompile Include="Gui\Debugger.cpp" />
<ClCompile Include="Gui\DisAsmFrame.cpp" />
<ClCompile Include="Gui\GameViewer.cpp" />
@ -560,6 +561,7 @@
<ClInclude Include="Gui\CgDisasm.h" />
<ClInclude Include="Gui\CompilerELF.h" />
<ClInclude Include="Gui\ConLogFrame.h" />
<ClInclude Include="Gui\D3DGSFrame.h" />
<ClInclude Include="Gui\Debugger.h" />
<ClInclude Include="Gui\DisAsmFrame.h" />
<ClInclude Include="Gui\FrameBase.h" />

6
rpcs3/rpcs3.vcxproj.filters
View file

@ -102,6 +102,9 @@
<ClCompile Include="Gui\SaveDataDialog.cpp">
<Filter>Gui</Filter>
</ClCompile>
<ClCompile Include="Gui\D3DGSFrame.cpp">
<Filter>Gui</Filter>
</ClCompile>
<ClCompile Include="Gui\SettingsDialog.cpp">
<Filter>Gui</Filter>
</ClCompile>
@ -213,6 +216,9 @@
<Filter>Gui</Filter>
</ClInclude>
<ClInclude Include="resource.h" />
<ClInclude Include="Gui\D3DGSFrame.h">
<Filter>Gui</Filter>
</ClInclude>
<ClInclude Include="Gui\SettingsDialog.h">
<Filter>Gui</Filter>
</ClInclude>