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

Remove m_ prefix on some members of RSXThread

Browse source
This commit is contained in:
Vincent Lejeune 2015-10-08 23:06:42 +02:00
parent 4cd9e5754e
commit e3e5b46cbf
11 changed files with 219 additions and 219 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -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); 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); 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++) 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 = {}; D3D12_INDEX_BUFFER_VIEW indexBufferView = {};
// No need for index buffer // 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_indexed = false;
m_renderingInfo.m_count = m_draw_array_count; m_renderingInfo.m_count = draw_array_count;
m_renderingInfo.m_baseVertex = m_draw_array_first; m_renderingInfo.m_baseVertex = draw_array_first;
return indexBufferView; return indexBufferView;
} }
@ -207,11 +207,11 @@ D3D12_INDEX_BUFFER_VIEW D3D12GSRender::uploadIndexBuffers(bool indexed_draw)
} }
// Index count // 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 // Base vertex
if (!indexed_draw && isNativePrimitiveMode(m_draw_mode)) if (!indexed_draw && isNativePrimitiveMode(draw_mode))
m_renderingInfo.m_baseVertex = m_draw_array_first; m_renderingInfo.m_baseVertex = draw_array_first;
else else
m_renderingInfo.m_baseVertex = 0; m_renderingInfo.m_baseVertex = 0;
@ -224,7 +224,7 @@ D3D12_INDEX_BUFFER_VIEW D3D12GSRender::uploadIndexBuffers(bool indexed_draw)
void *buffer; void *buffer;
ThrowIfFailed(m_vertexIndexData.m_heap->Map(0, &CD3DX12_RANGE(heapOffset, heapOffset + subBufferSize), (void**)&buffer)); ThrowIfFailed(m_vertexIndexData.m_heap->Map(0, &CD3DX12_RANGE(heapOffset, heapOffset + subBufferSize), (void**)&buffer));
void *bufferMap = (char*)buffer + heapOffset; 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_vertexIndexData.m_heap->Unmap(0, &CD3DX12_RANGE(heapOffset, heapOffset + subBufferSize));
m_timers.m_bufferUploadSize += subBufferSize; m_timers.m_bufferUploadSize += subBufferSize;
indexBufferView.SizeInBytes = (UINT)subBufferSize; indexBufferView.SizeInBytes = (UINT)subBufferSize;

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

