diff --git a/rpcs3/Emu/RSX/CgBinaryProgram.h b/rpcs3/Emu/RSX/CgBinaryProgram.h index 31b9dfefbb..f9ecd4eb9c 100644 --- a/rpcs3/Emu/RSX/CgBinaryProgram.h +++ b/rpcs3/Emu/RSX/CgBinaryProgram.h @@ -333,7 +333,7 @@ public: auto& vmfprog = vm::ps3::_ref(ptr + vmprog.program); u32 size; u32 ctrl = (vmfprog.outputFromH0 ? 0 : 0x40) | (vmfprog.depthReplace ? 0xe : 0); - std::vector td; + std::vector td; RSXFragmentProgram prog; prog.size = 0, prog.addr = vm::base(ptr + vmprog.ucode), prog.offset = 0, prog.ctrl = ctrl; GLFragmentDecompilerThread(m_glsl_shader, param_array, prog, size).Task(); diff --git a/rpcs3/Emu/RSX/Common/FragmentProgramDecompiler.cpp b/rpcs3/Emu/RSX/Common/FragmentProgramDecompiler.cpp index 3ea0501525..c35750f819 100644 --- a/rpcs3/Emu/RSX/Common/FragmentProgramDecompiler.cpp +++ b/rpcs3/Emu/RSX/Common/FragmentProgramDecompiler.cpp @@ -130,16 +130,16 @@ std::string FragmentProgramDecompiler::AddTex() std::string sampler; switch (m_prog.get_texture_dimension(dst.tex_num)) { - case texture_dimension::texture_dimension_1d: + case texture_dimension_extended::texture_dimension_1d: sampler = "sampler1D"; break; - case texture_dimension::texture_dimension_cubemap: + case texture_dimension_extended::texture_dimension_cubemap: sampler = "samplerCube"; break; - case texture_dimension::texture_dimension_2d: + case texture_dimension_extended::texture_dimension_2d: sampler = "sampler2D"; break; - case texture_dimension::texture_dimension_3d: + case texture_dimension_extended::texture_dimension_3d: sampler = "sampler3D"; break; } @@ -442,16 +442,16 @@ bool FragmentProgramDecompiler::handle_tex_srb(u32 opcode) case RSX_FP_OPCODE_TEX: switch (m_prog.get_texture_dimension(dst.tex_num)) { - case texture_dimension::texture_dimension_1d: + case texture_dimension_extended::texture_dimension_1d: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLE1D)); return true; - case texture_dimension::texture_dimension_2d: + case texture_dimension_extended::texture_dimension_2d: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLE2D)); return true; - case texture_dimension::texture_dimension_cubemap: + case texture_dimension_extended::texture_dimension_cubemap: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLECUBE)); return true; - case texture_dimension::texture_dimension_3d: + case texture_dimension_extended::texture_dimension_3d: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLE3D)); return true; } @@ -460,16 +460,16 @@ bool FragmentProgramDecompiler::handle_tex_srb(u32 opcode) case RSX_FP_OPCODE_TXP: switch (m_prog.get_texture_dimension(dst.tex_num)) { - case texture_dimension::texture_dimension_1d: + case texture_dimension_extended::texture_dimension_1d: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLE1D_PROJ)); return true; - case texture_dimension::texture_dimension_2d: + case texture_dimension_extended::texture_dimension_2d: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLE2D_PROJ)); return true; - case texture_dimension::texture_dimension_cubemap: + case texture_dimension_extended::texture_dimension_cubemap: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLECUBE_PROJ)); return true; - case texture_dimension::texture_dimension_3d: + case texture_dimension_extended::texture_dimension_3d: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLE3D_PROJ)); return true; } @@ -480,16 +480,16 @@ bool FragmentProgramDecompiler::handle_tex_srb(u32 opcode) case RSX_FP_OPCODE_TXL: switch (m_prog.get_texture_dimension(dst.tex_num)) { - case texture_dimension::texture_dimension_1d: + case texture_dimension_extended::texture_dimension_1d: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLE1D_LOD)); return true; - case texture_dimension::texture_dimension_2d: + case texture_dimension_extended::texture_dimension_2d: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLE2D_LOD)); return true; - case texture_dimension::texture_dimension_cubemap: + case texture_dimension_extended::texture_dimension_cubemap: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLECUBE_LOD)); return true; - case texture_dimension::texture_dimension_3d: + case texture_dimension_extended::texture_dimension_3d: SetDst(getFunction(FUNCTION::FUNCTION_TEXTURE_SAMPLE3D_LOD)); return true; } diff --git a/rpcs3/Emu/RSX/Common/TextureUtils.cpp b/rpcs3/Emu/RSX/Common/TextureUtils.cpp index fdd138d694..c129acfe94 100644 --- a/rpcs3/Emu/RSX/Common/TextureUtils.cpp +++ b/rpcs3/Emu/RSX/Common/TextureUtils.cpp @@ -124,18 +124,18 @@ std::vector get_subresources_layout(const rsx::texture & u16 depth; u8 layer; - if (texture.dimension() == 1) + if (texture.dimension() == rsx::texture_dimension::dimension1d) { depth = 1; layer = 1; h = 1; } - else if (texture.dimension() == 2) + else if (texture.dimension() == rsx::texture_dimension::dimension2d) { depth = 1; layer = texture.cubemap() ? 6 : 1; } - else if (texture.dimension() == 3) + else if (texture.dimension() == rsx::texture_dimension::dimension3d) { depth = texture.depth(); layer = 1; diff --git a/rpcs3/Emu/RSX/D3D12/D3D12Formats.cpp b/rpcs3/Emu/RSX/D3D12/D3D12Formats.cpp index 7e0b392858..ae5ad79ee5 100644 --- a/rpcs3/Emu/RSX/D3D12/D3D12Formats.cpp +++ b/rpcs3/Emu/RSX/D3D12/D3D12Formats.cpp @@ -172,89 +172,89 @@ DXGI_FORMAT get_texture_format(u8 format) throw EXCEPTION("Invalid or unsupported texture format (0x%x)", format); } -UINT get_texture_max_aniso(u8 aniso) +UINT get_texture_max_aniso(rsx::texture_max_anisotropy aniso) { switch (aniso) { - case CELL_GCM_TEXTURE_MAX_ANISO_1: return 1; - case CELL_GCM_TEXTURE_MAX_ANISO_2: return 2; - case CELL_GCM_TEXTURE_MAX_ANISO_4: return 4; - case CELL_GCM_TEXTURE_MAX_ANISO_6: return 6; - case CELL_GCM_TEXTURE_MAX_ANISO_8: return 8; - case CELL_GCM_TEXTURE_MAX_ANISO_10: return 10; - case CELL_GCM_TEXTURE_MAX_ANISO_12: return 12; - case CELL_GCM_TEXTURE_MAX_ANISO_16: return 16; + case rsx::texture_max_anisotropy::x1: return 1; + case rsx::texture_max_anisotropy::x2: return 2; + case rsx::texture_max_anisotropy::x4: return 4; + case rsx::texture_max_anisotropy::x6: return 6; + case rsx::texture_max_anisotropy::x8: return 8; + case rsx::texture_max_anisotropy::x10: return 10; + case rsx::texture_max_anisotropy::x12: return 12; + case rsx::texture_max_anisotropy::x16: return 16; } throw EXCEPTION("Invalid texture max aniso (0x%x)", aniso); } -D3D12_TEXTURE_ADDRESS_MODE get_texture_wrap_mode(u8 wrap) +D3D12_TEXTURE_ADDRESS_MODE get_texture_wrap_mode(rsx::texture_wrap_mode wrap) { switch (wrap) { - case CELL_GCM_TEXTURE_WRAP: return D3D12_TEXTURE_ADDRESS_MODE_WRAP; - case CELL_GCM_TEXTURE_MIRROR: return D3D12_TEXTURE_ADDRESS_MODE_MIRROR; - case CELL_GCM_TEXTURE_CLAMP_TO_EDGE: return D3D12_TEXTURE_ADDRESS_MODE_CLAMP; - case CELL_GCM_TEXTURE_BORDER: return D3D12_TEXTURE_ADDRESS_MODE_BORDER; - case CELL_GCM_TEXTURE_CLAMP: return D3D12_TEXTURE_ADDRESS_MODE_CLAMP; - case CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP_TO_EDGE: return D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE; - case CELL_GCM_TEXTURE_MIRROR_ONCE_BORDER: return D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE; - case CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP: return D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE; + case rsx::texture_wrap_mode::wrap: return D3D12_TEXTURE_ADDRESS_MODE_WRAP; + case rsx::texture_wrap_mode::mirror: return D3D12_TEXTURE_ADDRESS_MODE_MIRROR; + case rsx::texture_wrap_mode::clamp_to_edge: return D3D12_TEXTURE_ADDRESS_MODE_CLAMP; + case rsx::texture_wrap_mode::border: return D3D12_TEXTURE_ADDRESS_MODE_BORDER; + case rsx::texture_wrap_mode::clamp: return D3D12_TEXTURE_ADDRESS_MODE_CLAMP; + case rsx::texture_wrap_mode::mirror_once_clamp_to_edge: return D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE; + case rsx::texture_wrap_mode::mirror_once_border: return D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE; + case rsx::texture_wrap_mode::mirror_once_clamp: return D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE; } throw EXCEPTION("Invalid texture wrap mode (0x%x)", wrap); } namespace { - void get_min_filter(u8 min_filter, D3D12_FILTER_TYPE &min, D3D12_FILTER_TYPE &mip) + void get_min_filter(rsx::texture_minify_filter min_filter, D3D12_FILTER_TYPE &min, D3D12_FILTER_TYPE &mip) { switch (min_filter) { - case CELL_GCM_TEXTURE_NEAREST: + case rsx::texture_minify_filter::nearest: min = D3D12_FILTER_TYPE_POINT; mip = D3D12_FILTER_TYPE_POINT; return; - case CELL_GCM_TEXTURE_LINEAR: + case rsx::texture_minify_filter::linear: min = D3D12_FILTER_TYPE_LINEAR; mip = D3D12_FILTER_TYPE_POINT; return; - case CELL_GCM_TEXTURE_NEAREST_NEAREST: + case rsx::texture_minify_filter::nearest_nearest: min = D3D12_FILTER_TYPE_POINT; mip = D3D12_FILTER_TYPE_POINT; return; - case CELL_GCM_TEXTURE_LINEAR_NEAREST: + case rsx::texture_minify_filter::linear_nearest: min = D3D12_FILTER_TYPE_LINEAR; mip = D3D12_FILTER_TYPE_POINT; return; - case CELL_GCM_TEXTURE_NEAREST_LINEAR: + case rsx::texture_minify_filter::nearest_linear: min = D3D12_FILTER_TYPE_POINT; mip = D3D12_FILTER_TYPE_LINEAR; return; - case CELL_GCM_TEXTURE_LINEAR_LINEAR: + case rsx::texture_minify_filter::linear_linear: min = D3D12_FILTER_TYPE_LINEAR; mip = D3D12_FILTER_TYPE_LINEAR; return; - case CELL_GCM_TEXTURE_CONVOLUTION_MIN: + case rsx::texture_minify_filter::convolution_min: min = D3D12_FILTER_TYPE_LINEAR; mip = D3D12_FILTER_TYPE_POINT; return; } - throw EXCEPTION("Invalid max filter (0x%x)", min_filter); + throw EXCEPTION("Invalid max filter"); } - D3D12_FILTER_TYPE get_mag_filter(u8 mag_filter) + D3D12_FILTER_TYPE get_mag_filter(rsx::texture_magnify_filter mag_filter) { switch (mag_filter) { - case CELL_GCM_TEXTURE_NEAREST: return D3D12_FILTER_TYPE_POINT; - case CELL_GCM_TEXTURE_LINEAR: return D3D12_FILTER_TYPE_LINEAR; - case CELL_GCM_TEXTURE_CONVOLUTION_MAG: return D3D12_FILTER_TYPE_LINEAR; + case rsx::texture_magnify_filter::nearest: return D3D12_FILTER_TYPE_POINT; + case rsx::texture_magnify_filter::linear: return D3D12_FILTER_TYPE_LINEAR; + case rsx::texture_magnify_filter::convolution_mag: return D3D12_FILTER_TYPE_LINEAR; } - throw EXCEPTION("Invalid mag filter (0x%x)", mag_filter); + throw EXCEPTION("Invalid mag filter"); } } -D3D12_FILTER get_texture_filter(u8 min_filter, u8 mag_filter) +D3D12_FILTER get_texture_filter(rsx::texture_minify_filter min_filter, rsx::texture_magnify_filter mag_filter) { D3D12_FILTER_TYPE min, mip; get_min_filter(min_filter, min, mip); diff --git a/rpcs3/Emu/RSX/D3D12/D3D12Formats.h b/rpcs3/Emu/RSX/D3D12/D3D12Formats.h index a5cc001acc..c507c46510 100644 --- a/rpcs3/Emu/RSX/D3D12/D3D12Formats.h +++ b/rpcs3/Emu/RSX/D3D12/D3D12Formats.h @@ -41,17 +41,17 @@ DXGI_FORMAT get_texture_format(u8 format); /** * Convert texture aniso value to UINT. */ -UINT get_texture_max_aniso(u8 aniso); +UINT get_texture_max_aniso(rsx::texture_max_anisotropy aniso); /** * Convert texture wrap mode to D3D12_TEXTURE_ADDRESS_MODE */ -D3D12_TEXTURE_ADDRESS_MODE get_texture_wrap_mode(u8 wrap); +D3D12_TEXTURE_ADDRESS_MODE get_texture_wrap_mode(rsx::texture_wrap_mode wrap); /** * Convert minify and magnify filter to D3D12_FILTER */ -D3D12_FILTER get_texture_filter(u8 min_filter, u8 mag_filter); +D3D12_FILTER get_texture_filter(rsx::texture_minify_filter min_filter, rsx::texture_magnify_filter mag_filter); /** * Convert draw mode to D3D12_PRIMITIVE_TOPOLOGY diff --git a/rpcs3/Emu/RSX/D3D12/D3D12Texture.cpp b/rpcs3/Emu/RSX/D3D12/D3D12Texture.cpp index 301802d05b..0a566f248c 100644 --- a/rpcs3/Emu/RSX/D3D12/D3D12Texture.cpp +++ b/rpcs3/Emu/RSX/D3D12/D3D12Texture.cpp @@ -47,17 +47,17 @@ namespace const u8 format = texture.format() & ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN); DXGI_FORMAT dxgi_format = get_texture_format(format); - if (texture.dimension() == 1) // 1D texture or cubemap + if (texture.dimension() == rsx::texture_dimension::dimension1d) { return CD3DX12_RESOURCE_DESC::Tex1D(dxgi_format, texture.width(), 1, texture.get_exact_mipmap_count()); } - else if (texture.dimension() == 2) // 2D texture or cubemap + else if (texture.dimension() == rsx::texture_dimension::dimension2d) { // if (texture.depth() < 2); size_t depth = (texture.cubemap()) ? 6 : 1; return CD3DX12_RESOURCE_DESC::Tex2D(dxgi_format, texture.width(), texture.height(), (UINT)depth, texture.get_exact_mipmap_count()); } - else if (texture.dimension() == 3) // 3d texture + else if (texture.dimension() == rsx::texture_dimension::dimension3d) { return CD3DX12_RESOURCE_DESC::Tex3D(dxgi_format, texture.width(), texture.height(), texture.depth(), texture.get_exact_mipmap_count()); } @@ -146,13 +146,13 @@ ComPtr upload_single_texture( D3D12_SHADER_RESOURCE_VIEW_DESC get_srv_descriptor_with_dimensions(const rsx::texture &tex) { D3D12_SHADER_RESOURCE_VIEW_DESC shared_resource_view_desc = {}; - if (tex.dimension() == 1) + if (tex.dimension() == rsx::texture_dimension::dimension1d) { shared_resource_view_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1D; shared_resource_view_desc.Texture1D.MipLevels = tex.get_exact_mipmap_count(); return shared_resource_view_desc; } - if (tex.dimension() == 2) + if (tex.dimension() == rsx::texture_dimension::dimension2d) { if (tex.cubemap()) { @@ -164,7 +164,7 @@ D3D12_SHADER_RESOURCE_VIEW_DESC get_srv_descriptor_with_dimensions(const rsx::te shared_resource_view_desc.Texture2D.MipLevels = tex.get_exact_mipmap_count(); return shared_resource_view_desc; } - if (tex.dimension() == 3) + if (tex.dimension() == rsx::texture_dimension::dimension3d) { shared_resource_view_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D; shared_resource_view_desc.Texture3D.MipLevels = tex.get_exact_mipmap_count(); diff --git a/rpcs3/Emu/RSX/GCM.cpp b/rpcs3/Emu/RSX/GCM.cpp index 57f8b4269b..645ecd9106 100644 --- a/rpcs3/Emu/RSX/GCM.cpp +++ b/rpcs3/Emu/RSX/GCM.cpp @@ -830,6 +830,16 @@ rsx::fog_mode rsx::to_fog_mode(u32 in) throw EXCEPTION("Wrong fog mode %x", in); } +rsx::texture_dimension rsx::to_texture_dimension(u8 in) +{ + switch (in) + { + case 1: return rsx::texture_dimension::dimension1d; + case 2: return rsx::texture_dimension::dimension2d; + case 3: return rsx::texture_dimension::dimension3d; + } + throw EXCEPTION("Wrong texture dimension %d", in); +} enum { @@ -867,8 +877,96 @@ enum CELL_GCM_SURFACE_X8B8G8R8_O8B8G8R8 = 15, CELL_GCM_SURFACE_A8B8G8R8 = 16, + // Wrap + CELL_GCM_TEXTURE_WRAP = 1, + CELL_GCM_TEXTURE_MIRROR = 2, + CELL_GCM_TEXTURE_CLAMP_TO_EDGE = 3, + CELL_GCM_TEXTURE_BORDER = 4, + CELL_GCM_TEXTURE_CLAMP = 5, + CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP_TO_EDGE = 6, + CELL_GCM_TEXTURE_MIRROR_ONCE_BORDER = 7, + CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP = 8, + + // Max Anisotropy + CELL_GCM_TEXTURE_MAX_ANISO_1 = 0, + CELL_GCM_TEXTURE_MAX_ANISO_2 = 1, + CELL_GCM_TEXTURE_MAX_ANISO_4 = 2, + CELL_GCM_TEXTURE_MAX_ANISO_6 = 3, + CELL_GCM_TEXTURE_MAX_ANISO_8 = 4, + CELL_GCM_TEXTURE_MAX_ANISO_10 = 5, + CELL_GCM_TEXTURE_MAX_ANISO_12 = 6, + CELL_GCM_TEXTURE_MAX_ANISO_16 = 7, + + // Texture Filter + CELL_GCM_TEXTURE_NEAREST = 1, + CELL_GCM_TEXTURE_LINEAR = 2, + CELL_GCM_TEXTURE_NEAREST_NEAREST = 3, + CELL_GCM_TEXTURE_LINEAR_NEAREST = 4, + CELL_GCM_TEXTURE_NEAREST_LINEAR = 5, + CELL_GCM_TEXTURE_LINEAR_LINEAR = 6, + CELL_GCM_TEXTURE_CONVOLUTION_MIN = 7, + CELL_GCM_TEXTURE_CONVOLUTION_MAG = 4, }; +rsx::texture_wrap_mode rsx::to_texture_wrap_mode(u8 in) +{ + switch (in) + { + case CELL_GCM_TEXTURE_WRAP: return rsx::texture_wrap_mode::wrap; + case CELL_GCM_TEXTURE_MIRROR: return rsx::texture_wrap_mode::mirror; + case CELL_GCM_TEXTURE_CLAMP_TO_EDGE: return rsx::texture_wrap_mode::clamp_to_edge; + case CELL_GCM_TEXTURE_BORDER: return rsx::texture_wrap_mode::border; + case CELL_GCM_TEXTURE_CLAMP: return rsx::texture_wrap_mode::clamp; + case CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP_TO_EDGE: return rsx::texture_wrap_mode::mirror_once_clamp_to_edge; + case CELL_GCM_TEXTURE_MIRROR_ONCE_BORDER: return rsx::texture_wrap_mode::mirror_once_border; + case CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP: return rsx::texture_wrap_mode::mirror_once_clamp; + } + throw EXCEPTION("Unknow wrap mode %x", in); +} + +rsx::texture_max_anisotropy rsx::to_texture_max_anisotropy(u8 in) +{ + switch (in) + { + case CELL_GCM_TEXTURE_MAX_ANISO_1: return rsx::texture_max_anisotropy::x1; + case CELL_GCM_TEXTURE_MAX_ANISO_2: return rsx::texture_max_anisotropy::x2; + case CELL_GCM_TEXTURE_MAX_ANISO_4: return rsx::texture_max_anisotropy::x4; + case CELL_GCM_TEXTURE_MAX_ANISO_6: return rsx::texture_max_anisotropy::x6; + case CELL_GCM_TEXTURE_MAX_ANISO_8: return rsx::texture_max_anisotropy::x8; + case CELL_GCM_TEXTURE_MAX_ANISO_10: return rsx::texture_max_anisotropy::x10; + case CELL_GCM_TEXTURE_MAX_ANISO_12: return rsx::texture_max_anisotropy::x12; + case CELL_GCM_TEXTURE_MAX_ANISO_16: return rsx::texture_max_anisotropy::x16; + } + throw EXCEPTION("Unknow anisotropy max mode %x", in); +} + +rsx::texture_minify_filter rsx::to_texture_minify_filter(u8 in) +{ + switch (in) + { + case CELL_GCM_TEXTURE_NEAREST: return rsx::texture_minify_filter::nearest; + case CELL_GCM_TEXTURE_LINEAR: return rsx::texture_minify_filter::linear; + case CELL_GCM_TEXTURE_NEAREST_NEAREST: return rsx::texture_minify_filter::nearest_nearest; + case CELL_GCM_TEXTURE_LINEAR_NEAREST: return rsx::texture_minify_filter::linear_nearest; + case CELL_GCM_TEXTURE_NEAREST_LINEAR: return rsx::texture_minify_filter::nearest_linear; + case CELL_GCM_TEXTURE_LINEAR_LINEAR: return rsx::texture_minify_filter::linear_linear; + case CELL_GCM_TEXTURE_CONVOLUTION_MIN: return rsx::texture_minify_filter::linear_linear; + } + throw EXCEPTION("Unknow minify filter %x", in); +} + + +rsx::texture_magnify_filter rsx::to_texture_magnify_filter(u8 in) +{ + switch (in) + { + case CELL_GCM_TEXTURE_NEAREST: return rsx::texture_magnify_filter::nearest; + case CELL_GCM_TEXTURE_LINEAR: return rsx::texture_magnify_filter::linear; + case CELL_GCM_TEXTURE_CONVOLUTION_MAG: return rsx::texture_magnify_filter::convolution_mag; + } + throw EXCEPTION("Unknow magnify filter %x", in); +} + rsx::surface_target rsx::to_surface_target(u8 in) { switch (in) @@ -1099,6 +1197,17 @@ namespace return "Error"; } + std::string texture_dimension(u8 dim) + { + switch(rsx::to_texture_dimension(dim)) + { + case rsx::texture_dimension::dimension1d: return "1D"; + case rsx::texture_dimension::dimension2d: return "2D"; + case rsx::texture_dimension::dimension3d: return "3D"; + } + return ""; + } + std::string surface_target(u32 target) { switch (rsx::to_surface_target(target)) @@ -1245,16 +1354,16 @@ namespace std::string get_texture_wrap_mode(u8 wrap) { - switch (wrap) + switch (rsx::to_texture_wrap_mode(wrap)) { - case CELL_GCM_TEXTURE_WRAP: return "WRAP"; - case CELL_GCM_TEXTURE_MIRROR: return "MIRROR"; - case CELL_GCM_TEXTURE_CLAMP_TO_EDGE: return "CLAMP_TO_EDGE"; - case CELL_GCM_TEXTURE_BORDER: return "BORDER"; - case CELL_GCM_TEXTURE_CLAMP: return "CLAMP"; - case CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP_TO_EDGE: return "MIRROR_ONCE_CLAMP_TO_EDGE"; - case CELL_GCM_TEXTURE_MIRROR_ONCE_BORDER: return "MIRROR_ONCE_BORDER"; - case CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP: return "MIRROR_ONCE_CLAMP"; + case rsx::texture_wrap_mode::wrap: return "WRAP"; + case rsx::texture_wrap_mode::mirror: return "MIRROR"; + case rsx::texture_wrap_mode::clamp_to_edge: return "CLAMP_TO_EDGE"; + case rsx::texture_wrap_mode::border: return "BORDER"; + case rsx::texture_wrap_mode::clamp: return "CLAMP"; + case rsx::texture_wrap_mode::mirror_once_clamp_to_edge: return "MIRROR_ONCE_CLAMP_TO_EDGE"; + case rsx::texture_wrap_mode::mirror_once_border: return "MIRROR_ONCE_BORDER"; + case rsx::texture_wrap_mode::mirror_once_clamp: return "MIRROR_ONCE_CLAMP"; } return "Error"; } @@ -1289,16 +1398,16 @@ namespace std::string get_texture_max_aniso_name(u8 aniso) { - switch (aniso) + switch (rsx::to_texture_max_anisotropy(aniso)) { - case CELL_GCM_TEXTURE_MAX_ANISO_1: return "1"; - case CELL_GCM_TEXTURE_MAX_ANISO_2: return "2"; - case CELL_GCM_TEXTURE_MAX_ANISO_4: return "4"; - case CELL_GCM_TEXTURE_MAX_ANISO_6: return "6"; - case CELL_GCM_TEXTURE_MAX_ANISO_8: return "8"; - case CELL_GCM_TEXTURE_MAX_ANISO_10: return "10"; - case CELL_GCM_TEXTURE_MAX_ANISO_12: return "12"; - case CELL_GCM_TEXTURE_MAX_ANISO_16: return "16"; + case rsx::texture_max_anisotropy::x1 : return "1"; + case rsx::texture_max_anisotropy::x2: return "2"; + case rsx::texture_max_anisotropy::x4: return "4"; + case rsx::texture_max_anisotropy::x6: return "6"; + case rsx::texture_max_anisotropy::x8: return "8"; + case rsx::texture_max_anisotropy::x10: return "10"; + case rsx::texture_max_anisotropy::x12: return "12"; + case rsx::texture_max_anisotropy::x16: return "16"; } return "Error"; } diff --git a/rpcs3/Emu/RSX/GCM.h b/rpcs3/Emu/RSX/GCM.h index f9d6aae57b..29362c2df2 100644 --- a/rpcs3/Emu/RSX/GCM.h +++ b/rpcs3/Emu/RSX/GCM.h @@ -153,6 +153,65 @@ namespace rsx }; fog_mode to_fog_mode(u32 in); + + enum class texture_dimension : u8 + { + dimension1d, + dimension2d, + dimension3d, + }; + + texture_dimension to_texture_dimension(u8 in); + + enum class texture_wrap_mode : u8 + { + wrap, + mirror, + clamp_to_edge, + border, + clamp, + mirror_once_clamp_to_edge, + mirror_once_border, + mirror_once_clamp, + }; + + texture_wrap_mode to_texture_wrap_mode(u8 in); + + enum class texture_max_anisotropy : u8 + { + x1, + x2, + x4, + x6, + x8, + x10, + x12, + x16, + }; + + texture_max_anisotropy to_texture_max_anisotropy(u8 in); + + enum class texture_minify_filter : u8 + { + nearest, ///< no filtering, mipmap base level + linear, ///< linear filtering, mipmap base level + nearest_nearest, ///< no filtering, closest mipmap level + linear_nearest, ///< linear filtering, closest mipmap level + nearest_linear, ///< no filtering, linear mix between closest mipmap levels + linear_linear, ///< linear filtering, linear mix between closest mipmap levels + convolution_min, ///< Unknow mode but looks close to linear_linear + }; + + texture_minify_filter to_texture_minify_filter(u8 in); + + enum class texture_magnify_filter : u8 + { + nearest, ///< no filtering + linear, ///< linear filtering + convolution_mag, ///< Unknow mode but looks close to linear + }; + + texture_magnify_filter to_texture_magnify_filter(u8 in); } enum @@ -229,26 +288,6 @@ enum // Normalization Flag CELL_GCM_TEXTURE_NR = 0x00, CELL_GCM_TEXTURE_UN = 0x40, - - // Max Anisotropy - CELL_GCM_TEXTURE_MAX_ANISO_1 = 0, - CELL_GCM_TEXTURE_MAX_ANISO_2 = 1, - CELL_GCM_TEXTURE_MAX_ANISO_4 = 2, - CELL_GCM_TEXTURE_MAX_ANISO_6 = 3, - CELL_GCM_TEXTURE_MAX_ANISO_8 = 4, - CELL_GCM_TEXTURE_MAX_ANISO_10 = 5, - CELL_GCM_TEXTURE_MAX_ANISO_12 = 6, - CELL_GCM_TEXTURE_MAX_ANISO_16 = 7, - - // Wrap - CELL_GCM_TEXTURE_WRAP = 1, - CELL_GCM_TEXTURE_MIRROR = 2, - CELL_GCM_TEXTURE_CLAMP_TO_EDGE = 3, - CELL_GCM_TEXTURE_BORDER = 4, - CELL_GCM_TEXTURE_CLAMP = 5, - CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP_TO_EDGE = 6, - CELL_GCM_TEXTURE_MIRROR_ONCE_BORDER = 7, - CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP = 8, }; // GCM Surface @@ -360,16 +399,6 @@ enum CELL_GCM_TEXTURE_CYLINDRICAL_WRAP_ENABLE_TEX7_P = 1 << 30, CELL_GCM_TEXTURE_CYLINDRICAL_WRAP_ENABLE_TEX7_Q = 1 << 31, - // Texture Filter - CELL_GCM_TEXTURE_NEAREST = 1, - CELL_GCM_TEXTURE_LINEAR = 2, - CELL_GCM_TEXTURE_NEAREST_NEAREST = 3, - CELL_GCM_TEXTURE_LINEAR_NEAREST = 4, - CELL_GCM_TEXTURE_NEAREST_LINEAR = 5, - CELL_GCM_TEXTURE_LINEAR_LINEAR = 6, - CELL_GCM_TEXTURE_CONVOLUTION_MIN = 7, - CELL_GCM_TEXTURE_CONVOLUTION_MAG = 4, - CELL_GCM_COLOR_MASK_B = 1 << 0, CELL_GCM_COLOR_MASK_G = 1 << 8, CELL_GCM_COLOR_MASK_R = 1 << 16, diff --git a/rpcs3/Emu/RSX/GL/rsx_gl_texture.cpp b/rpcs3/Emu/RSX/GL/rsx_gl_texture.cpp index 74c24bfad2..f78b311422 100644 --- a/rpcs3/Emu/RSX/GL/rsx_gl_texture.cpp +++ b/rpcs3/Emu/RSX/GL/rsx_gl_texture.cpp @@ -157,26 +157,31 @@ namespace rsx { namespace gl { - static const int gl_tex_min_filter[] = + int gl_tex_min_filter(rsx::texture_minify_filter min_filter) { - GL_NEAREST, // unused - GL_NEAREST, - GL_LINEAR, - GL_NEAREST_MIPMAP_NEAREST, - GL_LINEAR_MIPMAP_NEAREST, - GL_NEAREST_MIPMAP_LINEAR, - GL_LINEAR_MIPMAP_LINEAR, - GL_NEAREST, // CELL_GCM_TEXTURE_CONVOLUTION_MIN - }; + switch (min_filter) + { + case rsx::texture_minify_filter::nearest: return GL_NEAREST; + case rsx::texture_minify_filter::linear: return GL_LINEAR; + case rsx::texture_minify_filter::nearest_nearest: return GL_NEAREST_MIPMAP_NEAREST; + case rsx::texture_minify_filter::linear_nearest: return GL_LINEAR_MIPMAP_NEAREST; + case rsx::texture_minify_filter::nearest_linear: return GL_NEAREST_MIPMAP_LINEAR; + case rsx::texture_minify_filter::linear_linear: return GL_LINEAR_MIPMAP_LINEAR; + case rsx::texture_minify_filter::convolution_min: return GL_LINEAR_MIPMAP_LINEAR; + } + throw EXCEPTION("Unknow min filter"); + } - static const int gl_tex_mag_filter[] = + int gl_tex_mag_filter(rsx::texture_magnify_filter mag_filter) { - GL_NEAREST, // unused - GL_NEAREST, - GL_LINEAR, - GL_NEAREST, // unused - GL_LINEAR // CELL_GCM_TEXTURE_CONVOLUTION_MAG - }; + switch (mag_filter) + { + case rsx::texture_magnify_filter::nearest: return GL_NEAREST; + case rsx::texture_magnify_filter::linear: return GL_LINEAR; + case rsx::texture_magnify_filter::convolution_mag: return GL_LINEAR; + } + throw EXCEPTION("Unknow mag filter"); + } static const int gl_tex_zfunc[] = { @@ -200,36 +205,36 @@ namespace rsx glGenTextures(1, &m_id); } - int texture::gl_wrap(int wrap) + int texture::gl_wrap(rsx::texture_wrap_mode wrap) { switch (wrap) { - case CELL_GCM_TEXTURE_WRAP: return GL_REPEAT; - case CELL_GCM_TEXTURE_MIRROR: return GL_MIRRORED_REPEAT; - case CELL_GCM_TEXTURE_CLAMP_TO_EDGE: return GL_CLAMP_TO_EDGE; - case CELL_GCM_TEXTURE_BORDER: return GL_CLAMP_TO_BORDER; - case CELL_GCM_TEXTURE_CLAMP: return GL_CLAMP; - case CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP_TO_EDGE: return GL_MIRROR_CLAMP_TO_EDGE_EXT; - case CELL_GCM_TEXTURE_MIRROR_ONCE_BORDER: return GL_MIRROR_CLAMP_TO_BORDER_EXT; - case CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP: return GL_MIRROR_CLAMP_EXT; + case rsx::texture_wrap_mode::wrap: return GL_REPEAT; + case rsx::texture_wrap_mode::mirror: return GL_MIRRORED_REPEAT; + case rsx::texture_wrap_mode::clamp_to_edge: return GL_CLAMP_TO_EDGE; + case rsx::texture_wrap_mode::border: return GL_CLAMP_TO_BORDER; + case rsx::texture_wrap_mode::clamp: return GL_CLAMP; + case rsx::texture_wrap_mode::mirror_once_clamp_to_edge: return GL_MIRROR_CLAMP_TO_EDGE_EXT; + case rsx::texture_wrap_mode::mirror_once_border: return GL_MIRROR_CLAMP_TO_BORDER_EXT; + case rsx::texture_wrap_mode::mirror_once_clamp: return GL_MIRROR_CLAMP_EXT; } LOG_ERROR(RSX, "Texture wrap error: bad wrap (%d).", wrap); return GL_REPEAT; } - float texture::max_aniso(int aniso) + float texture::max_aniso(rsx::texture_max_anisotropy aniso) { switch (aniso) { - case CELL_GCM_TEXTURE_MAX_ANISO_1: return 1.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_2: return 2.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_4: return 4.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_6: return 6.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_8: return 8.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_10: return 10.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_12: return 12.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_16: return 16.0f; + case rsx::texture_max_anisotropy::x1: return 1.0f; + case rsx::texture_max_anisotropy::x2: return 2.0f; + case rsx::texture_max_anisotropy::x4: return 4.0f; + case rsx::texture_max_anisotropy::x6: return 6.0f; + case rsx::texture_max_anisotropy::x8: return 8.0f; + case rsx::texture_max_anisotropy::x10: return 10.0f; + case rsx::texture_max_anisotropy::x12: return 12.0f; + case rsx::texture_max_anisotropy::x16: return 16.0f; } LOG_ERROR(RSX, "Texture anisotropy error: bad max aniso (%d).", aniso); @@ -378,7 +383,7 @@ namespace rsx glTexParameteri(m_target, GL_TEXTURE_MIN_LOD, (tex.min_lod() >> 8)); glTexParameteri(m_target, GL_TEXTURE_MAX_LOD, (tex.max_lod() >> 8)); - int min_filter = gl_tex_min_filter[tex.min_filter()]; + int min_filter = gl_tex_min_filter(tex.min_filter()); if (min_filter != GL_LINEAR && min_filter != GL_NEAREST) { @@ -390,7 +395,7 @@ namespace rsx } glTexParameteri(m_target, GL_TEXTURE_MIN_FILTER, min_filter); - glTexParameteri(m_target, GL_TEXTURE_MAG_FILTER, gl_tex_mag_filter[tex.mag_filter()]); + glTexParameteri(m_target, GL_TEXTURE_MAG_FILTER, gl_tex_mag_filter(tex.mag_filter())); glTexParameterf(m_target, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_aniso(tex.max_aniso())); } diff --git a/rpcs3/Emu/RSX/GL/rsx_gl_texture.h b/rpcs3/Emu/RSX/GL/rsx_gl_texture.h index c16da5854b..8198e583ba 100644 --- a/rpcs3/Emu/RSX/GL/rsx_gl_texture.h +++ b/rpcs3/Emu/RSX/GL/rsx_gl_texture.h @@ -1,4 +1,5 @@ #include "OpenGL.h" +#include "../GCM.h" namespace rsx { @@ -14,9 +15,9 @@ namespace rsx public: void create(); - int gl_wrap(int wrap); + int gl_wrap(rsx::texture_wrap_mode in); - float max_aniso(int aniso); + float max_aniso(rsx::texture_max_anisotropy aniso); inline static u8 convert_4_to_8(u8 v) { diff --git a/rpcs3/Emu/RSX/RSXFragmentProgram.h b/rpcs3/Emu/RSX/RSXFragmentProgram.h index c019f96269..f403294dcf 100644 --- a/rpcs3/Emu/RSX/RSXFragmentProgram.h +++ b/rpcs3/Emu/RSX/RSXFragmentProgram.h @@ -205,7 +205,11 @@ static const std::string rsx_fp_op_names[] = "NULL", "BRK", "CAL", "IFE", "LOOP", "REP", "RET" }; -enum class texture_dimension : u8 + +/** + * Use an extra cubemap format + */ +enum class texture_dimension_extended : u8 { texture_dimension_1d = 0, texture_dimension_2d = 1, @@ -230,15 +234,15 @@ struct RSXFragmentProgram rsx::fog_mode fog_equation; u16 height; - texture_dimension get_texture_dimension(u8 id) const + texture_dimension_extended get_texture_dimension(u8 id) const { - return (texture_dimension)((texture_dimensions >> (id * 2)) & 0x3); + return (texture_dimension_extended)((texture_dimensions >> (id * 2)) & 0x3); } - void set_texture_dimension(const std::array &dimensions) + void set_texture_dimension(const std::array &dimensions) { size_t id = 0; - for (const texture_dimension &dim : dimensions) + for (const texture_dimension_extended &dim : dimensions) { texture_dimensions &= ~(0x3 << (id * 2)); u8 d = (u8)dim; diff --git a/rpcs3/Emu/RSX/RSXTexture.cpp b/rpcs3/Emu/RSX/RSXTexture.cpp index 9a4ba54355..e638feec05 100644 --- a/rpcs3/Emu/RSX/RSXTexture.cpp +++ b/rpcs3/Emu/RSX/RSXTexture.cpp @@ -60,9 +60,9 @@ namespace rsx return ((method_registers[NV4097_SET_TEXTURE_FORMAT + (m_index * 8)] >> 3) & 0x1); } - u8 texture::dimension() const + rsx::texture_dimension texture::dimension() const { - return ((method_registers[NV4097_SET_TEXTURE_FORMAT + (m_index * 8)] >> 4) & 0xf); + return rsx::to_texture_dimension((method_registers[NV4097_SET_TEXTURE_FORMAT + (m_index * 8)] >> 4) & 0xf); } u8 texture::format() const @@ -81,19 +81,19 @@ namespace rsx return std::min(mipmap(), max_mipmap_count); } - u8 texture::wrap_s() const + rsx::texture_wrap_mode texture::wrap_s() const { - return ((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)]) & 0xf); + return rsx::to_texture_wrap_mode((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)]) & 0xf); } - u8 texture::wrap_t() const + rsx::texture_wrap_mode texture::wrap_t() const { - return ((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] >> 8) & 0xf); + return rsx::to_texture_wrap_mode((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] >> 8) & 0xf); } - u8 texture::wrap_r() const + rsx::texture_wrap_mode texture::wrap_r() const { - return ((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] >> 16) & 0xf); + return rsx::to_texture_wrap_mode((method_registers[NV4097_SET_TEXTURE_ADDRESS + (m_index * 8)] >> 16) & 0xf); } u8 texture::unsigned_remap() const @@ -136,9 +136,9 @@ namespace rsx return ((method_registers[NV4097_SET_TEXTURE_CONTROL0 + (m_index * 8)] >> 7) & 0xfff); } - u8 texture::max_aniso() const + rsx::texture_max_anisotropy texture::max_aniso() const { - return ((method_registers[NV4097_SET_TEXTURE_CONTROL0 + (m_index * 8)] >> 4) & 0x7); + return rsx::to_texture_max_anisotropy((method_registers[NV4097_SET_TEXTURE_CONTROL0 + (m_index * 8)] >> 4) & 0x7); } bool texture::alpha_kill_enabled() const @@ -156,14 +156,14 @@ namespace rsx return float(f16((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)]) & 0x1fff)); } - u8 texture::min_filter() const + rsx::texture_minify_filter texture::min_filter() const { - return ((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] >> 16) & 0x7); + return rsx::to_texture_minify_filter((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] >> 16) & 0x7); } - u8 texture::mag_filter() const + rsx::texture_magnify_filter texture::mag_filter() const { - return ((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] >> 24) & 0x7); + return rsx::to_texture_magnify_filter((method_registers[NV4097_SET_TEXTURE_FILTER + (m_index * 8)] >> 24) & 0x7); } u8 texture::convolution_filter() const diff --git a/rpcs3/Emu/RSX/RSXTexture.h b/rpcs3/Emu/RSX/RSXTexture.h index d1bc8c719c..724caad77a 100644 --- a/rpcs3/Emu/RSX/RSXTexture.h +++ b/rpcs3/Emu/RSX/RSXTexture.h @@ -1,4 +1,5 @@ #pragma once +#include "GCM.h" namespace rsx { @@ -18,7 +19,7 @@ namespace rsx u8 location() const; bool cubemap() const; u8 border_type() const; - u8 dimension() const; + rsx::texture_dimension dimension() const; u8 format() const; u16 mipmap() const; /** @@ -28,9 +29,9 @@ namespace rsx u16 get_exact_mipmap_count() const; // Address - u8 wrap_s() const; - u8 wrap_t() const; - u8 wrap_r() const; + rsx::texture_wrap_mode wrap_s() const; + rsx::texture_wrap_mode wrap_t() const; + rsx::texture_wrap_mode wrap_r() const; u8 unsigned_remap() const; u8 zfunc() const; u8 gamma() const; @@ -41,7 +42,7 @@ namespace rsx bool enabled() const; u16 min_lod() const; u16 max_lod() const; - u8 max_aniso() const; + rsx::texture_max_anisotropy max_aniso() const; bool alpha_kill_enabled() const; // Control1 @@ -49,8 +50,8 @@ namespace rsx // Filter float bias() const; - u8 min_filter() const; - u8 mag_filter() const; + rsx::texture_minify_filter min_filter() const; + rsx::texture_magnify_filter mag_filter() const; u8 convolution_filter() const; bool a_signed() const; bool r_signed() const; diff --git a/rpcs3/Emu/RSX/RSXThread.cpp b/rpcs3/Emu/RSX/RSXThread.cpp index 965e2fd257..3cafd5b58d 100644 --- a/rpcs3/Emu/RSX/RSXThread.cpp +++ b/rpcs3/Emu/RSX/RSXThread.cpp @@ -719,22 +719,22 @@ namespace rsx result.pixel_center_mode = rsx::to_window_pixel_center((shader_window >> 16) & 0xF); result.height = shader_window & 0xFFF; - std::array texture_dimensions; + std::array texture_dimensions; for (u32 i = 0; i < rsx::limits::textures_count; ++i) { if (!textures[i].enabled()) - texture_dimensions[i] = texture_dimension::texture_dimension_2d; - else if (textures[i].dimension() == 1) - texture_dimensions[i] = texture_dimension::texture_dimension_1d; - else if (textures[i].dimension() == 2) + texture_dimensions[i] = texture_dimension_extended::texture_dimension_2d; + else if (textures[i].dimension() == rsx::texture_dimension::dimension1d) + texture_dimensions[i] = texture_dimension_extended::texture_dimension_1d; + else if (textures[i].dimension() == rsx::texture_dimension::dimension2d) { if (textures[i].cubemap()) - texture_dimensions[i] = texture_dimension::texture_dimension_cubemap; + texture_dimensions[i] = texture_dimension_extended::texture_dimension_cubemap; else - texture_dimensions[i] = texture_dimension::texture_dimension_2d; + texture_dimensions[i] = texture_dimension_extended::texture_dimension_2d; } - else if (textures[i].dimension() == 3) - texture_dimensions[i] = texture_dimension::texture_dimension_3d; + else if (textures[i].dimension() == rsx::texture_dimension::dimension3d) + texture_dimensions[i] = texture_dimension_extended::texture_dimension_3d; else throw EXCEPTION("Unable to determine texture dimension"); if (textures[i].enabled() && (textures[i].format() & CELL_GCM_TEXTURE_UN)) diff --git a/rpcs3/Emu/RSX/VK/VKFormats.cpp b/rpcs3/Emu/RSX/VK/VKFormats.cpp index cae7eee7c8..295a4efe44 100644 --- a/rpcs3/Emu/RSX/VK/VKFormats.cpp +++ b/rpcs3/Emu/RSX/VK/VKFormats.cpp @@ -39,61 +39,60 @@ VkFormat get_compatible_depth_surface_format(const gpu_formats_support &support, throw EXCEPTION("Invalid format (0x%x)", format); } -std::tuple get_min_filter_and_mip(u8 min_filter) +std::tuple get_min_filter_and_mip(rsx::texture_minify_filter min_filter) { switch (min_filter) { - case CELL_GCM_TEXTURE_NEAREST: return std::make_tuple(VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST); - case CELL_GCM_TEXTURE_LINEAR: return std::make_tuple(VK_FILTER_LINEAR, VK_SAMPLER_MIPMAP_MODE_NEAREST); - case CELL_GCM_TEXTURE_NEAREST_NEAREST: return std::make_tuple(VK_FILTER_LINEAR, VK_SAMPLER_MIPMAP_MODE_NEAREST); - case CELL_GCM_TEXTURE_LINEAR_NEAREST: return std::make_tuple(VK_FILTER_LINEAR, VK_SAMPLER_MIPMAP_MODE_NEAREST); - case CELL_GCM_TEXTURE_NEAREST_LINEAR: return std::make_tuple(VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_LINEAR); - case CELL_GCM_TEXTURE_LINEAR_LINEAR: return std::make_tuple(VK_FILTER_LINEAR, VK_SAMPLER_MIPMAP_MODE_LINEAR); - case CELL_GCM_TEXTURE_CONVOLUTION_MIN: return std::make_tuple(VK_FILTER_LINEAR, VK_SAMPLER_MIPMAP_MODE_LINEAR); + case rsx::texture_minify_filter::nearest: return std::make_tuple(VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST); + case rsx::texture_minify_filter::linear: return std::make_tuple(VK_FILTER_LINEAR, VK_SAMPLER_MIPMAP_MODE_NEAREST); + case rsx::texture_minify_filter::nearest_nearest: return std::make_tuple(VK_FILTER_LINEAR, VK_SAMPLER_MIPMAP_MODE_NEAREST); + case rsx::texture_minify_filter::linear_nearest: return std::make_tuple(VK_FILTER_LINEAR, VK_SAMPLER_MIPMAP_MODE_NEAREST); + case rsx::texture_minify_filter::nearest_linear: return std::make_tuple(VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_LINEAR); + case rsx::texture_minify_filter::linear_linear: return std::make_tuple(VK_FILTER_LINEAR, VK_SAMPLER_MIPMAP_MODE_LINEAR); + case rsx::texture_minify_filter::convolution_min: return std::make_tuple(VK_FILTER_LINEAR, VK_SAMPLER_MIPMAP_MODE_LINEAR); } - throw EXCEPTION("Invalid max filter (0x%x)", min_filter); + throw EXCEPTION("Invalid max filter"); } -VkFilter get_mag_filter(u8 mag_filter) +VkFilter get_mag_filter(rsx::texture_magnify_filter mag_filter) { switch (mag_filter) { - case CELL_GCM_TEXTURE_NEAREST: return VK_FILTER_NEAREST; - case CELL_GCM_TEXTURE_LINEAR: return VK_FILTER_LINEAR; - case CELL_GCM_TEXTURE_CONVOLUTION_MAG: return VK_FILTER_LINEAR; + case rsx::texture_magnify_filter::nearest: return VK_FILTER_NEAREST; + case rsx::texture_magnify_filter::linear: return VK_FILTER_LINEAR; + case rsx::texture_magnify_filter::convolution_mag: return VK_FILTER_LINEAR; } throw EXCEPTION("Invalid mag filter (0x%x)", mag_filter); } -VkSamplerAddressMode vk_wrap_mode(u32 gcm_wrap) +VkSamplerAddressMode vk_wrap_mode(rsx::texture_wrap_mode gcm_wrap) { switch (gcm_wrap) { - case CELL_GCM_TEXTURE_WRAP: return VK_SAMPLER_ADDRESS_MODE_REPEAT; - case CELL_GCM_TEXTURE_MIRROR: return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; - case CELL_GCM_TEXTURE_CLAMP_TO_EDGE: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; - case CELL_GCM_TEXTURE_BORDER: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; - case CELL_GCM_TEXTURE_CLAMP: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; - case CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP_TO_EDGE: return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; - case CELL_GCM_TEXTURE_MIRROR_ONCE_BORDER: return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; - case CELL_GCM_TEXTURE_MIRROR_ONCE_CLAMP: return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; - default: - throw EXCEPTION("unhandled texture clamp mode 0x%X", gcm_wrap); + case rsx::texture_wrap_mode::wrap: return VK_SAMPLER_ADDRESS_MODE_REPEAT; + case rsx::texture_wrap_mode::mirror: return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; + case rsx::texture_wrap_mode::clamp_to_edge: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + case rsx::texture_wrap_mode::border: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; + case rsx::texture_wrap_mode::clamp: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + case rsx::texture_wrap_mode::mirror_once_clamp_to_edge: return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; + case rsx::texture_wrap_mode::mirror_once_border: return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; + case rsx::texture_wrap_mode::mirror_once_clamp: return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; } + throw EXCEPTION("unhandled texture clamp mode"); } -float max_aniso(u32 gcm_aniso) +float max_aniso(rsx::texture_max_anisotropy gcm_aniso) { switch (gcm_aniso) { - case CELL_GCM_TEXTURE_MAX_ANISO_1: return 1.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_2: return 2.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_4: return 4.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_6: return 6.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_8: return 8.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_10: return 10.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_12: return 12.0f; - case CELL_GCM_TEXTURE_MAX_ANISO_16: return 16.0f; + case rsx::texture_max_anisotropy::x1: return 1.0f; + case rsx::texture_max_anisotropy::x2: return 2.0f; + case rsx::texture_max_anisotropy::x4: return 4.0f; + case rsx::texture_max_anisotropy::x6: return 6.0f; + case rsx::texture_max_anisotropy::x8: return 8.0f; + case rsx::texture_max_anisotropy::x10: return 10.0f; + case rsx::texture_max_anisotropy::x12: return 12.0f; + case rsx::texture_max_anisotropy::x16: return 16.0f; } throw EXCEPTION("Texture anisotropy error: bad max aniso (%d).", gcm_aniso); diff --git a/rpcs3/Emu/RSX/VK/VKFormats.h b/rpcs3/Emu/RSX/VK/VKFormats.h index b07e3c3db5..e970166e3f 100644 --- a/rpcs3/Emu/RSX/VK/VKFormats.h +++ b/rpcs3/Emu/RSX/VK/VKFormats.h @@ -13,10 +13,10 @@ namespace vk gpu_formats_support get_optimal_tiling_supported_formats(VkPhysicalDevice physical_device); VkFormat get_compatible_depth_surface_format(const gpu_formats_support &support, rsx::surface_depth_format format); - std::tuple get_min_filter_and_mip(u8 min_filter); - VkFilter get_mag_filter(u8 mag_filter); - VkSamplerAddressMode vk_wrap_mode(u32 gcm_wrap); - float max_aniso(u32 gcm_aniso); + std::tuple get_min_filter_and_mip(rsx::texture_minify_filter min_filter); + VkFilter get_mag_filter(rsx::texture_magnify_filter mag_filter); + VkSamplerAddressMode vk_wrap_mode(rsx::texture_wrap_mode gcm_wrap); + float max_aniso(rsx::texture_max_anisotropy gcm_aniso); VkComponentMapping get_component_mapping(u32 format, u8 swizzle_mask); VkPrimitiveTopology get_appropriate_topology(rsx::primitive_type& mode, bool &requires_modification); }