mirror/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-02-28 12:40:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Optimization

Browse Source
This commit is contained in:
Nekotekina 2015-12-02 12:23:25 +03:00
parent 298eb46a31
commit 24128ba450
10 changed files with 152 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
Utilities/types.h
View File

@ -1,4 +1,5 @@
#pragma once
#include <typeinfo>
#include <cstdint>
#include <cmath>
@ -12,15 +13,15 @@ using ullong = unsigned long long;
using llong = long long;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using u8 = std::uint8_t;
using u16 = std::uint16_t;
using u32 = std::uint32_t;
using u64 = std::uint64_t;
using s8 = int8_t;
using s16 = int16_t;
using s32 = int32_t;
using s64 = int64_t;
using s8 = std::int8_t;
using s16 = std::int16_t;
using s32 = std::int32_t;
using s64 = std::int64_t;
union alignas(2) f16
{
@ -46,18 +47,6 @@ union alignas(2) f16
using f32 = float;
using f64 = double;
#include "BEType.h"
template<typename T>
class pi_t
{
public:
static constexpr T value = T(3.141592653589793238462643383279502884197169399375105820974944592307816406286);
};
template<typename T>
using pi = pi_t<T>;
struct ignore
{
template<typename T>
@ -1103,12 +1092,11 @@ using color1d = color1_base<double>;
namespace std
{
template<>
class hash<position2i>
struct hash<::position2i>
{
public:
size_t operator()(const position2i& position) const
size_t operator()(const ::position2i& position) const
{
return ((size_t)position.x << 32) | position.y;
return (static_cast<size_t>(position.x) << 32) | position.y;
}
};
}

223
rpcs3/Emu/RSX/GCM.cpp
View File

@ -3,7 +3,7 @@
namespace
{
const std::unordered_map<u32, std::string> methods =
const std::unordered_map<u32, const char*> methods =
{
{ NV4097_NO_OPERATION, "NV4097_NO_OPERATION" },
{ NV4097_NOTIFY, "NV4097_NOTIFY" },
@ -703,17 +703,16 @@ namespace
{ NV4097_SET_SHADER_PACKER, "NV4097_SET_SHADER_PACKER" },
{ NV4097_SET_VERTEX_ATTRIB_INPUT_MASK, "NV4097_SET_VERTEX_ATTRIB_INPUT_MASK" },
{ NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK, "NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK" },
{ NV4097_SET_TRANSFORM_BRANCH_BITS, "NV4097_SET_TRANSFORM_BRANCH_BITS" }
{ NV4097_SET_TRANSFORM_BRANCH_BITS, "NV4097_SET_TRANSFORM_BRANCH_BITS" },
};
}
std::string rsx::get_method_name(const u32 id) noexcept
std::string rsx::get_method_name(const u32 id)
{
auto found = methods.find(id);
if (found != methods.end())
{
return "CELL_GCM_" + found->second;
return "CELL_GCM_"s + found->second;
}
return fmt::format("unknown/illegal method [0x%08x]", id);
@ -820,9 +819,7 @@ namespace
std::string ptr_to_string(u32 ptr) noexcept
{
std::stringstream ss;
ss << (void*)(u64)ptr;
return ss.str();
return fmt::format("0x%08x", ptr);
}
std::string dma_mode(u32 arg) noexcept
@ -1116,7 +1113,7 @@ namespace
}
#define OPCODE_RANGE_1(opcode, increment, index, printing_function) \
{ (opcode) + (index) * (increment), [](u32 arg) { return (printing_function)((index), arg); } },
{ (opcode) + (index) * (increment), [](u32 arg) -> std::string { return (printing_function)((index), arg); } },
#define OPCODE_RANGE_2(opcode, increment, index, printing_function) \
OPCODE_RANGE_1((opcode), (increment), (index), (printing_function)) \
@ -1138,107 +1135,107 @@ namespace
OPCODE_RANGE_16((opcode), (increment), (index), (printing_function)) \
OPCODE_RANGE_16((opcode), (increment), (index) + 16, (printing_function))
const std::unordered_map<u32, std::function<std::string(u32)> > printing_functions =
const std::unordered_map<u32, std::string(*)(u32)> printing_functions =
{
{ NV4097_NO_OPERATION , [](u32) { return "(nop)"; } },
{ NV4097_SET_ALPHA_TEST_ENABLE, [](u32 arg) { return (!!arg) ? "Alpha: enable" : "Alpha: disable"; } },
{ NV4097_SET_DEPTH_TEST_ENABLE, [](u32 arg) { return (!!arg) ? "Depth: enable" : "Depth: disable"; } },
{ NV4097_SET_DEPTH_MASK, [](u32 arg) { return (!!arg) ? "Depth: write enabled" : "Depth: write disabled"; } },
{ NV4097_SET_DEPTH_FUNC, [](u32 arg) { return "Depth: " + get_compare_func(arg); } },
{ NV4097_SET_LOGIC_OP_ENABLE, [](u32 arg) { return (!!arg) ? "Logic Op: enable" : "Logic Op: disable"; } },
{ NV4097_SET_LOGIC_OP, [](u32 arg) { return "Logic Op: " + get_logic_op(arg); } },
{ NV4097_SET_BLEND_ENABLE, [](u32 arg) { return (!!arg) ? "Blend: enable" : "Blend: disable"; } },
{ NV4097_SET_BLEND_FUNC_SFACTOR, [](u32 arg) { return "Blend: sfactor.rgb = " + get_blend_factor(arg & 0xFFFF) + " sfactor.a = " + get_blend_factor(arg >> 16); } },
{ NV4097_SET_BLEND_FUNC_DFACTOR, [](u32 arg) { return "Blend: dfactor.rgb = " + get_blend_factor(arg & 0xFFFF) + " dfactor.a = " + get_blend_factor(arg >> 16); } },
{ NV4097_SET_BLEND_EQUATION , [](u32 arg) { return "Blend: op.rgb = " + get_blend_op(arg & 0xFFFF) + " op.a = " + get_blend_op(arg >> 16); } },
{ NV4097_SET_BLEND_ENABLE_MRT, [](u32 arg) { return "Blend: mrt0 = " + std::to_string(!!(arg & 0x2)) + " mrt1 = " + std::to_string(!!(arg & 0x4)) + " mrt2 = " + std::to_string(!!(arg & 0x8)); } },
{ NV4097_SET_COLOR_MASK , [](u32 arg) { return "Color mask: A = " + std::to_string(!!(arg & 0x1000000)) + " R = " + std::to_string(!!(arg & 0x10000)) + " G = " + std::to_string(!!(arg & 0x100)) + " B = " + std::to_string(!!(arg & 0x1)); } },
{ NV4097_SET_VIEWPORT_HORIZONTAL, [](u32 arg) { return "Viewport: x = " + std::to_string(arg & 0xFFFF) + " width = " + std::to_string(arg >> 16); } },
{ NV4097_SET_VIEWPORT_VERTICAL, [](u32 arg) { return "Viewport: y = " + std::to_string(arg & 0xFFFF) + " height = " + std::to_string(arg >> 16); } },
{ NV4097_SET_BEGIN_END, [](u32 arg) { return arg ? "- Begin: " + get_primitive_mode(arg) + " -" : "- End -"; } },
{ NV4097_DRAW_ARRAYS, [](u32 arg) { return "Draw " + std::to_string((arg >> 24) + 1) + " vertex starting from " + std::to_string(arg & 0xFFFFFF); } },
{ NV4097_DRAW_INDEX_ARRAY, [](u32 arg) { return "Draw " + std::to_string((arg >> 24) + 1) + " index starting from " + std::to_string(arg & 0xFFFFFF); } },
{ NV4097_SET_SEMAPHORE_OFFSET, [](u32 arg) { return "Semaphore: @ " + ptr_to_string(arg); } },
{ NV4097_TEXTURE_READ_SEMAPHORE_RELEASE, [](u32 arg) { return "Write semaphore value " + std::to_string(arg); } },
{ NV4097_CLEAR_SURFACE, [](u32 arg) { return "Clear surface " + std::string(arg & 0x1 ? "Depth " : "") + std::string(arg & 0x2 ? "Stencil " : "") + std::string(arg & 0xF0 ? "Color " : ""); } },
{ NV4097_SET_CONTEXT_DMA_COLOR_A, [](u32 arg) { return "Surface A: DMA mode = " + dma_mode(arg);} },
{ NV4097_SET_SURFACE_PITCH_A, [](u32 arg) { return "Surface A: Pitch = " + std::to_string(arg); } },
{ NV4097_SET_SURFACE_COLOR_AOFFSET, [](u32 arg) { return "Surface A: Offset = " + ptr_to_string(arg); } },
{ NV4097_SET_CONTEXT_DMA_COLOR_B, [](u32 arg) { return "Surface B: DMA mode = " + dma_mode(arg);} },
{ NV4097_SET_SURFACE_PITCH_B, [](u32 arg) { return "Surface B: Pitch = " + std::to_string(arg); } },
{ NV4097_SET_SURFACE_COLOR_BOFFSET, [](u32 arg) { return "Surface B: Offset = " + ptr_to_string(arg); } },
{ NV4097_SET_CONTEXT_DMA_COLOR_C, [](u32 arg) { return "Surface C: DMA mode = " + dma_mode(arg);} },
{ NV4097_SET_SURFACE_PITCH_C, [](u32 arg) { return "Surface C: Pitch = " + std::to_string(arg); } },
{ NV4097_SET_SURFACE_COLOR_COFFSET, [](u32 arg) { return "Surface C: Offset = " + ptr_to_string(arg); } },
{ NV4097_SET_SURFACE_PITCH_D, [](u32 arg) { return "Surface D: Pitch = " + std::to_string(arg); } },
{ NV4097_SET_SURFACE_COLOR_DOFFSET, [](u32 arg) { return "Surface D: Offset = " + ptr_to_string(arg); } },
{ NV4097_SET_CONTEXT_DMA_COLOR_D, [](u32 arg) { return "Surface D: DMA mode = " + dma_mode(arg);} },
{ NV4097_SET_SURFACE_PITCH_Z, [](u32 arg) { return "Surface Zeta: Pitch = " + std::to_string(arg); } },
{ NV4097_SET_SURFACE_ZETA_OFFSET, [](u32 arg) { return "Surface Zeta: Offset = " + ptr_to_string(arg); } },
{ NV4097_SET_CONTEXT_DMA_ZETA, [](u32 arg) { return "Surface Zeta: DMA mode = " + dma_mode(arg);} },
{ NV4097_SET_SURFACE_FORMAT, [](u32 arg) { return "Surface: Color format = " + color_surface_format(arg & 0x1F) + " DepthStencil format = " + depth_stencil_surface_format((arg >> 5) & 0x7); } },
{ NV4097_SET_SURFACE_CLIP_HORIZONTAL, [](u32 arg) { return "Surface: clip x = " + std::to_string(arg & 0xFFFF) + " width = " + std::to_string(arg >> 16); } },
{ NV4097_SET_SURFACE_CLIP_VERTICAL, [](u32 arg) { return "Surface: clip y = " + std::to_string(arg & 0xFFFF) + " height = " + std::to_string(arg >> 16); } },
{ NV4097_SET_SURFACE_COLOR_TARGET, [](u32 arg) { return "Surface: Targets " + surface_target(arg); } },
{ NV4097_SET_COLOR_CLEAR_VALUE, [](u32 arg) { return "Clear: " + get_clear_color(arg); } },
{ NV4097_SET_ZSTENCIL_CLEAR_VALUE, [](u32 arg) { return "Clear: " + get_zstencil_clear(arg); } },
{ NV4097_SET_CLIP_MIN, [](u32 arg) { return "Depth: Min = " + std::to_string((f32&)arg); } },
{ NV4097_SET_CLIP_MAX, [](u32 arg) { return "Depth: Max = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_SCALE, [](u32 arg) { return "Viewport: x scale = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_SCALE + 1, [](u32 arg) { return "Viewport: y scale = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_SCALE + 2, [](u32 arg) { return "Viewport: z scale = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_OFFSET, [](u32 arg) { return "Viewport: x offset = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_OFFSET + 1, [](u32 arg) { return "Viewport: y offset = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_OFFSET + 2, [](u32 arg) { return "Viewport: z offset = " + std::to_string((f32&)arg); } },
{ NV4097_SET_SCISSOR_HORIZONTAL, [](u32 arg) { return "Scissor: x = " + std::to_string(arg & 0xFFFF) + " width = " + std::to_string(arg >> 16); } },
{ NV4097_SET_SCISSOR_VERTICAL, [](u32 arg) { return "Scissor: y = " + std::to_string(arg & 0xFFFF) + " height = " + std::to_string(arg >> 16); } },
{ NV4097_SET_STENCIL_TEST_ENABLE, [](u32 arg) { return (!!arg) ? "Stencil: Enable" : "Stencil : Disable"; } },
{ NV4097_SET_STENCIL_FUNC, [](u32 arg) { return "Stencil: " + get_compare_func(arg); } },
{ NV4097_SET_BACK_STENCIL_OP_ZPASS, [](u32 arg) { return "Stencil: Back ZPass = " + get_stencil_op(arg); } },
{ NV4097_SET_BACK_STENCIL_OP_ZFAIL, [](u32 arg) { return "Stencil: Back ZFail = " + get_stencil_op(arg); } },
{ NV4097_SET_BACK_STENCIL_OP_FAIL, [](u32 arg) { return "Stencil: Back Fail = " + get_stencil_op(arg); } },
{ NV4097_SET_STENCIL_OP_ZPASS, [](u32 arg) { return "Stencil: ZPass = " + get_stencil_op(arg); } },
{ NV4097_SET_STENCIL_OP_ZFAIL, [](u32 arg) { return "Stencil: ZFail = " + get_stencil_op(arg); } },
{ NV4097_SET_STENCIL_OP_FAIL, [](u32 arg) { return "Stencil: Fail = " + get_stencil_op(arg); } },
{ NV4097_SET_STENCIL_FUNC_MASK, [](u32 arg) { return "Stencil: Func mask = " + ptr_to_string(arg); } },
{ NV4097_SET_STENCIL_MASK, [](u32 arg) { return "Stencil: Mask = " + ptr_to_string(arg); } },
{ NV4097_SET_STENCIL_FUNC_REF, [](u32 arg) { return "Stencil: Ref = " + std::to_string(arg); } },
{ NV4097_INVALIDATE_VERTEX_CACHE_FILE, [](u32) { return "(invalidate vertex cache file)"; } },
{ NV4097_INVALIDATE_VERTEX_FILE, [](u32) { return "(invalidate vertex file)"; } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT, [](u32 arg) { return "Vertex array 0: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 1, [](u32 arg) { return "Vertex array 1: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 2, [](u32 arg) { return "Vertex array 2: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 3, [](u32 arg) { return "Vertex array 3: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 4, [](u32 arg) { return "Vertex array 4: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 5, [](u32 arg) { return "Vertex array 5: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 6, [](u32 arg) { return "Vertex array 6: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 7, [](u32 arg) { return "Vertex array 7: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 8, [](u32 arg) { return "Vertex array 8: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 9, [](u32 arg) { return "Vertex array 9: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 10, [](u32 arg) { return "Vertex array 10: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 11, [](u32 arg) { return "Vertex array 11: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 12, [](u32 arg) { return "Vertex array 12: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 13, [](u32 arg) { return "Vertex array 13: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 14, [](u32 arg) { return "Vertex array 14: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 15, [](u32 arg) { return "Vertex array 15: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET, [](u32 arg) { return "Vertex array 0: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 1, [](u32 arg) { return "Vertex array 1: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 2, [](u32 arg) { return "Vertex array 2: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 3, [](u32 arg) { return "Vertex array 3: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 4, [](u32 arg) { return "Vertex array 4: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 5, [](u32 arg) { return "Vertex array 5: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 6, [](u32 arg) { return "Vertex array 6: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 7, [](u32 arg) { return "Vertex array 7: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 8, [](u32 arg) { return "Vertex array 8: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 9, [](u32 arg) { return "Vertex array 9: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 10, [](u32 arg) { return "Vertex array 10: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 11, [](u32 arg) { return "Vertex array 11: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 12, [](u32 arg) { return "Vertex array 12: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 13, [](u32 arg) { return "Vertex array 13: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 14, [](u32 arg) { return "Vertex array 14: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 15, [](u32 arg) { return "Vertex array 15: Offset = " + std::to_string(arg); } },
{ NV4097_SET_INDEX_ARRAY_ADDRESS, [](u32 arg) { return "Index array: Address = " + ptr_to_string(arg); } },
{ NV4097_SET_INDEX_ARRAY_DMA, [](u32 arg) { return "Index array: DMA mode = " + dma_mode(arg & 0xF) + " type = " + index_type(arg >> 4); } },
{ NV4097_NO_OPERATION , [](u32) -> std::string { return "(nop)"; } },
{ NV4097_SET_ALPHA_TEST_ENABLE, [](u32 arg) -> std::string { return (!!arg) ? "Alpha: enable" : "Alpha: disable"; } },
{ NV4097_SET_DEPTH_TEST_ENABLE, [](u32 arg) -> std::string { return (!!arg) ? "Depth: enable" : "Depth: disable"; } },
{ NV4097_SET_DEPTH_MASK, [](u32 arg) -> std::string { return (!!arg) ? "Depth: write enabled" : "Depth: write disabled"; } },
{ NV4097_SET_DEPTH_FUNC, [](u32 arg) -> std::string { return "Depth: " + get_compare_func(arg); } },
{ NV4097_SET_LOGIC_OP_ENABLE, [](u32 arg) -> std::string { return (!!arg) ? "Logic Op: enable" : "Logic Op: disable"; } },
{ NV4097_SET_LOGIC_OP, [](u32 arg) -> std::string { return "Logic Op: " + get_logic_op(arg); } },
{ NV4097_SET_BLEND_ENABLE, [](u32 arg) -> std::string { return (!!arg) ? "Blend: enable" : "Blend: disable"; } },
{ NV4097_SET_BLEND_FUNC_SFACTOR, [](u32 arg) -> std::string { return "Blend: sfactor.rgb = " + get_blend_factor(arg & 0xFFFF) + " sfactor.a = " + get_blend_factor(arg >> 16); } },
{ NV4097_SET_BLEND_FUNC_DFACTOR, [](u32 arg) -> std::string { return "Blend: dfactor.rgb = " + get_blend_factor(arg & 0xFFFF) + " dfactor.a = " + get_blend_factor(arg >> 16); } },
{ NV4097_SET_BLEND_EQUATION , [](u32 arg) -> std::string { return "Blend: op.rgb = " + get_blend_op(arg & 0xFFFF) + " op.a = " + get_blend_op(arg >> 16); } },
{ NV4097_SET_BLEND_ENABLE_MRT, [](u32 arg) -> std::string { return "Blend: mrt0 = " + std::to_string(!!(arg & 0x2)) + " mrt1 = " + std::to_string(!!(arg & 0x4)) + " mrt2 = " + std::to_string(!!(arg & 0x8)); } },
{ NV4097_SET_COLOR_MASK , [](u32 arg) -> std::string { return "Color mask: A = " + std::to_string(!!(arg & 0x1000000)) + " R = " + std::to_string(!!(arg & 0x10000)) + " G = " + std::to_string(!!(arg & 0x100)) + " B = " + std::to_string(!!(arg & 0x1)); } },
{ NV4097_SET_VIEWPORT_HORIZONTAL, [](u32 arg) -> std::string { return "Viewport: x = " + std::to_string(arg & 0xFFFF) + " width = " + std::to_string(arg >> 16); } },
{ NV4097_SET_VIEWPORT_VERTICAL, [](u32 arg) -> std::string { return "Viewport: y = " + std::to_string(arg & 0xFFFF) + " height = " + std::to_string(arg >> 16); } },
{ NV4097_SET_BEGIN_END, [](u32 arg) -> std::string { return arg ? "- Begin: " + get_primitive_mode(arg) + " -" : "- End -"; } },
{ NV4097_DRAW_ARRAYS, [](u32 arg) -> std::string { return "Draw " + std::to_string((arg >> 24) + 1) + " vertex starting from " + std::to_string(arg & 0xFFFFFF); } },
{ NV4097_DRAW_INDEX_ARRAY, [](u32 arg) -> std::string { return "Draw " + std::to_string((arg >> 24) + 1) + " index starting from " + std::to_string(arg & 0xFFFFFF); } },
{ NV4097_SET_SEMAPHORE_OFFSET, [](u32 arg) -> std::string { return "Semaphore: @ " + ptr_to_string(arg); } },
{ NV4097_TEXTURE_READ_SEMAPHORE_RELEASE, [](u32 arg) -> std::string { return "Write semaphore value " + std::to_string(arg); } },
{ NV4097_CLEAR_SURFACE, [](u32 arg) -> std::string { return "Clear surface " + std::string(arg & 0x1 ? "Depth " : "") + std::string(arg & 0x2 ? "Stencil " : "") + std::string(arg & 0xF0 ? "Color " : ""); } },
{ NV4097_SET_CONTEXT_DMA_COLOR_A, [](u32 arg) -> std::string { return "Surface A: DMA mode = " + dma_mode(arg);} },
{ NV4097_SET_SURFACE_PITCH_A, [](u32 arg) -> std::string { return "Surface A: Pitch = " + std::to_string(arg); } },
{ NV4097_SET_SURFACE_COLOR_AOFFSET, [](u32 arg) -> std::string { return "Surface A: Offset = " + ptr_to_string(arg); } },
{ NV4097_SET_CONTEXT_DMA_COLOR_B, [](u32 arg) -> std::string { return "Surface B: DMA mode = " + dma_mode(arg);} },
{ NV4097_SET_SURFACE_PITCH_B, [](u32 arg) -> std::string { return "Surface B: Pitch = " + std::to_string(arg); } },
{ NV4097_SET_SURFACE_COLOR_BOFFSET, [](u32 arg) -> std::string { return "Surface B: Offset = " + ptr_to_string(arg); } },
{ NV4097_SET_CONTEXT_DMA_COLOR_C, [](u32 arg) -> std::string { return "Surface C: DMA mode = " + dma_mode(arg);} },
{ NV4097_SET_SURFACE_PITCH_C, [](u32 arg) -> std::string { return "Surface C: Pitch = " + std::to_string(arg); } },
{ NV4097_SET_SURFACE_COLOR_COFFSET, [](u32 arg) -> std::string { return "Surface C: Offset = " + ptr_to_string(arg); } },
{ NV4097_SET_SURFACE_PITCH_D, [](u32 arg) -> std::string { return "Surface D: Pitch = " + std::to_string(arg); } },
{ NV4097_SET_SURFACE_COLOR_DOFFSET, [](u32 arg) -> std::string { return "Surface D: Offset = " + ptr_to_string(arg); } },
{ NV4097_SET_CONTEXT_DMA_COLOR_D, [](u32 arg) -> std::string { return "Surface D: DMA mode = " + dma_mode(arg);} },
{ NV4097_SET_SURFACE_PITCH_Z, [](u32 arg) -> std::string { return "Surface Zeta: Pitch = " + std::to_string(arg); } },
{ NV4097_SET_SURFACE_ZETA_OFFSET, [](u32 arg) -> std::string { return "Surface Zeta: Offset = " + ptr_to_string(arg); } },
{ NV4097_SET_CONTEXT_DMA_ZETA, [](u32 arg) -> std::string { return "Surface Zeta: DMA mode = " + dma_mode(arg);} },
{ NV4097_SET_SURFACE_FORMAT, [](u32 arg) -> std::string { return "Surface: Color format = " + color_surface_format(arg & 0x1F) + " DepthStencil format = " + depth_stencil_surface_format((arg >> 5) & 0x7); } },
{ NV4097_SET_SURFACE_CLIP_HORIZONTAL, [](u32 arg) -> std::string { return "Surface: clip x = " + std::to_string(arg & 0xFFFF) + " width = " + std::to_string(arg >> 16); } },
{ NV4097_SET_SURFACE_CLIP_VERTICAL, [](u32 arg) -> std::string { return "Surface: clip y = " + std::to_string(arg & 0xFFFF) + " height = " + std::to_string(arg >> 16); } },
{ NV4097_SET_SURFACE_COLOR_TARGET, [](u32 arg) -> std::string { return "Surface: Targets " + surface_target(arg); } },
{ NV4097_SET_COLOR_CLEAR_VALUE, [](u32 arg) -> std::string { return "Clear: " + get_clear_color(arg); } },
{ NV4097_SET_ZSTENCIL_CLEAR_VALUE, [](u32 arg) -> std::string { return "Clear: " + get_zstencil_clear(arg); } },
{ NV4097_SET_CLIP_MIN, [](u32 arg) -> std::string { return "Depth: Min = " + std::to_string((f32&)arg); } },
{ NV4097_SET_CLIP_MAX, [](u32 arg) -> std::string { return "Depth: Max = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_SCALE, [](u32 arg) -> std::string { return "Viewport: x scale = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_SCALE + 1, [](u32 arg) -> std::string { return "Viewport: y scale = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_SCALE + 2, [](u32 arg) -> std::string { return "Viewport: z scale = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_OFFSET, [](u32 arg) -> std::string { return "Viewport: x offset = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_OFFSET + 1, [](u32 arg) -> std::string { return "Viewport: y offset = " + std::to_string((f32&)arg); } },
{ NV4097_SET_VIEWPORT_OFFSET + 2, [](u32 arg) -> std::string { return "Viewport: z offset = " + std::to_string((f32&)arg); } },
{ NV4097_SET_SCISSOR_HORIZONTAL, [](u32 arg) -> std::string { return "Scissor: x = " + std::to_string(arg & 0xFFFF) + " width = " + std::to_string(arg >> 16); } },
{ NV4097_SET_SCISSOR_VERTICAL, [](u32 arg) -> std::string { return "Scissor: y = " + std::to_string(arg & 0xFFFF) + " height = " + std::to_string(arg >> 16); } },
{ NV4097_SET_STENCIL_TEST_ENABLE, [](u32 arg) -> std::string { return (!!arg) ? "Stencil: Enable" : "Stencil : Disable"; } },
{ NV4097_SET_STENCIL_FUNC, [](u32 arg) -> std::string { return "Stencil: " + get_compare_func(arg); } },
{ NV4097_SET_BACK_STENCIL_OP_ZPASS, [](u32 arg) -> std::string { return "Stencil: Back ZPass = " + get_stencil_op(arg); } },
{ NV4097_SET_BACK_STENCIL_OP_ZFAIL, [](u32 arg) -> std::string { return "Stencil: Back ZFail = " + get_stencil_op(arg); } },
{ NV4097_SET_BACK_STENCIL_OP_FAIL, [](u32 arg) -> std::string { return "Stencil: Back Fail = " + get_stencil_op(arg); } },
{ NV4097_SET_STENCIL_OP_ZPASS, [](u32 arg) -> std::string { return "Stencil: ZPass = " + get_stencil_op(arg); } },
{ NV4097_SET_STENCIL_OP_ZFAIL, [](u32 arg) -> std::string { return "Stencil: ZFail = " + get_stencil_op(arg); } },
{ NV4097_SET_STENCIL_OP_FAIL, [](u32 arg) -> std::string { return "Stencil: Fail = " + get_stencil_op(arg); } },
{ NV4097_SET_STENCIL_FUNC_MASK, [](u32 arg) -> std::string { return "Stencil: Func mask = " + ptr_to_string(arg); } },
{ NV4097_SET_STENCIL_MASK, [](u32 arg) -> std::string { return "Stencil: Mask = " + ptr_to_string(arg); } },
{ NV4097_SET_STENCIL_FUNC_REF, [](u32 arg) -> std::string { return "Stencil: Ref = " + std::to_string(arg); } },
{ NV4097_INVALIDATE_VERTEX_CACHE_FILE, [](u32) -> std::string { return "(invalidate vertex cache file)"; } },
{ NV4097_INVALIDATE_VERTEX_FILE, [](u32) -> std::string { return "(invalidate vertex file)"; } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT, [](u32 arg) -> std::string { return "Vertex array 0: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 1, [](u32 arg) -> std::string { return "Vertex array 1: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 2, [](u32 arg) -> std::string { return "Vertex array 2: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 3, [](u32 arg) -> std::string { return "Vertex array 3: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 4, [](u32 arg) -> std::string { return "Vertex array 4: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 5, [](u32 arg) -> std::string { return "Vertex array 5: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 6, [](u32 arg) -> std::string { return "Vertex array 6: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 7, [](u32 arg) -> std::string { return "Vertex array 7: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 8, [](u32 arg) -> std::string { return "Vertex array 8: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 9, [](u32 arg) -> std::string { return "Vertex array 9: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 10, [](u32 arg) -> std::string { return "Vertex array 10: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 11, [](u32 arg) -> std::string { return "Vertex array 11: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 12, [](u32 arg) -> std::string { return "Vertex array 12: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 13, [](u32 arg) -> std::string { return "Vertex array 13: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 14, [](u32 arg) -> std::string { return "Vertex array 14: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_FORMAT + 15, [](u32 arg) -> std::string { return "Vertex array 15: " + unpack_vertex_format(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET, [](u32 arg) -> std::string { return "Vertex array 0: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 1, [](u32 arg) -> std::string { return "Vertex array 1: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 2, [](u32 arg) -> std::string { return "Vertex array 2: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 3, [](u32 arg) -> std::string { return "Vertex array 3: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 4, [](u32 arg) -> std::string { return "Vertex array 4: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 5, [](u32 arg) -> std::string { return "Vertex array 5: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 6, [](u32 arg) -> std::string { return "Vertex array 6: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 7, [](u32 arg) -> std::string { return "Vertex array 7: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 8, [](u32 arg) -> std::string { return "Vertex array 8: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 9, [](u32 arg) -> std::string { return "Vertex array 9: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 10, [](u32 arg) -> std::string { return "Vertex array 10: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 11, [](u32 arg) -> std::string { return "Vertex array 11: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 12, [](u32 arg) -> std::string { return "Vertex array 12: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 13, [](u32 arg) -> std::string { return "Vertex array 13: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 14, [](u32 arg) -> std::string { return "Vertex array 14: Offset = " + std::to_string(arg); } },
{ NV4097_SET_VERTEX_DATA_ARRAY_OFFSET + 15, [](u32 arg) -> std::string { return "Vertex array 15: Offset = " + std::to_string(arg); } },
{ NV4097_SET_INDEX_ARRAY_ADDRESS, [](u32 arg) -> std::string { return "Index array: Address = " + ptr_to_string(arg); } },
{ NV4097_SET_INDEX_ARRAY_DMA, [](u32 arg) -> std::string { return "Index array: DMA mode = " + dma_mode(arg & 0xF) + " type = " + index_type(arg >> 4); } },
OPCODE_RANGE_32(NV4097_SET_TRANSFORM_CONSTANT, 1, 0, transform_constant)
OPCODE_RANGE_16(NV4097_SET_TEXTURE_OFFSET, 8, 0, texture_offset)
OPCODE_RANGE_16(NV4097_SET_TEXTURE_FORMAT, 8, 0, texture_format)
@ -1252,7 +1249,7 @@ namespace
};
}
std::function<std::string(u32)> rsx::get_pretty_printing_function(const u32 id) noexcept
std::function<std::string(u32)> rsx::get_pretty_printing_function(u32 id)
{
auto found = printing_functions.find(id);
if (found != printing_functions.end())
@ -1262,8 +1259,6 @@ std::function<std::string(u32)> rsx::get_pretty_printing_function(const u32 id)
return [=](u32 v)
{
std::stringstream ss;
ss << rsx::get_method_name(id) << " : " << (void*)(u64)v;
return ss.str();
return fmt::format("%s : 0x%08x", rsx::get_method_name(id), v);
};
}
}

9
rpcs3/Emu/RSX/GCM.h
View File

@ -1,7 +1,6 @@
#pragma once
#include "Utilities/types.h"
#include "Emu/Memory/vm.h"
#include <sstream>
enum
{
@ -969,7 +968,7 @@ namespace rsx
return 1;
}
std::string get_method_name(const u32 id) noexcept;
std::string get_method_name(const u32 id);
std::function<std::string(u32)> get_pretty_printing_function(const u32 id) noexcept;
}
std::function<std::string(u32)> get_pretty_printing_function(const u32 id);
}

4
rpcs3/Emu/RSX/GL/gl_helpers.h
View File

@ -1,4 +1,5 @@
#pragma once
#include <exception>
#include <string>
#include <functional>
@ -9,7 +10,6 @@
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "Utilities/types.h"
#include "OpenGL.h"
namespace gl
@ -2260,4 +2260,4 @@ namespace gl
set_id(0);
}
};
}
}

1
rpcs3/Emu/RSX/RSXTexture.h
View File

@ -1,5 +1,4 @@
#pragma once
#include "Utilities/types.h"
namespace rsx
{

9
rpcs3/Emu/RSX/RSXThread.cpp
View File

@ -726,12 +726,17 @@ namespace rsx
bind_range_impl_t<id, step, count, T, index>::impl();
}
[[noreturn]] never_inline static void bind_redefinition_error(int id)
{
throw EXCEPTION("RSX method implementation redefinition (0x%04x)", id);
}
template<int id, typename T, T impl_func>
static void bind_impl()
{
if (methods[id])
{
throw std::logic_error(fmt::format("redefinition rsx method implementation (0x%04x)", id));
bind_redefinition_error(id);
}
methods[id] = wrapper<id, T, impl_func>;
@ -742,7 +747,7 @@ namespace rsx
{
if (methods[id])
{
throw std::logic_error(fmt::format("redefinition rsx method implementation(cpu only) (0x%04x)", id));
bind_redefinition_error(id);
}
methods[id] = call_impl_func<impl_func>;

3
rpcs3/Emu/RSX/RSXThread.h
View File

@ -1,4 +1,5 @@
#pragma once
#include "GCM.h"
#include "RSXTexture.h"
#include "RSXVertexProgram.h"
@ -8,8 +9,6 @@
#include "Utilities/Semaphore.h"
#include "Utilities/Thread.h"
#include "Utilities/Timer.h"
#include "Utilities/types.h"
extern u64 get_system_time();

4
rpcs3/Emu/System.h
View File

@ -3,9 +3,7 @@
#include "Loader/Loader.h"
#include "DbgCommand.h"
//just for frame_type
//TODO: provide better way
#include "Emu/RSX/GSRender.h"
enum class frame_type;
struct EmuCallbacks
{

20
rpcs3/Gui/RSXDebugger.cpp
View File

@ -4,6 +4,7 @@
#include "Utilities/rPlatform.h"
#include "Utilities/Log.h"
#include "Utilities/File.h"
#include "Emu/Memory/Memory.h"
#include "Emu/System.h"
#include "Emu/state.h"
@ -16,7 +17,6 @@
#include "MemoryViewer.h"
#include <wx/notebook.h>
#include <fstream>
// TODO: Clear the object when restarting the emulator
std::vector<RSXDebuggerProgram> m_debug_programs;
@ -558,20 +558,22 @@ void RSXDebugger::GetMemory()
m_list_commands->SetItem(i, 1, "????????");
}
}
std::ofstream command_dump;
command_dump.open("command_dump.log");
std::string dump;
for (u32 i = 0; i < frame_debug.command_queue.size(); i++)
{
std::string str = rsx::get_pretty_printing_function(frame_debug.command_queue[i].first)(frame_debug.command_queue[i].second);
const std::string& str = rsx::get_pretty_printing_function(frame_debug.command_queue[i].first)(frame_debug.command_queue[i].second);
m_list_captured_frame->SetItem(i, 0, str);
command_dump << str << "\n";
dump += str;
dump += '\n';
}
command_dump.close();
fs::file("command_dump.log", fom::rewrite) << dump;
for (u32 i = 0;i < frame_debug.draw_calls.size(); i++)
m_list_captured_draw_calls->InsertItem(i, frame_debug.draw_calls[i].name);
}
void RSXDebugger::GetBuffers()
@ -1050,4 +1052,4 @@ wxString RSXDebugger::DisAsmCommand(u32 cmd, u32 count, u32 currentAddr, u32 ioA
bool RSXDebugger::RSXReady()
{
return Emu.GetGSManager().IsInited();
}
}

20
rpcs3/stdafx.h
View File

@ -7,7 +7,10 @@
#endif
#define NOMINMAX
#ifndef __STDC_CONSTANT_MACROS
#define __STDC_CONSTANT_MACROS
#endif
#if defined(MSVC_CRT_MEMLEAK_DETECTION) && defined(_DEBUG) && !defined(DBG_NEW)
#define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
@ -55,27 +58,14 @@ using namespace std::chrono_literals;
#define CHECK_SIZE_ALIGN(type, size, align) CHECK_SIZE(type, size); CHECK_ALIGN(type, align)
#define CHECK_ASCENDING(constexpr_array) static_assert(::is_ascending(constexpr_array), #constexpr_array " is not sorted in ascending order")
using uint = unsigned int;
using u8 = std::uint8_t;
using u16 = std::uint16_t;
using u32 = std::uint32_t;
using u64 = std::uint64_t;
using s8 = std::int8_t;
using s16 = std::int16_t;
using s32 = std::int32_t;
using s64 = std::int64_t;
using f32 = float;
using f64 = double;
#ifndef _MSC_VER
using u128 = __uint128_t;
#endif
CHECK_SIZE_ALIGN(u128, 16, 16);
#include "Utilities/types.h"
// bool type replacement for PS3/PSV
class b8
{