@ -411,12 +411,12 @@ void D3D12GSRender::Draw()
if (!m_vertex_data[i].addr) continue; if (!m_vertex_data[i].addr) continue;
const u32 tsize = m_vertex_data[i].GetTypeSize(); 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 std::vector<D3D12_VERTEX_BUFFER_VIEW> &vertexBufferViews = UploadVertexBuffers(m_indexed_array.m_count ? true : false);
const D3D12_INDEX_BUFFER_VIEW &indexBufferView = uploadIndexBuffers(m_indexed_array.m_count ? true : false); const 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); getCurrentResourceStorage().m_commandList->RSSetScissorRects(1, &box);
switch (m_draw_mode - 1) switch (draw_mode - 1)
{ {
case GL_POINTS: case GL_POINTS:
getCurrentResourceStorage().m_commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_POINTLIST); getCurrentResourceStorage().m_commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_POINTLIST);
@ -647,9 +647,9 @@ void D3D12GSRender::Flip()
if (m_read_buffer) if (m_read_buffer)
{ {
CellGcmDisplayInfo* buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr); CellGcmDisplayInfo* buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr);
u32 addr = GetAddress(buffers[m_gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL); u32 addr = GetAddress(buffers[gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL);
w = buffers[m_gcm_current_buffer].width; w = buffers[gcm_current_buffer].width;
h = buffers[m_gcm_current_buffer].height; h = buffers[gcm_current_buffer].height;
u8 *src_buffer = vm::get_ptr<u8>(addr); u8 *src_buffer = vm::get_ptr<u8>(addr);
rowPitch = align(w * 4, 256); 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) 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(); const std::chrono::time_point<std::chrono::system_clock> enterWait = std::chrono::system_clock::now();
while (true) 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; if (val == value) break;
std::chrono::time_point<std::chrono::system_clock> waitPoint = std::chrono::system_clock::now(); 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(); long long elapsedTime = std::chrono::duration_cast<std::chrono::seconds>(waitPoint - enterWait).count();

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

@ -70,7 +70,7 @@ bool D3D12GSRender::LoadProgram()
} }
D3D12PipelineProperties prop = {}; D3D12PipelineProperties prop = {};
switch (m_draw_mode - 1) switch (draw_mode - 1)
{ {
case GL_POINTS: case GL_POINTS:
prop.Topology = D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT; prop.Topology = D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT;

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

@ -395,18 +395,18 @@ struct CellGcmTileInfo
struct GcmZcullInfo struct GcmZcullInfo
{ {
u32 m_offset; u32 offset;
u32 m_width; u32 width;
u32 m_height; u32 height;
u32 m_cullStart; u32 cullStart;
u32 m_zFormat; u32 zFormat;
u32 m_aaFormat; u32 aaFormat;
u32 m_zcullDir; u32 zcullDir;
u32 m_zcullFormat; u32 zcullFormat;
u32 m_sFunc; u32 sFunc;
u32 m_sRef; u32 sRef;
u32 m_sMask; u32 sMask;
bool m_binded; bool binded;
GcmZcullInfo() GcmZcullInfo()
{ {
@ -417,11 +417,11 @@ struct GcmZcullInfo
{ {
CellGcmZcullInfo ret; CellGcmZcullInfo ret;
ret.region = (1<<0) | (m_zFormat<<4) | (m_aaFormat<<8); ret.region = (1<<0) | (zFormat<<4) | (aaFormat<<8);
ret.size = ((m_width>>6)<<22) | ((m_height>>6)<<6); ret.size = ((width>>6)<<22) | ((height>>6)<<6);
ret.start = m_cullStart&(~0xFFF); ret.start = cullStart&(~0xFFF);
ret.offset = m_offset; ret.offset = offset;
ret.status0 = (m_zcullDir<<1) | (m_zcullFormat<<2) | ((m_sFunc&0xF)<<12) | (m_sRef<<16) | (m_sMask<<24); ret.status0 = (zcullDir<<1) | (zcullFormat<<2) | ((sFunc&0xF)<<12) | (sRef<<16) | (sMask<<24);
ret.status1 = (0x2000<<0) | (0x20<<16); ret.status1 = (0x2000<<0) | (0x20<<16);
return ret; return ret;
@ -430,14 +430,14 @@ struct GcmZcullInfo
struct GcmTileInfo struct GcmTileInfo
{ {
u8 m_location; u8 location;
u32 m_offset; u32 offset;
u32 m_size; u32 size;
u32 m_pitch; u32 pitch;
u8 m_comp; u8 comp;
u16 m_base; u16 base;
u8 m_bank; u8 bank;
bool m_binded; bool binded;
GcmTileInfo() GcmTileInfo()
{ {
@ -448,10 +448,10 @@ struct GcmTileInfo
{ {
CellGcmTileInfo ret; CellGcmTileInfo ret;
ret.tile = (m_location + 1) | (m_bank << 4) | ((m_offset / 0x10000) << 16) | (m_location << 31); ret.tile = (location + 1) | (bank << 4) | ((offset / 0x10000) << 16) | (location << 31);
ret.limit = ((m_offset + m_size - 1) / 0x10000) << 16 | (m_location << 31); ret.limit = ((offset + size - 1) / 0x10000) << 16 | (location << 31);
ret.pitch = (m_pitch / 0x100) << 8; ret.pitch = (pitch / 0x100) << 8;
ret.format = m_base | ((m_base + ((m_size - 1) / 0x10000)) << 13) | (m_comp << 26) | (1 << 30); ret.format = base | ((base + ((size - 1) / 0x10000)) << 13) | (comp << 26) | (1 << 30);
return ret; return ret;
} }

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

@ -807,7 +807,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
static u32 offset_list[m_vertex_count]; static u32 offset_list[m_vertex_count];
u32 cur_offset = 0; 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) for (u32 i = 0; i < m_vertex_count; ++i)
{ {
@ -1567,9 +1567,9 @@ void GLGSRender::InitDrawBuffers()
{ {
u32 format = GL_BGRA; u32 format = GL_BGRA;
CellGcmDisplayInfo* buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr); CellGcmDisplayInfo* buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr);
u32 addr = GetAddress(buffers[m_gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL); u32 addr = GetAddress(buffers[gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL);
u32 width = buffers[m_gcm_current_buffer].width; u32 width = buffers[gcm_current_buffer].width;
u32 height = buffers[m_gcm_current_buffer].height; u32 height = buffers[gcm_current_buffer].height;
glDrawPixels(width, height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, vm::get_ptr(addr)); 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"); 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; u32 min_vertex_size = ~0;
for (auto &i : m_vertex_data) for (auto &i : m_vertex_data)
@ -1660,8 +1660,8 @@ void GLGSRender::Draw()
min_vertex_size = vertex_size; min_vertex_size = vertex_size;
} }
m_draw_array_count = min_vertex_size; draw_array_count = min_vertex_size;
m_draw_array_first = 0; draw_array_first = 0;
} }
Enable(m_set_depth_test, GL_DEPTH_TEST); Enable(m_set_depth_test, GL_DEPTH_TEST);
@ -1905,7 +1905,7 @@ void GLGSRender::Draw()
checkForGlError("glPrimitiveRestartIndex"); 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"); LOG_WARNING(RSX, "m_indexed_array.m_count && draw_array_count");
} }
@ -1943,9 +1943,9 @@ void GLGSRender::Draw()
if (m_indexed_array.m_count) if (m_indexed_array.m_count)
LoadVertexData(m_indexed_array.index_min, m_indexed_array.index_max - m_indexed_array.index_min + 1); LoadVertexData(m_indexed_array.index_min, m_indexed_array.index_max - m_indexed_array.index_min + 1);
else 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); EnableVertexData(m_indexed_array.m_count ? true : false);
@ -1958,12 +1958,12 @@ void GLGSRender::Draw()
switch(m_indexed_array.m_type) switch(m_indexed_array.m_type)
{ {
case CELL_GCM_DRAW_INDEX_ARRAY_TYPE_32: 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"); checkForGlError("glDrawElements #4");
break; break;
case CELL_GCM_DRAW_INDEX_ARRAY_TYPE_16: 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"); checkForGlError("glDrawElements #2");
break; break;
@ -1976,10 +1976,10 @@ void GLGSRender::Draw()
m_indexed_array.Reset(); 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); //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"); checkForGlError("glDrawArrays");
DisableVertexData(); DisableVertexData();
} }
@ -2023,9 +2023,9 @@ void GLGSRender::Flip()
{ {
format = GL_BGRA; format = GL_BGRA;
CellGcmDisplayInfo* buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr); CellGcmDisplayInfo* buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr);
u32 addr = GetAddress(buffers[m_gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL); u32 addr = GetAddress(buffers[gcm_current_buffer].offset, CELL_GCM_LOCATION_LOCAL);
width = buffers[m_gcm_current_buffer].width; width = buffers[gcm_current_buffer].width;
height = buffers[m_gcm_current_buffer].height; height = buffers[gcm_current_buffer].height;
src_buffer = vm::get_ptr<u8>(addr); src_buffer = vm::get_ptr<u8>(addr);
} }
else if (m_fbo.IsCreated()) else if (m_fbo.IsCreated())
@ -2120,12 +2120,12 @@ void GLGSRender::Flip()
void GLGSRender::semaphorePGRAPHTextureReadRelease(u32 offset, u32 value) 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) 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) void GLGSRender::semaphorePFIFOAcquire(u32 offset, u32 value)

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

@ -67,8 +67,8 @@ GSLock::GSLock(GSRender& renderer, GSLockType type)
{ {
switch (m_type) switch (m_type)
{ {
case GS_LOCK_NOT_WAIT: m_renderer.m_cs_main.lock(); break; case GS_LOCK_NOT_WAIT: m_renderer.cs_main.lock(); break;
case GS_LOCK_WAIT_FLIP: m_renderer.m_sem_flip.wait(); break; case GS_LOCK_WAIT_FLIP: m_renderer.sem_flip.wait(); break;
} }
} }
@ -76,8 +76,8 @@ GSLock::~GSLock()
{ {
switch (m_type) switch (m_type)
{ {
case GS_LOCK_NOT_WAIT: m_renderer.m_cs_main.unlock(); break; case GS_LOCK_NOT_WAIT: m_renderer.cs_main.unlock(); break;
case GS_LOCK_WAIT_FLIP: m_renderer.m_sem_flip.try_post(); break; case GS_LOCK_WAIT_FLIP: m_renderer.sem_flip.try_post(); break;
} }
} }

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

@ -43,7 +43,7 @@ u32 GetAddress(u32 offset, u32 location)
throw EXCEPTION("RSXIO memory not mapped (offset=0x%x)", offset); 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 _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(); Flip();
m_last_flip_time = get_system_time(); last_flip_time = get_system_time();
m_gcm_current_buffer = ARGS(0); gcm_current_buffer = ARGS(0);
m_read_buffer = true; 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) 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 = [&]() 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); //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; 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); //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; u32 min_vertex_size = ~0;
for (auto &i : m_vertex_data) 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; min_vertex_size = vertex_size;
} }
m_draw_array_count = min_vertex_size; draw_array_count = min_vertex_size;
m_draw_array_first = 0; 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) 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); auto buffers = vm::get_ptr<CellGcmDisplayInfo>(m_gcm_buffers_addr);
m_width = buffers[m_gcm_current_buffer].width; m_width = buffers[gcm_current_buffer].width;
m_height = buffers[m_gcm_current_buffer].height; m_height = buffers[gcm_current_buffer].height;
CellVideoOutResolution res = ResolutionTable[ResolutionIdToNum(Ini.GSResolution.GetValue())]; CellVideoOutResolution res = ResolutionTable[ResolutionIdToNum(Ini.GSResolution.GetValue())];
m_width_scale = (float)res.width / m_width * 2.0f; 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 + 0x8, value);
//dma_write32(dma_report, offset + 0xc, 0); //dma_write32(dma_report, offset + 0xc, 0);
vm::ps3::write64(m_local_mem_addr + offset + 0x0, timestamp); vm::ps3::write64(local_mem_addr + offset + 0x0, timestamp);
vm::ps3::write32(m_local_mem_addr + offset + 0x8, value); vm::ps3::write32(local_mem_addr + offset + 0x8, value);
vm::ps3::write32(m_local_mem_addr + offset + 0xc, 0); vm::ps3::write32(local_mem_addr + offset + 0xc, 0);
break; break;
} }
@ -2340,7 +2340,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
{ {
const u32 cause = ARGS(0); const u32 cause = ARGS(0);
if (auto cb = m_user_handler) if (auto cb = user_handler)
{ {
Emu.GetCallbackManager().Async([=](CPUThread& cpu) 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_begin_end = 1;
m_draw_mode = draw_mode; draw_mode = drawMode;
m_draw_array_count = 0; draw_array_count = 0;
m_draw_array_first = ~0; draw_array_first = ~0;
} }
void RSXThread::End() void RSXThread::End()
@ -2495,23 +2495,23 @@ void RSXThread::Task()
oninit_thread(); 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]() autojoin_thread_t vblank(WRAP_EXPR("VBlank Thread"), [this]()
{ {
const u64 start_time = get_system_time(); const u64 start_time = get_system_time();
m_vblank_count = 0; vblank_count = 0;
while (joinable()) while (joinable())
{ {
CHECK_EMU_STATUS; 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) Emu.GetCallbackManager().Async([=](CPUThread& cpu)
{ {
@ -2528,7 +2528,7 @@ void RSXThread::Task()
while (joinable() && !Emu.IsStopped()) while (joinable() && !Emu.IsStopped())
{ {
std::lock_guard<std::mutex> lock(m_cs_main); std::lock_guard<std::mutex> lock(cs_main);
inc = 1; inc = 1;
@ -2605,7 +2605,7 @@ void RSXThread::Init(const u32 ioAddress, const u32 ioSize, const u32 ctrlAddres
m_ioAddress = ioAddress; m_ioAddress = ioAddress;
m_ioSize = ioSize; m_ioSize = ioSize;
m_ctrlAddress = ctrlAddress; m_ctrlAddress = ctrlAddress;
m_local_mem_addr = localAddress; local_mem_addr = localAddress;
m_cur_vertex_prog = nullptr; m_cur_vertex_prog = nullptr;
m_cur_fragment_prog = nullptr; m_cur_fragment_prog = nullptr;

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

@ -105,8 +105,8 @@ protected:
Timer m_timer_sync; Timer m_timer_sync;
public: public:
GcmTileInfo m_tiles[m_tiles_count]; GcmTileInfo tiles[m_tiles_count];
GcmZcullInfo m_zculls[m_zculls_count]; GcmZcullInfo zculls[m_zculls_count];
RSXTexture m_textures[m_textures_count]; RSXTexture m_textures[m_textures_count];
RSXVertexTexture m_vertex_textures[m_textures_count]; RSXVertexTexture m_vertex_textures[m_textures_count];
RSXVertexData m_vertex_data[m_vertex_count]; RSXVertexData m_vertex_data[m_vertex_count];
@ -122,45 +122,45 @@ public:
public: public:
u32 m_ioAddress, m_ioSize, m_ctrlAddress; u32 m_ioAddress, m_ioSize, m_ctrlAddress;
int m_flip_status; int flip_status;
int m_flip_mode; int flip_mode;
int m_debug_level; int debug_level;
int m_frequency_mode; int frequency_mode;
u32 m_tiles_addr; u32 tiles_addr;
u32 m_zculls_addr; u32 zculls_addr;
u32 m_gcm_buffers_addr; u32 m_gcm_buffers_addr;
u32 m_gcm_buffers_count; u32 gcm_buffers_count;
u32 m_gcm_current_buffer; u32 gcm_current_buffer;
u32 m_ctxt_addr; u32 ctxt_addr;
u32 m_report_main_addr; u32 report_main_addr;
u32 m_label_addr; u32 label_addr;
u32 draw_mode;
// DMA // DMA
u32 dma_report; u32 dma_report;
u32 m_local_mem_addr, m_main_mem_addr; u32 local_mem_addr, main_mem_addr;
bool m_strict_ordering[0x1000]; bool strict_ordering[0x1000];
public: public:
uint m_draw_mode; u32 draw_array_count;
u32 draw_array_first;
u32 m_width; u32 m_width;
u32 m_height; u32 m_height;
float m_width_scale; float m_width_scale;
float m_height_scale; float m_height_scale;
u32 m_draw_array_count;
u32 m_draw_array_first;
double m_fps_limit = 59.94; double m_fps_limit = 59.94;
public: public:
std::mutex m_cs_main; std::mutex cs_main;
semaphore_t m_sem_flip; semaphore_t sem_flip;
u64 m_last_flip_time; u64 last_flip_time;
vm::ps3::ptr<void(u32)> m_flip_handler; vm::ps3::ptr<void(u32)> flip_handler = { 0 };
vm::ps3::ptr<void(u32)> m_user_handler; vm::ps3::ptr<void(u32)> user_handler = { 0 };
u64 m_vblank_count; vm::ps3::ptr<void(u32)> vblank_handler = { 0 };
vm::ps3::ptr<void(u32)> m_vblank_handler; u64 vblank_count;
public: public:
// Dither // Dither
@ -450,22 +450,22 @@ protected:
RSXThread() RSXThread()
: m_ctrl(nullptr) : m_ctrl(nullptr)
, m_shader_ctrl(0x40) , m_shader_ctrl(0x40)
, m_flip_status(0) , flip_status(0)
, m_flip_mode(CELL_GCM_DISPLAY_VSYNC) , flip_mode(CELL_GCM_DISPLAY_VSYNC)
, m_debug_level(CELL_GCM_DEBUG_LEVEL0) , debug_level(CELL_GCM_DEBUG_LEVEL0)
, m_frequency_mode(CELL_GCM_DISPLAY_FREQUENCY_DISABLE) , frequency_mode(CELL_GCM_DISPLAY_FREQUENCY_DISABLE)
, m_report_main_addr(0) , report_main_addr(0)
, m_main_mem_addr(0) , main_mem_addr(0)
, m_local_mem_addr(0) , local_mem_addr(0)
, m_draw_mode(0) , draw_mode(0)
, m_draw_array_count(0) , draw_array_count(0)
, m_draw_array_first(~0) , draw_array_first(~0)
, m_gcm_current_buffer(0) , gcm_current_buffer(0)
, m_read_buffer(true) , m_read_buffer(true)
{ {
m_flip_handler.set(0); flip_handler.set(0);
m_vblank_handler.set(0); vblank_handler.set(0);
m_user_handler.set(0); user_handler.set(0);
m_set_depth_test = false; m_set_depth_test = false;
m_set_alpha_test = false; m_set_alpha_test = false;
m_set_depth_bounds_test = false; m_set_depth_bounds_test = false;

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

@ -102,7 +102,7 @@ vm::ptr<CellGcmReportData> cellGcmGetReportDataAddressLocation(u32 index, u32 lo
return vm::null; return vm::null;
} }
// TODO: It seems m_report_main_addr is not initialized // 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); cellGcmSys.Error("cellGcmGetReportDataAddressLocation: Wrong location (%d)", location);
@ -201,7 +201,7 @@ u64 cellGcmGetTimeStampLocation(u32 index, u32 location)
return 0; return 0;
} }
// TODO: It seems m_report_main_addr is not initialized // 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); cellGcmSys.Error("cellGcmGetTimeStampLocation: Wrong location (%d)", location);
@ -257,8 +257,8 @@ s32 cellGcmBindTile(u8 index)
return CELL_GCM_ERROR_INVALID_VALUE; return CELL_GCM_ERROR_INVALID_VALUE;
} }
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index]; auto& tile = Emu.GetGSManager().GetRender().tiles[index];
tile.m_binded = true; tile.binded = true;
return CELL_OK; return CELL_OK;
} }
@ -273,8 +273,8 @@ s32 cellGcmBindZcull(u8 index)
return CELL_GCM_ERROR_INVALID_VALUE; return CELL_GCM_ERROR_INVALID_VALUE;
} }
auto& zcull = Emu.GetGSManager().GetRender().m_zculls[index]; auto& zcull = Emu.GetGSManager().GetRender().zculls[index];
zcull.m_binded = true; zcull.binded = true;
return CELL_OK; return CELL_OK;
} }
@ -290,7 +290,7 @@ s32 cellGcmGetConfiguration(vm::ptr<CellGcmConfig> config)
s32 cellGcmGetFlipStatus() s32 cellGcmGetFlipStatus()
{ {
s32 status = Emu.GetGSManager().GetRender().m_flip_status; s32 status = Emu.GetGSManager().GetRender().flip_status;
cellGcmSys.Log("cellGcmGetFlipStatus() -> %d", status); cellGcmSys.Log("cellGcmGetFlipStatus() -> %d", status);
@ -388,14 +388,14 @@ s32 _cellGcmInitBody(vm::pptr<CellGcmContextData> context, u32 cmdSize, u32 ioSi
ctrl.ref = -1; ctrl.ref = -1;
auto& render = Emu.GetGSManager().GetRender(); 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_gcm_buffers_addr = vm::alloc(sizeof(CellGcmDisplayInfo) * 8, vm::main);
render.m_zculls_addr = vm::alloc(sizeof(CellGcmZcullInfo) * 8, vm::main); render.zculls_addr = vm::alloc(sizeof(CellGcmZcullInfo) * 8, vm::main);
render.m_tiles_addr = vm::alloc(sizeof(CellGcmTileInfo) * 15, vm::main); render.tiles_addr = vm::alloc(sizeof(CellGcmTileInfo) * 15, vm::main);
render.m_gcm_buffers_count = 0; render.gcm_buffers_count = 0;
render.m_gcm_current_buffer = 0; render.gcm_current_buffer = 0;
render.m_main_mem_addr = 0; render.main_mem_addr = 0;
render.m_label_addr = gcm_info.label_addr; render.label_addr = gcm_info.label_addr;
render.Init(g_defaultCommandBufferBegin, cmdSize, gcm_info.control_addr, local_addr); render.Init(g_defaultCommandBufferBegin, cmdSize, gcm_info.control_addr, local_addr);
return CELL_OK; return CELL_OK;
@ -405,7 +405,7 @@ s32 cellGcmResetFlipStatus()
{ {
cellGcmSys.Log("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; return CELL_OK;
} }
@ -419,7 +419,7 @@ s32 cellGcmSetDebugOutputLevel(s32 level)
case CELL_GCM_DEBUG_LEVEL0: case CELL_GCM_DEBUG_LEVEL0:
case CELL_GCM_DEBUG_LEVEL1: case CELL_GCM_DEBUG_LEVEL1:
case CELL_GCM_DEBUG_LEVEL2: case CELL_GCM_DEBUG_LEVEL2:
Emu.GetGSManager().GetRender().m_debug_level = level; Emu.GetGSManager().GetRender().debug_level = level;
break; break;
default: return CELL_EINVAL; 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].width = width;
buffers[id].height = height; 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; return CELL_OK;
@ -457,7 +457,7 @@ void cellGcmSetFlipHandler(vm::ptr<void(u32)> handler)
{ {
cellGcmSys.Warning("cellGcmSetFlipHandler(handler=*0x%x)", 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) s32 cellGcmSetFlipMode(u32 mode)
@ -469,7 +469,7 @@ s32 cellGcmSetFlipMode(u32 mode)
case CELL_GCM_DISPLAY_HSYNC: case CELL_GCM_DISPLAY_HSYNC:
case CELL_GCM_DISPLAY_VSYNC: case CELL_GCM_DISPLAY_VSYNC:
case CELL_GCM_DISPLAY_HSYNC_WITH_NOISE: case CELL_GCM_DISPLAY_HSYNC_WITH_NOISE:
Emu.GetGSManager().GetRender().m_flip_mode = mode; Emu.GetGSManager().GetRender().flip_mode = mode;
break; break;
default: default:
@ -483,7 +483,7 @@ void cellGcmSetFlipStatus()
{ {
cellGcmSys.Warning("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) s32 cellGcmSetPrepareFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> ctxt, u32 id)
@ -535,11 +535,11 @@ s32 cellGcmSetSecondVFrequency(u32 freq)
switch (freq) switch (freq)
{ {
case CELL_GCM_DISPLAY_FREQUENCY_59_94HZ: 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: 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: 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; 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); cellGcmSys.Error("cellGcmSetTileInfo: bad compression mode! (%d)", comp);
} }
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index]; auto& tile = Emu.GetGSManager().GetRender().tiles[index];
tile.m_location = location; tile.location = location;
tile.m_offset = offset; tile.offset = offset;
tile.m_size = size; tile.size = size;
tile.m_pitch = pitch; tile.pitch = pitch;
tile.m_comp = comp; tile.comp = comp;
tile.m_base = base; tile.base = base;
tile.m_bank = bank; 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; return CELL_OK;
} }
@ -591,7 +591,7 @@ void cellGcmSetUserHandler(vm::ptr<void(u32)> handler)
{ {
cellGcmSys.Warning("cellGcmSetUserHandler(handler=*0x%x)", handler); cellGcmSys.Warning("cellGcmSetUserHandler(handler=*0x%x)", handler);
Emu.GetGSManager().GetRender().m_user_handler = handler; Emu.GetGSManager().GetRender().user_handler = handler;
} }
s32 cellGcmSetUserCommand() s32 cellGcmSetUserCommand()
@ -603,7 +603,7 @@ void cellGcmSetVBlankHandler(vm::ptr<void(u32)> handler)
{ {
cellGcmSys.Warning("cellGcmSetVBlankHandler(handler=*0x%x)", 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) 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; return CELL_GCM_ERROR_INVALID_VALUE;
} }
auto& zcull = Emu.GetGSManager().GetRender().m_zculls[index]; auto& zcull = Emu.GetGSManager().GetRender().zculls[index];
zcull.m_offset = offset; zcull.offset = offset;
zcull.m_width = width; zcull.width = width;
zcull.m_height = height; zcull.height = height;
zcull.m_cullStart = cullStart; zcull.cullStart = cullStart;
zcull.m_zFormat = zFormat; zcull.zFormat = zFormat;
zcull.m_aaFormat = aaFormat; zcull.aaFormat = aaFormat;
zcull.m_zcullDir = zCullDir; zcull.zcullDir = zCullDir;
zcull.m_zcullFormat = zCullFormat; zcull.zcullFormat = zCullFormat;
zcull.m_sFunc = sFunc; zcull.sFunc = sFunc;
zcull.m_sRef = sRef; zcull.sRef = sRef;
zcull.m_sMask = sMask; 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; return CELL_OK;
} }
@ -658,8 +658,8 @@ s32 cellGcmUnbindTile(u8 index)
return CELL_GCM_ERROR_INVALID_VALUE; return CELL_GCM_ERROR_INVALID_VALUE;
} }
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index]; auto& tile = Emu.GetGSManager().GetRender().tiles[index];
tile.m_binded = false; tile.binded = false;
return CELL_OK; return CELL_OK;
} }
@ -674,8 +674,8 @@ s32 cellGcmUnbindZcull(u8 index)
return CELL_EINVAL; return CELL_EINVAL;
} }
auto& zcull = Emu.GetGSManager().GetRender().m_zculls[index]; auto& zcull = Emu.GetGSManager().GetRender().zculls[index];
zcull.m_binded = false; zcull.binded = false;
return CELL_OK; return CELL_OK;
} }
@ -683,13 +683,13 @@ s32 cellGcmUnbindZcull(u8 index)
u32 cellGcmGetTileInfo() u32 cellGcmGetTileInfo()
{ {
cellGcmSys.Warning("cellGcmGetTileInfo()"); cellGcmSys.Warning("cellGcmGetTileInfo()");
return Emu.GetGSManager().GetRender().m_tiles_addr; return Emu.GetGSManager().GetRender().tiles_addr;
} }
u32 cellGcmGetZcullInfo() u32 cellGcmGetZcullInfo()
{ {
cellGcmSys.Warning("cellGcmGetZcullInfo()"); cellGcmSys.Warning("cellGcmGetZcullInfo()");
return Emu.GetGSManager().GetRender().m_zculls_addr; return Emu.GetGSManager().GetRender().zculls_addr;
} }
u32 cellGcmGetDisplayInfo() u32 cellGcmGetDisplayInfo()
@ -702,12 +702,12 @@ s32 cellGcmGetCurrentDisplayBufferId(vm::ptr<u8> id)
{ {
cellGcmSys.Warning("cellGcmGetCurrentDisplayBufferId(id=*0x%x)", 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"); throw EXCEPTION("Unexpected");
} }
*id = Emu.GetGSManager().GetRender().m_gcm_current_buffer; *id = Emu.GetGSManager().GetRender().gcm_current_buffer;
return CELL_OK; return CELL_OK;
} }
@ -739,7 +739,7 @@ u64 cellGcmGetLastFlipTime()
{ {
cellGcmSys.Log("cellGcmGetLastFlipTime()"); cellGcmSys.Log("cellGcmGetLastFlipTime()");
return Emu.GetGSManager().GetRender().m_last_flip_time; return Emu.GetGSManager().GetRender().last_flip_time;
} }
u64 cellGcmGetLastSecondVTime() u64 cellGcmGetLastSecondVTime()
@ -752,7 +752,7 @@ u64 cellGcmGetVBlankCount()
{ {
cellGcmSys.Log("cellGcmGetVBlankCount()"); cellGcmSys.Log("cellGcmGetVBlankCount()");
return Emu.GetGSManager().GetRender().m_vblank_count; return Emu.GetGSManager().GetRender().vblank_count;
} }
s32 cellGcmSysGetLastVBlankTime() 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.ioAddress[(ea >> 20) + i] = (io >> 20) + i;
offsetTable.eaAddress[(io >> 20) + i] = (ea >> 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 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.ioAddress[(ea >> 20) + i] = (u16)((io >> 20) + i);
offsetTable.eaAddress[(io >> 20) + i] = (u16)((ea >> 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; *offset = io;
@ -968,7 +968,7 @@ s32 cellGcmMapMainMemory(u32 ea, u32 size, vm::ptr<u32> offset)
return CELL_GCM_ERROR_NO_IO_PAGE_TABLE; 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; return CELL_OK;
} }
@ -1108,7 +1108,7 @@ s32 cellGcmSetCursorImageOffset(u32 offset)
void cellGcmSetDefaultCommandBuffer() void cellGcmSetDefaultCommandBuffer()
{ {
cellGcmSys.Warning("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() 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); cellGcmSys.Error("cellGcmSetTile: bad compression mode! (%d)", comp);
} }
auto& tile = Emu.GetGSManager().GetRender().m_tiles[index]; auto& tile = Emu.GetGSManager().GetRender().tiles[index];
tile.m_location = location; tile.location = location;
tile.m_offset = offset; tile.offset = offset;
tile.m_size = size; tile.size = size;
tile.m_pitch = pitch; tile.pitch = pitch;
tile.m_comp = comp; tile.comp = comp;
tile.m_base = base; tile.base = base;
tile.m_bank = bank; 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; return CELL_OK;
} }

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

