mirror of
https://github.com/RPCS3/rpcs3.git
synced 2025-03-01 07:13:36 +00:00
Remove m_ prefix on some members of RSXThread
This commit is contained in:
Vincent Lejeune
parent
4cd9e5754e
commit
e3e5b46cbf
@ -145,7 +145,7 @@ std::vector<D3D12_VERTEX_BUFFER_VIEW> D3D12GSRender::UploadVertexBuffers(bool in
|
||||
const std::vector<VertexBufferFormat> &vertexBufferFormat = FormatVertexData(m_vertex_data, m_vertexBufferSize, m_vertex_data_base_offset);
|
||||
m_IASet = getIALayout(m_device.Get(), vertexBufferFormat, m_vertex_data, m_vertex_data_base_offset);
|
||||
|
||||
const u32 data_offset = indexed_draw ? 0 : m_draw_array_first;
|
||||
const u32 data_offset = indexed_draw ? 0 : draw_array_first;
|
||||
|
||||
for (size_t buffer = 0; buffer < vertexBufferFormat.size(); buffer++)
|
||||
{
|
||||
@ -173,11 +173,11 @@ D3D12_INDEX_BUFFER_VIEW D3D12GSRender::uploadIndexBuffers(bool indexed_draw)
|
||||
D3D12_INDEX_BUFFER_VIEW indexBufferView = {};
|
||||
|
||||
// No need for index buffer
|
||||
if (!indexed_draw && isNativePrimitiveMode(m_draw_mode))
|
||||
if (!indexed_draw && isNativePrimitiveMode(draw_mode))
|
||||
{
|
||||
m_renderingInfo.m_indexed = false;
|
||||
m_renderingInfo.m_count = m_draw_array_count;
|
||||
m_renderingInfo.m_baseVertex = m_draw_array_first;
|
||||
m_renderingInfo.m_count = draw_array_count;
|
||||
m_renderingInfo.m_baseVertex = draw_array_first;
|
||||
return indexBufferView;
|
||||
}
|
||||
|
||||
@ -207,11 +207,11 @@ D3D12_INDEX_BUFFER_VIEW D3D12GSRender::uploadIndexBuffers(bool indexed_draw)
|
||||
}
|
||||
|
||||
// Index count
|
||||
m_renderingInfo.m_count = getIndexCount(m_draw_mode, indexed_draw ? (u32)(m_indexed_array.m_data.size() / indexSize) : m_draw_array_count);
|
||||
m_renderingInfo.m_count = getIndexCount(draw_mode, indexed_draw ? (u32)(m_indexed_array.m_data.size() / indexSize) : draw_array_count);
|
||||
|
||||
// Base vertex
|
||||
if (!indexed_draw && isNativePrimitiveMode(m_draw_mode))
|
||||
m_renderingInfo.m_baseVertex = m_draw_array_first;
|
||||
if (!indexed_draw && isNativePrimitiveMode(draw_mode))
|
||||
m_renderingInfo.m_baseVertex = draw_array_first;
|
||||
else
|
||||
m_renderingInfo.m_baseVertex = 0;
|
||||
|
||||
@ -224,7 +224,7 @@ D3D12_INDEX_BUFFER_VIEW D3D12GSRender::uploadIndexBuffers(bool indexed_draw)
|
||||
void *buffer;
|
||||
ThrowIfFailed(m_vertexIndexData.m_heap->Map(0, &CD3DX12_RANGE(heapOffset, heapOffset + subBufferSize), (void**)&buffer));
|
||||
void *bufferMap = (char*)buffer + heapOffset;
|
||||
uploadIndexData(m_draw_mode, m_indexed_array.m_type, indexed_draw ? m_indexed_array.m_data.data() : nullptr, bufferMap, indexed_draw ? (u32)(m_indexed_array.m_data.size() / indexSize) : m_draw_array_count);
|
||||
uploadIndexData(draw_mode, m_indexed_array.m_type, indexed_draw ? m_indexed_array.m_data.data() : nullptr, bufferMap, indexed_draw ? (u32)(m_indexed_array.m_data.size() / indexSize) : draw_array_count);
|
||||
m_vertexIndexData.m_heap->Unmap(0, &CD3DX12_RANGE(heapOffset, heapOffset + subBufferSize));
|
||||
m_timers.m_bufferUploadSize += subBufferSize;
|
||||
indexBufferView.SizeInBytes = (UINT)subBufferSize;
|
||||
|
||||
@ -411,12 +411,12 @@ void D3D12GSRender::Draw()
|
||||
if (!m_vertex_data[i].addr) continue;
|
||||
|
||||
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;
|
||||
m_vertexBufferSize[i] = (draw_array_first + draw_array_count) * tsize * m_vertex_data[i].size;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (m_indexed_array.m_count || m_draw_array_count)
|
||||
if (m_indexed_array.m_count || draw_array_count)
|
||||
{
|
||||
const std::vector<D3D12_VERTEX_BUFFER_VIEW> &vertexBufferViews = UploadVertexBuffers(m_indexed_array.m_count ? true : false);
|
||||
const D3D12_INDEX_BUFFER_VIEW &indexBufferView = uploadIndexBuffers(m_indexed_array.m_count ? true : false);
|
||||
@ -564,7 +564,7 @@ void D3D12GSRender::Draw()
|
||||
};
|
||||
getCurrentResourceStorage().m_commandList->RSSetScissorRects(1, &box);
|
||||
|
||||
switch (m_draw_mode - 1)
|
||||
switch (draw_mode - 1)
|
||||
{
|
||||
case GL_POINTS:
|
||||
getCurrentResourceStorage().m_commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_POINTLIST);
|
||||
@ -647,9 +647,9 @@ void D3D12GSRender::Flip()
|
||||
if (m_read_buffer)
|
||||
{
|
||||
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;
|
||||
u32 addr = GetAddress(buffers[gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL);
|
||||
w = buffers[gcm_current_buffer].width;
|
||||
h = buffers[gcm_current_buffer].height;
|
||||
u8 *src_buffer = vm::get_ptr<u8>(addr);
|
||||
|
||||
rowPitch = align(w * 4, 256);
|
||||
@ -1151,7 +1151,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
|
||||
}
|
||||
}
|
||||
|
||||
vm::ps3::write32(m_label_addr + offset, value);
|
||||
vm::ps3::write32(label_addr + offset, value);
|
||||
}
|
||||
|
||||
void D3D12GSRender::semaphorePFIFOAcquire(u32 offset, u32 value)
|
||||
@ -1159,7 +1159,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(m_label_addr + offset);
|
||||
volatile u32 val = vm::ps3::read32(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();
|
||||
|
||||
@ -70,7 +70,7 @@ bool D3D12GSRender::LoadProgram()
|
||||
}
|
||||
|
||||
D3D12PipelineProperties prop = {};
|
||||
switch (m_draw_mode - 1)
|
||||
switch (draw_mode - 1)
|
||||
{
|
||||
case GL_POINTS:
|
||||
prop.Topology = D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT;
|
||||
|
||||
@ -395,18 +395,18 @@ struct CellGcmTileInfo
|
||||
|
||||
struct GcmZcullInfo
|
||||
{
|
||||
u32 m_offset;
|
||||
u32 m_width;
|
||||
u32 m_height;
|
||||
u32 m_cullStart;
|
||||
u32 m_zFormat;
|
||||
u32 m_aaFormat;
|
||||
u32 m_zcullDir;
|
||||
u32 m_zcullFormat;
|
||||
u32 m_sFunc;
|
||||
u32 m_sRef;
|
||||
u32 m_sMask;
|
||||
bool m_binded;
|
||||
u32 offset;
|
||||
u32 width;
|
||||
u32 height;
|
||||
u32 cullStart;
|
||||
u32 zFormat;
|
||||
u32 aaFormat;
|
||||
u32 zcullDir;
|
||||
u32 zcullFormat;
|
||||
u32 sFunc;
|
||||
u32 sRef;
|
||||
u32 sMask;
|
||||
bool binded;
|
||||
|
||||
GcmZcullInfo()
|
||||
{
|
||||
@ -417,11 +417,11 @@ struct GcmZcullInfo
|
||||
{
|
||||
CellGcmZcullInfo ret;
|
||||
|
||||
ret.region = (1<<0) | (m_zFormat<<4) | (m_aaFormat<<8);
|
||||
ret.size = ((m_width>>6)<<22) | ((m_height>>6)<<6);
|
||||
ret.start = m_cullStart&(~0xFFF);
|
||||
ret.offset = m_offset;
|
||||
ret.status0 = (m_zcullDir<<1) | (m_zcullFormat<<2) | ((m_sFunc&0xF)<<12) | (m_sRef<<16) | (m_sMask<<24);
|
||||
ret.region = (1<<0) | (zFormat<<4) | (aaFormat<<8);
|
||||
ret.size = ((width>>6)<<22) | ((height>>6)<<6);
|
||||
ret.start = cullStart&(~0xFFF);
|
||||
ret.offset = offset;
|
||||
ret.status0 = (zcullDir<<1) | (zcullFormat<<2) | ((sFunc&0xF)<<12) | (sRef<<16) | (sMask<<24);
|
||||
ret.status1 = (0x2000<<0) | (0x20<<16);
|
||||
|
||||
return ret;
|
||||
@ -430,14 +430,14 @@ struct GcmZcullInfo
|
||||
|
||||
struct GcmTileInfo
|
||||
{
|
||||
u8 m_location;
|
||||
u32 m_offset;
|
||||
u32 m_size;
|
||||
u32 m_pitch;
|
||||
u8 m_comp;
|
||||
u16 m_base;
|
||||
u8 m_bank;
|
||||
bool m_binded;
|
||||
u8 location;
|
||||
u32 offset;
|
||||
u32 size;
|
||||
u32 pitch;
|
||||
u8 comp;
|
||||
u16 base;
|
||||
u8 bank;
|
||||
bool binded;
|
||||
|
||||
GcmTileInfo()
|
||||
{
|
||||
@ -448,10 +448,10 @@ struct GcmTileInfo
|
||||
{
|
||||
CellGcmTileInfo ret;
|
||||
|
||||
ret.tile = (m_location + 1) | (m_bank << 4) | ((m_offset / 0x10000) << 16) | (m_location << 31);
|
||||
ret.limit = ((m_offset + m_size - 1) / 0x10000) << 16 | (m_location << 31);
|
||||
ret.pitch = (m_pitch / 0x100) << 8;
|
||||
ret.format = m_base | ((m_base + ((m_size - 1) / 0x10000)) << 13) | (m_comp << 26) | (1 << 30);
|
||||
ret.tile = (location + 1) | (bank << 4) | ((offset / 0x10000) << 16) | (location << 31);
|
||||
ret.limit = ((offset + size - 1) / 0x10000) << 16 | (location << 31);
|
||||
ret.pitch = (pitch / 0x100) << 8;
|
||||
ret.format = base | ((base + ((size - 1) / 0x10000)) << 13) | (comp << 26) | (1 << 30);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -807,7 +807,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
|
||||
static u32 offset_list[m_vertex_count];
|
||||
u32 cur_offset = 0;
|
||||
|
||||
const u32 data_offset = indexed_draw ? 0 : m_draw_array_first;
|
||||
const u32 data_offset = indexed_draw ? 0 : draw_array_first;
|
||||
|
||||
for (u32 i = 0; i < m_vertex_count; ++i)
|
||||
{
|
||||
@ -1567,9 +1567,9 @@ void GLGSRender::InitDrawBuffers()
|
||||
{
|
||||
u32 format = GL_BGRA;
|
||||
CellGcmDisplayInfo* buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr);
|
||||
u32 addr = GetAddress(buffers[m_gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL);
|
||||
u32 width = buffers[m_gcm_current_buffer].width;
|
||||
u32 height = buffers[m_gcm_current_buffer].height;
|
||||
u32 addr = GetAddress(buffers[gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL);
|
||||
u32 width = buffers[gcm_current_buffer].width;
|
||||
u32 height = buffers[gcm_current_buffer].height;
|
||||
glDrawPixels(width, height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, vm::get_ptr(addr));
|
||||
}
|
||||
}
|
||||
@ -1646,7 +1646,7 @@ void GLGSRender::Draw()
|
||||
checkForGlError("glColorMask");
|
||||
}
|
||||
|
||||
if (!m_indexed_array.m_count && !m_draw_array_count)
|
||||
if (!m_indexed_array.m_count && !draw_array_count)
|
||||
{
|
||||
u32 min_vertex_size = ~0;
|
||||
for (auto &i : m_vertex_data)
|
||||
@ -1660,8 +1660,8 @@ void GLGSRender::Draw()
|
||||
min_vertex_size = vertex_size;
|
||||
}
|
||||
|
||||
m_draw_array_count = min_vertex_size;
|
||||
m_draw_array_first = 0;
|
||||
draw_array_count = min_vertex_size;
|
||||
draw_array_first = 0;
|
||||
}
|
||||
|
||||
Enable(m_set_depth_test, GL_DEPTH_TEST);
|
||||
@ -1905,7 +1905,7 @@ void GLGSRender::Draw()
|
||||
checkForGlError("glPrimitiveRestartIndex");
|
||||
}
|
||||
|
||||
if (m_indexed_array.m_count && m_draw_array_count)
|
||||
if (m_indexed_array.m_count && draw_array_count)
|
||||
{
|
||||
LOG_WARNING(RSX, "m_indexed_array.m_count && draw_array_count");
|
||||
}
|
||||
@ -1943,9 +1943,9 @@ void GLGSRender::Draw()
|
||||
if (m_indexed_array.m_count)
|
||||
LoadVertexData(m_indexed_array.index_min, m_indexed_array.index_max - m_indexed_array.index_min + 1);
|
||||
else
|
||||
LoadVertexData(m_draw_array_first, m_draw_array_count);
|
||||
LoadVertexData(draw_array_first, draw_array_count);
|
||||
|
||||
if (m_indexed_array.m_count || m_draw_array_count)
|
||||
if (m_indexed_array.m_count || draw_array_count)
|
||||
{
|
||||
EnableVertexData(m_indexed_array.m_count ? true : false);
|
||||
|
||||
@ -1958,12 +1958,12 @@ void GLGSRender::Draw()
|
||||
switch(m_indexed_array.m_type)
|
||||
{
|
||||
case CELL_GCM_DRAW_INDEX_ARRAY_TYPE_32:
|
||||
glDrawElements(m_draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_INT, nullptr);
|
||||
glDrawElements(draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_INT, nullptr);
|
||||
checkForGlError("glDrawElements #4");
|
||||
break;
|
||||
|
||||
case CELL_GCM_DRAW_INDEX_ARRAY_TYPE_16:
|
||||
glDrawElements(m_draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_SHORT, nullptr);
|
||||
glDrawElements(draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_SHORT, nullptr);
|
||||
checkForGlError("glDrawElements #2");
|
||||
break;
|
||||
|
||||
@ -1976,10 +1976,10 @@ void GLGSRender::Draw()
|
||||
m_indexed_array.Reset();
|
||||
}
|
||||
|
||||
if (m_draw_array_count)
|
||||
if (draw_array_count)
|
||||
{
|
||||
//LOG_WARNING(RSX,"glDrawArrays(%d,%d,%d)", m_draw_mode - 1, m_draw_array_first, m_draw_array_count);
|
||||
glDrawArrays(m_draw_mode - 1, 0, m_draw_array_count);
|
||||
glDrawArrays(draw_mode - 1, 0, draw_array_count);
|
||||
checkForGlError("glDrawArrays");
|
||||
DisableVertexData();
|
||||
}
|
||||
@ -2023,9 +2023,9 @@ void GLGSRender::Flip()
|
||||
{
|
||||
format = GL_BGRA;
|
||||
CellGcmDisplayInfo* buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr);
|
||||
u32 addr = GetAddress(buffers[m_gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL);
|
||||
width = buffers[m_gcm_current_buffer].width;
|
||||
height = buffers[m_gcm_current_buffer].height;
|
||||
u32 addr = GetAddress(buffers[gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL);
|
||||
width = buffers[gcm_current_buffer].width;
|
||||
height = buffers[gcm_current_buffer].height;
|
||||
src_buffer = vm::get_ptr<u8>(addr);
|
||||
}
|
||||
else if (m_fbo.IsCreated())
|
||||
@ -2120,12 +2120,12 @@ void GLGSRender::Flip()
|
||||
|
||||
void GLGSRender::semaphorePGRAPHTextureReadRelease(u32 offset, u32 value)
|
||||
{
|
||||
vm::ps3::write32(m_label_addr + offset, value);
|
||||
vm::ps3::write32(label_addr + offset, value);
|
||||
}
|
||||
|
||||
void GLGSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
|
||||
{
|
||||
vm::ps3::write32(m_label_addr + offset, value);
|
||||
vm::ps3::write32(label_addr + offset, value);
|
||||
}
|
||||
|
||||
void GLGSRender::semaphorePFIFOAcquire(u32 offset, u32 value)
|
||||
|
||||
@ -67,8 +67,8 @@ GSLock::GSLock(GSRender& renderer, GSLockType type)
|
||||
{
|
||||
switch (m_type)
|
||||
{
|
||||
case GS_LOCK_NOT_WAIT: m_renderer.m_cs_main.lock(); break;
|
||||
case GS_LOCK_WAIT_FLIP: m_renderer.m_sem_flip.wait(); break;
|
||||
case GS_LOCK_NOT_WAIT: m_renderer.cs_main.lock(); break;
|
||||
case GS_LOCK_WAIT_FLIP: m_renderer.sem_flip.wait(); break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -76,8 +76,8 @@ GSLock::~GSLock()
|
||||
{
|
||||
switch (m_type)
|
||||
{
|
||||
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;
|
||||
case GS_LOCK_NOT_WAIT: m_renderer.cs_main.unlock(); break;
|
||||
case GS_LOCK_WAIT_FLIP: m_renderer.sem_flip.try_post(); break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -43,7 +43,7 @@ u32 GetAddress(u32 offset, u32 location)
|
||||
throw EXCEPTION("RSXIO memory not mapped (offset=0x%x)", offset);
|
||||
}
|
||||
|
||||
if (Emu.GetGSManager().GetRender().m_strict_ordering[offset >> 20])
|
||||
if (Emu.GetGSManager().GetRender().strict_ordering[offset >> 20])
|
||||
{
|
||||
_mm_mfence(); // probably doesn't have any effect on current implementation
|
||||
}
|
||||
@ -245,12 +245,12 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
|
||||
{
|
||||
Flip();
|
||||
|
||||
m_last_flip_time = get_system_time();
|
||||
m_gcm_current_buffer = ARGS(0);
|
||||
last_flip_time = get_system_time();
|
||||
gcm_current_buffer = ARGS(0);
|
||||
m_read_buffer = true;
|
||||
m_flip_status = 0;
|
||||
flip_status = 0;
|
||||
|
||||
if (auto cb = m_flip_handler)
|
||||
if (auto cb = flip_handler)
|
||||
{
|
||||
Emu.GetCallbackManager().Async([=](CPUThread& cpu)
|
||||
{
|
||||
@ -258,7 +258,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
|
||||
});
|
||||
}
|
||||
|
||||
m_sem_flip.post_and_wait();
|
||||
sem_flip.post_and_wait();
|
||||
|
||||
auto sync = [&]()
|
||||
{
|
||||
@ -937,12 +937,12 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
|
||||
|
||||
//LOG_WARNING(RSX, "NV4097_DRAW_ARRAYS: %d - %d", first, _count);
|
||||
|
||||
if (first < m_draw_array_first)
|
||||
if (first < draw_array_first)
|
||||
{
|
||||
m_draw_array_first = first;
|
||||
draw_array_first = first;
|
||||
}
|
||||
|
||||
m_draw_array_count += _count;
|
||||
draw_array_count += _count;
|
||||
}
|
||||
break;
|
||||
}
|
||||
@ -1025,7 +1025,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
|
||||
|
||||
//LOG_WARNING(RSX, "NV4097_SET_BEGIN_END: 0x%x", a0);
|
||||
|
||||
if (!m_indexed_array.m_count && !m_draw_array_count)
|
||||
if (!m_indexed_array.m_count && !draw_array_count)
|
||||
{
|
||||
u32 min_vertex_size = ~0;
|
||||
for (auto &i : m_vertex_data)
|
||||
@ -1039,11 +1039,11 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
|
||||
min_vertex_size = vertex_size;
|
||||
}
|
||||
|
||||
m_draw_array_count = min_vertex_size;
|
||||
m_draw_array_first = 0;
|
||||
draw_array_count = min_vertex_size;
|
||||
draw_array_first = 0;
|
||||
}
|
||||
|
||||
m_read_buffer = Ini.GSReadColorBuffer.GetValue() || (!m_indexed_array.m_count && !m_draw_array_count);
|
||||
m_read_buffer = Ini.GSReadColorBuffer.GetValue() || (!m_indexed_array.m_count && !draw_array_count);
|
||||
|
||||
if (a0)
|
||||
{
|
||||
@ -1505,8 +1505,8 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
|
||||
}
|
||||
|
||||
auto buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr);
|
||||
m_width = buffers[m_gcm_current_buffer].width;
|
||||
m_height = buffers[m_gcm_current_buffer].height;
|
||||
m_width = buffers[gcm_current_buffer].width;
|
||||
m_height = buffers[gcm_current_buffer].height;
|
||||
|
||||
CellVideoOutResolution res = ResolutionTable[ResolutionIdToNum(Ini.GSResolution.GetValue())];
|
||||
m_width_scale = (float)res.width / m_width * 2.0f;
|
||||
@ -1847,9 +1847,9 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
|
||||
//dma_write32(dma_report, offset + 0x8, value);
|
||||
//dma_write32(dma_report, offset + 0xc, 0);
|
||||
|
||||
vm::ps3::write64(m_local_mem_addr + offset + 0x0, timestamp);
|
||||
vm::ps3::write32(m_local_mem_addr + offset + 0x8, value);
|
||||
vm::ps3::write32(m_local_mem_addr + offset + 0xc, 0);
|
||||
vm::ps3::write64(local_mem_addr + offset + 0x0, timestamp);
|
||||
vm::ps3::write32(local_mem_addr + offset + 0x8, value);
|
||||
vm::ps3::write32(local_mem_addr + offset + 0xc, 0);
|
||||
break;
|
||||
}
|
||||
|
||||
@ -2340,7 +2340,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
|
||||
{
|
||||
const u32 cause = ARGS(0);
|
||||
|
||||
if (auto cb = m_user_handler)
|
||||
if (auto cb = user_handler)
|
||||
{
|
||||
Emu.GetCallbackManager().Async([=](CPUThread& cpu)
|
||||
{
|
||||
@ -2460,12 +2460,12 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
|
||||
}
|
||||
}
|
||||
|
||||
void RSXThread::Begin(u32 draw_mode)
|
||||
void RSXThread::Begin(u32 drawMode)
|
||||
{
|
||||
m_begin_end = 1;
|
||||
m_draw_mode = draw_mode;
|
||||
m_draw_array_count = 0;
|
||||
m_draw_array_first = ~0;
|
||||
draw_mode = drawMode;
|
||||
draw_array_count = 0;
|
||||
draw_array_first = ~0;
|
||||
}
|
||||
|
||||
void RSXThread::End()
|
||||
@ -2495,23 +2495,23 @@ void RSXThread::Task()
|
||||
|
||||
oninit_thread();
|
||||
|
||||
m_last_flip_time = get_system_time() - 1000000;
|
||||
last_flip_time = get_system_time() - 1000000;
|
||||
|
||||
autojoin_thread_t vblank(WRAP_EXPR("VBlank Thread"), [this]()
|
||||
{
|
||||
const u64 start_time = get_system_time();
|
||||
|
||||
m_vblank_count = 0;
|
||||
vblank_count = 0;
|
||||
|
||||
while (joinable())
|
||||
{
|
||||
CHECK_EMU_STATUS;
|
||||
|
||||
if (get_system_time() - start_time > m_vblank_count * 1000000 / 60)
|
||||
if (get_system_time() - start_time > vblank_count * 1000000 / 60)
|
||||
{
|
||||
m_vblank_count++;
|
||||
vblank_count++;
|
||||
|
||||
if (auto cb = m_vblank_handler)
|
||||
if (auto cb = vblank_handler)
|
||||
{
|
||||
Emu.GetCallbackManager().Async([=](CPUThread& cpu)
|
||||
{
|
||||
@ -2528,7 +2528,7 @@ void RSXThread::Task()
|
||||
|
||||
while (joinable() && !Emu.IsStopped())
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(m_cs_main);
|
||||
std::lock_guard<std::mutex> lock(cs_main);
|
||||
|
||||
inc = 1;
|
||||
|
||||
@ -2605,7 +2605,7 @@ void RSXThread::Init(const u32 ioAddress, const u32 ioSize, const u32 ctrlAddres
|
||||
m_ioAddress = ioAddress;
|
||||
m_ioSize = ioSize;
|
||||
m_ctrlAddress = ctrlAddress;
|
||||
m_local_mem_addr = localAddress;
|
||||
local_mem_addr = localAddress;
|
||||
|
||||
m_cur_vertex_prog = nullptr;
|
||||
m_cur_fragment_prog = nullptr;
|
||||
|
||||
@ -105,8 +105,8 @@ protected:
|
||||
Timer m_timer_sync;
|
||||
|
||||
public:
|
||||
GcmTileInfo m_tiles[m_tiles_count];
|
||||
GcmZcullInfo m_zculls[m_zculls_count];
|
||||
GcmTileInfo tiles[m_tiles_count];
|
||||
GcmZcullInfo zculls[m_zculls_count];
|
||||
RSXTexture m_textures[m_textures_count];
|
||||
RSXVertexTexture m_vertex_textures[m_textures_count];
|
||||
RSXVertexData m_vertex_data[m_vertex_count];
|
||||
@ -122,45 +122,45 @@ public:
|
||||
|
||||
public:
|
||||
u32 m_ioAddress, m_ioSize, m_ctrlAddress;
|
||||
int m_flip_status;
|
||||
int m_flip_mode;
|
||||
int m_debug_level;
|
||||
int m_frequency_mode;
|
||||
int flip_status;
|
||||
int flip_mode;
|
||||
int debug_level;
|
||||
int frequency_mode;
|
||||
|
||||
u32 m_tiles_addr;
|
||||
u32 m_zculls_addr;
|
||||
u32 tiles_addr;
|
||||
u32 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;
|
||||
u32 gcm_buffers_count;
|
||||
u32 gcm_current_buffer;
|
||||
u32 ctxt_addr;
|
||||
u32 report_main_addr;
|
||||
u32 label_addr;
|
||||
u32 draw_mode;
|
||||
|
||||
// DMA
|
||||
u32 dma_report;
|
||||
|
||||
u32 m_local_mem_addr, m_main_mem_addr;
|
||||
bool m_strict_ordering[0x1000];
|
||||
u32 local_mem_addr, main_mem_addr;
|
||||
bool strict_ordering[0x1000];
|
||||
|
||||
public:
|
||||
uint m_draw_mode;
|
||||
u32 draw_array_count;
|
||||
u32 draw_array_first;
|
||||
|
||||
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::ps3::ptr<void(u32)> m_flip_handler;
|
||||
vm::ps3::ptr<void(u32)> m_user_handler;
|
||||
u64 m_vblank_count;
|
||||
vm::ps3::ptr<void(u32)> m_vblank_handler;
|
||||
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:
|
||||
// Dither
|
||||
@ -450,22 +450,22 @@ 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)
|
||||
, flip_status(0)
|
||||
, flip_mode(CELL_GCM_DISPLAY_VSYNC)
|
||||
, debug_level(CELL_GCM_DEBUG_LEVEL0)
|
||||
, frequency_mode(CELL_GCM_DISPLAY_FREQUENCY_DISABLE)
|
||||
, report_main_addr(0)
|
||||
, main_mem_addr(0)
|
||||
, local_mem_addr(0)
|
||||
, draw_mode(0)
|
||||
, draw_array_count(0)
|
||||
, draw_array_first(~0)
|
||||
, gcm_current_buffer(0)
|
||||
, m_read_buffer(true)
|
||||
{
|
||||
m_flip_handler.set(0);
|
||||
m_vblank_handler.set(0);
|
||||
m_user_handler.set(0);
|
||||
flip_handler.set(0);
|
||||
vblank_handler.set(0);
|
||||
user_handler.set(0);
|
||||
m_set_depth_test = false;
|
||||
m_set_alpha_test = false;
|
||||
m_set_depth_bounds_test = false;
|
||||
|
||||
@ -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().m_report_main_addr + index * 0x10);
|
||||
return vm::ptr<CellGcmReportData>::make(Emu.GetGSManager().GetRender().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().m_report_main_addr + index * 0x10);
|
||||
return vm::read64(Emu.GetGSManager().GetRender().report_main_addr + index * 0x10);
|
||||
}
|
||||
|
||||
cellGcmSys.Error("cellGcmGetTimeStampLocation: Wrong location (%d)", location);
|
||||
@ -257,8 +257,8 @@ s32 cellGcmBindTile(u8 index)
|
||||
return CELL_GCM_ERROR_INVALID_VALUE;
|
||||
}
|
||||
|
||||
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index];
|
||||
tile.m_binded = true;
|
||||
auto& tile = Emu.GetGSManager().GetRender().tiles[index];
|
||||
tile.binded = true;
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
@ -273,8 +273,8 @@ s32 cellGcmBindZcull(u8 index)
|
||||
return CELL_GCM_ERROR_INVALID_VALUE;
|
||||
}
|
||||
|
||||
auto& zcull = Emu.GetGSManager().GetRender().m_zculls[index];
|
||||
zcull.m_binded = true;
|
||||
auto& zcull = Emu.GetGSManager().GetRender().zculls[index];
|
||||
zcull.binded = true;
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
@ -290,7 +290,7 @@ s32 cellGcmGetConfiguration(vm::ptr<CellGcmConfig> config)
|
||||
|
||||
s32 cellGcmGetFlipStatus()
|
||||
{
|
||||
s32 status = Emu.GetGSManager().GetRender().m_flip_status;
|
||||
s32 status = Emu.GetGSManager().GetRender().flip_status;
|
||||
|
||||
cellGcmSys.Log("cellGcmGetFlipStatus() -> %d", status);
|
||||
|
||||
@ -388,14 +388,14 @@ s32 _cellGcmInitBody(vm::pptr<CellGcmContextData> context, u32 cmdSize, u32 ioSi
|
||||
ctrl.ref = -1;
|
||||
|
||||
auto& render = Emu.GetGSManager().GetRender();
|
||||
render.m_ctxt_addr = context.addr();
|
||||
render.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.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);
|
||||
|
||||
return CELL_OK;
|
||||
@ -405,7 +405,7 @@ s32 cellGcmResetFlipStatus()
|
||||
{
|
||||
cellGcmSys.Log("cellGcmResetFlipStatus()");
|
||||
|
||||
Emu.GetGSManager().GetRender().m_flip_status = CELL_GCM_DISPLAY_FLIP_STATUS_WAITING;
|
||||
Emu.GetGSManager().GetRender().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().m_debug_level = level;
|
||||
Emu.GetGSManager().GetRender().debug_level = level;
|
||||
break;
|
||||
|
||||
default: return CELL_EINVAL;
|
||||
@ -445,9 +445,9 @@ s32 cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height
|
||||
buffers[id].width = width;
|
||||
buffers[id].height = height;
|
||||
|
||||
if (id + 1 > Emu.GetGSManager().GetRender().m_gcm_buffers_count)
|
||||
if (id + 1 > Emu.GetGSManager().GetRender().gcm_buffers_count)
|
||||
{
|
||||
Emu.GetGSManager().GetRender().m_gcm_buffers_count = id + 1;
|
||||
Emu.GetGSManager().GetRender().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().m_flip_handler = handler;
|
||||
Emu.GetGSManager().GetRender().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().m_flip_mode = mode;
|
||||
Emu.GetGSManager().GetRender().flip_mode = mode;
|
||||
break;
|
||||
|
||||
default:
|
||||
@ -483,7 +483,7 @@ void cellGcmSetFlipStatus()
|
||||
{
|
||||
cellGcmSys.Warning("cellGcmSetFlipStatus()");
|
||||
|
||||
Emu.GetGSManager().GetRender().m_flip_status = 0;
|
||||
Emu.GetGSManager().GetRender().flip_status = 0;
|
||||
}
|
||||
|
||||
s32 cellGcmSetPrepareFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> ctxt, u32 id)
|
||||
@ -535,11 +535,11 @@ s32 cellGcmSetSecondVFrequency(u32 freq)
|
||||
switch (freq)
|
||||
{
|
||||
case CELL_GCM_DISPLAY_FREQUENCY_59_94HZ:
|
||||
Emu.GetGSManager().GetRender().m_frequency_mode = freq; Emu.GetGSManager().GetRender().m_fps_limit = 59.94; break;
|
||||
Emu.GetGSManager().GetRender().frequency_mode = freq; Emu.GetGSManager().GetRender().m_fps_limit = 59.94; break;
|
||||
case CELL_GCM_DISPLAY_FREQUENCY_SCANOUT:
|
||||
Emu.GetGSManager().GetRender().m_frequency_mode = freq; cellGcmSys.Todo("Unimplemented display frequency: Scanout"); break;
|
||||
Emu.GetGSManager().GetRender().frequency_mode = freq; cellGcmSys.Todo("Unimplemented display frequency: Scanout"); break;
|
||||
case CELL_GCM_DISPLAY_FREQUENCY_DISABLE:
|
||||
Emu.GetGSManager().GetRender().m_frequency_mode = freq; cellGcmSys.Todo("Unimplemented display frequency: Disabled"); break;
|
||||
Emu.GetGSManager().GetRender().frequency_mode = freq; cellGcmSys.Todo("Unimplemented display frequency: Disabled"); break;
|
||||
default: cellGcmSys.Error("Improper display frequency specified!"); return CELL_OK;
|
||||
}
|
||||
|
||||
@ -574,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().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;
|
||||
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;
|
||||
|
||||
vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().m_tiles_addr)[index] = tile.Pack();
|
||||
vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().tiles_addr)[index] = tile.Pack();
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
@ -591,7 +591,7 @@ void cellGcmSetUserHandler(vm::ptr<void(u32)> handler)
|
||||
{
|
||||
cellGcmSys.Warning("cellGcmSetUserHandler(handler=*0x%x)", handler);
|
||||
|
||||
Emu.GetGSManager().GetRender().m_user_handler = handler;
|
||||
Emu.GetGSManager().GetRender().user_handler = handler;
|
||||
}
|
||||
|
||||
s32 cellGcmSetUserCommand()
|
||||
@ -603,7 +603,7 @@ void cellGcmSetVBlankHandler(vm::ptr<void(u32)> handler)
|
||||
{
|
||||
cellGcmSys.Warning("cellGcmSetVBlankHandler(handler=*0x%x)", handler);
|
||||
|
||||
Emu.GetGSManager().GetRender().m_vblank_handler = handler;
|
||||
Emu.GetGSManager().GetRender().vblank_handler = handler;
|
||||
}
|
||||
|
||||
s32 cellGcmSetWaitFlip(vm::ptr<CellGcmContextData> ctxt)
|
||||
@ -631,20 +631,20 @@ s32 cellGcmSetZcull(u8 index, u32 offset, u32 width, u32 height, u32 cullStart,
|
||||
return CELL_GCM_ERROR_INVALID_VALUE;
|
||||
}
|
||||
|
||||
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;
|
||||
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;
|
||||
|
||||
vm::get_ptr<CellGcmZcullInfo>(Emu.GetGSManager().GetRender().m_zculls_addr)[index] = zcull.Pack();
|
||||
vm::get_ptr<CellGcmZcullInfo>(Emu.GetGSManager().GetRender().zculls_addr)[index] = zcull.Pack();
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
@ -658,8 +658,8 @@ s32 cellGcmUnbindTile(u8 index)
|
||||
return CELL_GCM_ERROR_INVALID_VALUE;
|
||||
}
|
||||
|
||||
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index];
|
||||
tile.m_binded = false;
|
||||
auto& tile = Emu.GetGSManager().GetRender().tiles[index];
|
||||
tile.binded = false;
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
@ -674,8 +674,8 @@ s32 cellGcmUnbindZcull(u8 index)
|
||||
return CELL_EINVAL;
|
||||
}
|
||||
|
||||
auto& zcull = Emu.GetGSManager().GetRender().m_zculls[index];
|
||||
zcull.m_binded = false;
|
||||
auto& zcull = Emu.GetGSManager().GetRender().zculls[index];
|
||||
zcull.binded = false;
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
@ -683,13 +683,13 @@ s32 cellGcmUnbindZcull(u8 index)
|
||||
u32 cellGcmGetTileInfo()
|
||||
{
|
||||
cellGcmSys.Warning("cellGcmGetTileInfo()");
|
||||
return Emu.GetGSManager().GetRender().m_tiles_addr;
|
||||
return Emu.GetGSManager().GetRender().tiles_addr;
|
||||
}
|
||||
|
||||
u32 cellGcmGetZcullInfo()
|
||||
{
|
||||
cellGcmSys.Warning("cellGcmGetZcullInfo()");
|
||||
return Emu.GetGSManager().GetRender().m_zculls_addr;
|
||||
return Emu.GetGSManager().GetRender().zculls_addr;
|
||||
}
|
||||
|
||||
u32 cellGcmGetDisplayInfo()
|
||||
@ -702,12 +702,12 @@ s32 cellGcmGetCurrentDisplayBufferId(vm::ptr<u8> id)
|
||||
{
|
||||
cellGcmSys.Warning("cellGcmGetCurrentDisplayBufferId(id=*0x%x)", id);
|
||||
|
||||
if (Emu.GetGSManager().GetRender().m_gcm_current_buffer > UINT8_MAX)
|
||||
if (Emu.GetGSManager().GetRender().gcm_current_buffer > UINT8_MAX)
|
||||
{
|
||||
throw EXCEPTION("Unexpected");
|
||||
}
|
||||
|
||||
*id = Emu.GetGSManager().GetRender().m_gcm_current_buffer;
|
||||
*id = Emu.GetGSManager().GetRender().gcm_current_buffer;
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
@ -739,7 +739,7 @@ u64 cellGcmGetLastFlipTime()
|
||||
{
|
||||
cellGcmSys.Log("cellGcmGetLastFlipTime()");
|
||||
|
||||
return Emu.GetGSManager().GetRender().m_last_flip_time;
|
||||
return Emu.GetGSManager().GetRender().last_flip_time;
|
||||
}
|
||||
|
||||
u64 cellGcmGetLastSecondVTime()
|
||||
@ -752,7 +752,7 @@ u64 cellGcmGetVBlankCount()
|
||||
{
|
||||
cellGcmSys.Log("cellGcmGetVBlankCount()");
|
||||
|
||||
return Emu.GetGSManager().GetRender().m_vblank_count;
|
||||
return Emu.GetGSManager().GetRender().vblank_count;
|
||||
}
|
||||
|
||||
s32 cellGcmSysGetLastVBlankTime()
|
||||
@ -895,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().m_strict_ordering[(io >> 20) + i] = is_strict;
|
||||
Emu.GetGSManager().GetRender().strict_ordering[(io >> 20) + i] = is_strict;
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -957,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().m_strict_ordering[(io >> 20) + i] = false;
|
||||
Emu.GetGSManager().GetRender().strict_ordering[(io >> 20) + i] = false;
|
||||
}
|
||||
|
||||
*offset = io;
|
||||
@ -968,7 +968,7 @@ s32 cellGcmMapMainMemory(u32 ea, u32 size, vm::ptr<u32> offset)
|
||||
return CELL_GCM_ERROR_NO_IO_PAGE_TABLE;
|
||||
}
|
||||
|
||||
Emu.GetGSManager().GetRender().m_main_mem_addr = Emu.GetGSManager().GetRender().m_ioAddress;
|
||||
Emu.GetGSManager().GetRender().main_mem_addr = Emu.GetGSManager().GetRender().m_ioAddress;
|
||||
|
||||
return CELL_OK;
|
||||
}
|
||||
@ -1108,7 +1108,7 @@ s32 cellGcmSetCursorImageOffset(u32 offset)
|
||||
void cellGcmSetDefaultCommandBuffer()
|
||||
{
|
||||
cellGcmSys.Warning("cellGcmSetDefaultCommandBuffer()");
|
||||
vm::write32(Emu.GetGSManager().GetRender().m_ctxt_addr, gcm_info.context_addr);
|
||||
vm::write32(Emu.GetGSManager().GetRender().ctxt_addr, gcm_info.context_addr);
|
||||
}
|
||||
|
||||
s32 cellGcmSetDefaultCommandBufferAndSegmentWordSize()
|
||||
@ -1165,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().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;
|
||||
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;
|
||||
|
||||
vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().m_tiles_addr)[index] = tile.Pack();
|
||||
vm::get_ptr<CellGcmTileInfo>(Emu.GetGSManager().GetRender().tiles_addr)[index] = tile.Pack();
|
||||
return CELL_OK;
|
||||
}
|
||||
|
||||
|
||||
@ -1075,21 +1075,21 @@ void cellRescSetFlipHandler(vm::ptr<void(u32)> handler)
|
||||
{
|
||||
cellResc.Warning("cellRescSetFlipHandler(handler=*0x%x)", handler);
|
||||
|
||||
Emu.GetGSManager().GetRender().m_flip_handler = handler;
|
||||
Emu.GetGSManager().GetRender().flip_handler = handler;
|
||||
}
|
||||
|
||||
void cellRescResetFlipStatus()
|
||||
{
|
||||
cellResc.Log("cellRescResetFlipStatus()");
|
||||
|
||||
Emu.GetGSManager().GetRender().m_flip_status = 1;
|
||||
Emu.GetGSManager().GetRender().flip_status = 1;
|
||||
}
|
||||
|
||||
s32 cellRescGetFlipStatus()
|
||||
{
|
||||
cellResc.Log("cellRescGetFlipStatus()");
|
||||
|
||||
return Emu.GetGSManager().GetRender().m_flip_status;
|
||||
return Emu.GetGSManager().GetRender().flip_status;
|
||||
}
|
||||
|
||||
s32 cellRescGetRegisterCount()
|
||||
@ -1102,7 +1102,7 @@ u64 cellRescGetLastFlipTime()
|
||||
{
|
||||
cellResc.Log("cellRescGetLastFlipTime()");
|
||||
|
||||
return Emu.GetGSManager().GetRender().m_last_flip_time;
|
||||
return Emu.GetGSManager().GetRender().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().m_vblank_handler = handler;
|
||||
Emu.GetGSManager().GetRender().vblank_handler = handler;
|
||||
}
|
||||
|
||||
u16 FloatToHalf(float val)
|
||||
|
||||
@ -304,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.m_local_mem_addr + buffers[id].offset; \
|
||||
u32 addr = render.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; \
|
||||
@ -408,13 +408,13 @@ void RSXDebugger::GetBuffers()
|
||||
|
||||
// Draw Buffers
|
||||
// TODO: Currently it only supports color buffers
|
||||
for (u32 bufferId=0; bufferId < render.m_gcm_buffers_count; bufferId++)
|
||||
for (u32 bufferId=0; bufferId < render.gcm_buffers_count; bufferId++)
|
||||
{
|
||||
if(!vm::check_addr(render.m_gcm_buffers_addr))
|
||||
continue;
|
||||
|
||||
auto buffers = vm::get_ptr<CellGcmDisplayInfo>(render.m_gcm_buffers_addr);
|
||||
u32 RSXbuffer_addr = render.m_local_mem_addr + buffers[bufferId].offset;
|
||||
u32 RSXbuffer_addr = render.local_mem_addr + buffers[bufferId].offset;
|
||||
|
||||
if(!vm::check_addr(RSXbuffer_addr))
|
||||
continue;
|
||||
@ -616,8 +616,8 @@ void RSXDebugger::GetSettings()
|
||||
render.m_depth_func,
|
||||
ParseGCMEnum(render.m_depth_func, CELL_GCM_ENUM)));
|
||||
LIST_SETTINGS_ADD("Draw mode", wxString::Format("%d (%s)",
|
||||
render.m_draw_mode,
|
||||
ParseGCMEnum(render.m_draw_mode, CELL_GCM_PRIMITIVE_ENUM)));
|
||||
render.draw_mode,
|
||||
ParseGCMEnum(render.draw_mode, CELL_GCM_PRIMITIVE_ENUM)));
|
||||
LIST_SETTINGS_ADD("Scissor", wxString::Format("X:%d, Y:%d, W:%d, H:%d",
|
||||
render.m_scissor_x,
|
||||
render.m_scissor_y,
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user