@ -1075,21 +1075,21 @@ void cellRescSetFlipHandler(vm::ptr<void(u32)> handler)
{ {
cellResc.Warning("cellRescSetFlipHandler(handler=*0x%x)", handler); cellResc.Warning("cellRescSetFlipHandler(handler=*0x%x)", handler);
Emu.GetGSManager().GetRender().m_flip_handler = handler; Emu.GetGSManager().GetRender().flip_handler = handler;
} }
void cellRescResetFlipStatus() void cellRescResetFlipStatus()
{ {
cellResc.Log("cellRescResetFlipStatus()"); cellResc.Log("cellRescResetFlipStatus()");
Emu.GetGSManager().GetRender().m_flip_status = 1; Emu.GetGSManager().GetRender().flip_status = 1;
} }
s32 cellRescGetFlipStatus() s32 cellRescGetFlipStatus()
{ {
cellResc.Log("cellRescGetFlipStatus()"); cellResc.Log("cellRescGetFlipStatus()");
return Emu.GetGSManager().GetRender().m_flip_status; return Emu.GetGSManager().GetRender().flip_status;
} }
s32 cellRescGetRegisterCount() s32 cellRescGetRegisterCount()
@ -1102,7 +1102,7 @@ u64 cellRescGetLastFlipTime()
{ {
cellResc.Log("cellRescGetLastFlipTime()"); cellResc.Log("cellRescGetLastFlipTime()");
return Emu.GetGSManager().GetRender().m_last_flip_time; return Emu.GetGSManager().GetRender().last_flip_time;
} }
s32 cellRescSetRegisterCount() s32 cellRescSetRegisterCount()
@ -1115,7 +1115,7 @@ void cellRescSetVBlankHandler(vm::ptr<void(u32)> handler)
{ {
cellResc.Warning("cellRescSetVBlankHandler(handler=*0x%x)", 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) u16 FloatToHalf(float val)

10
rpcs3/Gui/RSXDebugger.cpp
View file

@ -304,7 +304,7 @@ void RSXDebugger::OnClickBuffer(wxMouseEvent& event)
// TODO: Is there any better way to choose the color buffers // TODO: Is there any better way to choose the color buffers
#define SHOW_BUFFER(id) \ #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) \ if (vm::check_addr(addr) && buffers[id].width && buffers[id].height) \
MemoryViewerPanel::ShowImage(this, addr, 3, buffers[id].width, buffers[id].height, true); \ MemoryViewerPanel::ShowImage(this, addr, 3, buffers[id].width, buffers[id].height, true); \
return; \ return; \
@ -408,13 +408,13 @@ void RSXDebugger::GetBuffers()
// Draw Buffers // Draw Buffers
// TODO: Currently it only supports color 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)) if(!vm::check_addr(render.m_gcm_buffers_addr))
continue; continue;
auto buffers = vm::get_ptr<CellGcmDisplayInfo>(render.m_gcm_buffers_addr); 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)) if(!vm::check_addr(RSXbuffer_addr))
continue; continue;
@ -616,8 +616,8 @@ void RSXDebugger::GetSettings()
render.m_depth_func, render.m_depth_func,
ParseGCMEnum(render.m_depth_func, CELL_GCM_ENUM))); ParseGCMEnum(render.m_depth_func, CELL_GCM_ENUM)));
LIST_SETTINGS_ADD("Draw mode", wxString::Format("%d (%s)", LIST_SETTINGS_ADD("Draw mode", wxString::Format("%d (%s)",
render.m_draw_mode, render.draw_mode,
ParseGCMEnum(render.m_draw_mode, CELL_GCM_PRIMITIVE_ENUM))); ParseGCMEnum(render.draw_mode, CELL_GCM_PRIMITIVE_ENUM)));
LIST_SETTINGS_ADD("Scissor", wxString::Format("X:%d, Y:%d, W:%d, H:%d", LIST_SETTINGS_ADD("Scissor", wxString::Format("X:%d, Y:%d, W:%d, H:%d",
render.m_scissor_x, render.m_scissor_x,
render.m_scissor_y, render.m_scissor_y,