From f749fcfa9f42cda679ff7f4288c8418d2b56b08d Mon Sep 17 00:00:00 2001 From: Pokechu22 Date: Mon, 8 Feb 2021 15:22:10 -0800 Subject: Convert CPMemory to BitField and enum class Additionally, VCacheEnhance has been added to UVAT_group1. According to YAGCD, this field is always 1. TVtxDesc also now has separate low and high fields whose hex values correspond with the proper registers, instead of having one 33-bit value. This change was made in a way that should be backwards-compatible. --- Source/Core/VideoBackends/Software/SWVertexLoader.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'Source/Core/VideoBackends') diff --git a/Source/Core/VideoBackends/Software/SWVertexLoader.cpp b/Source/Core/VideoBackends/Software/SWVertexLoader.cpp index 3e90f69614..fdcafc71bf 100644 --- a/Source/Core/VideoBackends/Software/SWVertexLoader.cpp +++ b/Source/Core/VideoBackends/Software/SWVertexLoader.cpp @@ -183,8 +183,8 @@ static void ParseColorAttributes(InputVertexData* dst, DataReader& src, const auto set_default_color = [](u8* color, int i) { // The default alpha channel seems to depend on the number of components in the vertex format. const auto& g0 = g_main_cp_state.vtx_attr[g_main_cp_state.last_id].g0; - const u32 color_elements = i == 0 ? g0.Color0Elements : g0.Color1Elements; - color[0] = color_elements == 0 ? 255 : 0; + const auto color_elements = i == 0 ? g0.Color0Elements.Value() : g0.Color1Elements.Value(); + color[0] = color_elements == ColorComponentCount::RGB ? 255 : 0; color[1] = 255; color[2] = 255; color[3] = 255; -- cgit v1.2.3 From aab81d5aa0a1bd6a467c91d0dbba04a9dc40998f Mon Sep 17 00:00:00 2001 From: Pokechu22 Date: Wed, 10 Feb 2021 16:01:42 -0800 Subject: Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin). --- .../Core/VideoBackends/Software/TransformUnit.cpp | 88 +++++++++++----------- 1 file changed, 45 insertions(+), 43 deletions(-) (limited to 'Source/Core/VideoBackends') diff --git a/Source/Core/VideoBackends/Software/TransformUnit.cpp b/Source/Core/VideoBackends/Software/TransformUnit.cpp index 387903f117..0c7fccaf0b 100644 --- a/Source/Core/VideoBackends/Software/TransformUnit.cpp +++ b/Source/Core/VideoBackends/Software/TransformUnit.cpp @@ -80,7 +80,7 @@ void TransformPosition(const InputVertexData* src, OutputVertexData* dst) const float* mat = &xfmem.posMatrices[src->posMtx * 4]; MultiplyVec3Mat34(src->position, mat, dst->mvPosition); - if (xfmem.projection.type == GX_PERSPECTIVE) + if (xfmem.projection.type == ProjectionType::Perspective) { MultipleVec3Perspective(dst->mvPosition, xfmem.projection.rawProjection, dst->projectedPosition); @@ -115,39 +115,42 @@ static void TransformTexCoordRegular(const TexMtxInfo& texinfo, int coordNum, Vec3 src; switch (texinfo.sourcerow) { - case XF_SRCGEOM_INROW: + case SourceRow::Geom: src = srcVertex->position; break; - case XF_SRCNORMAL_INROW: + case SourceRow::Normal: src = srcVertex->normal[0]; break; - case XF_SRCBINORMAL_T_INROW: + case SourceRow::BinormalT: src = srcVertex->normal[1]; break; - case XF_SRCBINORMAL_B_INROW: + case SourceRow::BinormalB: src = srcVertex->normal[2]; break; default: - ASSERT(texinfo.sourcerow >= XF_SRCTEX0_INROW && texinfo.sourcerow <= XF_SRCTEX7_INROW); - src.x = srcVertex->texCoords[texinfo.sourcerow - XF_SRCTEX0_INROW][0]; - src.y = srcVertex->texCoords[texinfo.sourcerow - XF_SRCTEX0_INROW][1]; + { + ASSERT(texinfo.sourcerow >= SourceRow::Tex0 && texinfo.sourcerow <= SourceRow::Tex7); + u32 texnum = static_cast(texinfo.sourcerow.Value()) - static_cast(SourceRow::Tex0); + src.x = srcVertex->texCoords[texnum][0]; + src.y = srcVertex->texCoords[texnum][1]; src.z = 1.0f; break; } + } const float* mat = &xfmem.posMatrices[srcVertex->texMtx[coordNum] * 4]; Vec3* dst = &dstVertex->texCoords[coordNum]; - if (texinfo.projection == XF_TEXPROJ_ST) + if (texinfo.projection == TexSize::ST) { - if (texinfo.inputform == XF_TEXINPUT_AB11) + if (texinfo.inputform == TexInputForm::AB11) MultiplyVec2Mat24(src, mat, *dst); else MultiplyVec3Mat24(src, mat, *dst); } - else // texinfo.projection == XF_TEXPROJ_STQ + else // texinfo.projection == TexSize::STQ { - if (texinfo.inputform == XF_TEXINPUT_AB11) + if (texinfo.inputform == TexInputForm::AB11) MultiplyVec2Mat34(src, mat, *dst); else MultiplyVec3Mat34(src, mat, *dst); @@ -209,28 +212,28 @@ static float CalculateLightAttn(const LightPointer* light, Vec3* _ldir, const Ve switch (chan.attnfunc) { - case LIGHTATTN_NONE: - case LIGHTATTN_DIR: + case AttenuationFunc::None: + case AttenuationFunc::Dir: { ldir = ldir.Normalized(); if (ldir == Vec3(0.0f, 0.0f, 0.0f)) ldir = normal; break; } - case LIGHTATTN_SPEC: + case AttenuationFunc::Spec: { ldir = ldir.Normalized(); attn = (ldir * normal) >= 0.0 ? std::max(0.0f, light->dir * normal) : 0; Vec3 attLen = Vec3(1.0, attn, attn * attn); Vec3 cosAttn = light->cosatt; Vec3 distAttn = light->distatt; - if (chan.diffusefunc != LIGHTDIF_NONE) + if (chan.diffusefunc != DiffuseFunc::None) distAttn = distAttn.Normalized(); attn = SafeDivide(std::max(0.0f, attLen * cosAttn), attLen * distAttn); break; } - case LIGHTATTN_SPOT: + case AttenuationFunc::Spot: { float dist2 = ldir.Length2(); float dist = sqrtf(dist2); @@ -243,7 +246,7 @@ static float CalculateLightAttn(const LightPointer* light, Vec3* _ldir, const Ve break; } default: - PanicAlertFmt("LightColor"); + PanicAlertFmt("Invalid attnfunc: {}", chan.attnfunc); } return attn; @@ -260,18 +263,18 @@ static void LightColor(const Vec3& pos, const Vec3& normal, u8 lightNum, const L float difAttn = ldir * normal; switch (chan.diffusefunc) { - case LIGHTDIF_NONE: + case DiffuseFunc::None: AddScaledIntegerColor(light->color, attn, lightCol); break; - case LIGHTDIF_SIGN: + case DiffuseFunc::Sign: AddScaledIntegerColor(light->color, attn * difAttn, lightCol); break; - case LIGHTDIF_CLAMP: + case DiffuseFunc::Clamp: difAttn = std::max(0.0f, difAttn); AddScaledIntegerColor(light->color, attn * difAttn, lightCol); break; default: - ASSERT(0); + PanicAlertFmt("Invalid diffusefunc: {}", chan.attnfunc); } } @@ -286,18 +289,18 @@ static void LightAlpha(const Vec3& pos, const Vec3& normal, u8 lightNum, const L float difAttn = ldir * normal; switch (chan.diffusefunc) { - case LIGHTDIF_NONE: + case DiffuseFunc::None: lightCol += light->color[0] * attn; break; - case LIGHTDIF_SIGN: + case DiffuseFunc::Sign: lightCol += light->color[0] * attn * difAttn; break; - case LIGHTDIF_CLAMP: + case DiffuseFunc::Clamp: difAttn = std::max(0.0f, difAttn); lightCol += light->color[0] * attn * difAttn; break; default: - ASSERT(0); + PanicAlertFmt("Invalid diffusefunc: {}", chan.attnfunc); } } @@ -311,17 +314,16 @@ void TransformColor(const InputVertexData* src, OutputVertexData* dst) // color const LitChannel& colorchan = xfmem.color[chan]; - if (colorchan.matsource) - matcolor = src->color[chan]; // vertex + if (colorchan.matsource == MatSource::Vertex) + matcolor = src->color[chan]; else std::memcpy(matcolor.data(), &xfmem.matColor[chan], sizeof(u32)); if (colorchan.enablelighting) { Vec3 lightCol; - if (colorchan.ambsource) + if (colorchan.ambsource == AmbSource::Vertex) { - // vertex lightCol.x = src->color[chan][1]; lightCol.y = src->color[chan][2]; lightCol.z = src->color[chan][3]; @@ -355,16 +357,16 @@ void TransformColor(const InputVertexData* src, OutputVertexData* dst) // alpha const LitChannel& alphachan = xfmem.alpha[chan]; - if (alphachan.matsource) - matcolor[0] = src->color[chan][0]; // vertex + if (alphachan.matsource == MatSource::Vertex) + matcolor[0] = src->color[chan][0]; else matcolor[0] = xfmem.matColor[chan] & 0xff; if (xfmem.alpha[chan].enablelighting) { float lightCol; - if (alphachan.ambsource) - lightCol = src->color[chan][0]; // vertex + if (alphachan.ambsource == AmbSource::Vertex) + lightCol = src->color[chan][0]; else lightCol = static_cast(xfmem.ambColor[chan] & 0xff); @@ -397,10 +399,10 @@ void TransformTexCoord(const InputVertexData* src, OutputVertexData* dst) switch (texinfo.texgentype) { - case XF_TEXGEN_REGULAR: + case TexGenType::Regular: TransformTexCoordRegular(texinfo, coordNum, src, dst); break; - case XF_TEXGEN_EMBOSS_MAP: + case TexGenType::EmbossMap: { const LightPointer* light = (const LightPointer*)&xfmem.lights[texinfo.embosslightshift]; @@ -413,22 +415,22 @@ void TransformTexCoord(const InputVertexData* src, OutputVertexData* dst) dst->texCoords[coordNum].z = dst->texCoords[texinfo.embosssourceshift].z; } break; - case XF_TEXGEN_COLOR_STRGBC0: - ASSERT(texinfo.sourcerow == XF_SRCCOLORS_INROW); - ASSERT(texinfo.inputform == XF_TEXINPUT_AB11); + case TexGenType::Color0: + ASSERT(texinfo.sourcerow == SourceRow::Colors); + ASSERT(texinfo.inputform == TexInputForm::AB11); dst->texCoords[coordNum].x = (float)dst->color[0][0] / 255.0f; dst->texCoords[coordNum].y = (float)dst->color[0][1] / 255.0f; dst->texCoords[coordNum].z = 1.0f; break; - case XF_TEXGEN_COLOR_STRGBC1: - ASSERT(texinfo.sourcerow == XF_SRCCOLORS_INROW); - ASSERT(texinfo.inputform == XF_TEXINPUT_AB11); + case TexGenType::Color1: + ASSERT(texinfo.sourcerow == SourceRow::Colors); + ASSERT(texinfo.inputform == TexInputForm::AB11); dst->texCoords[coordNum].x = (float)dst->color[1][0] / 255.0f; dst->texCoords[coordNum].y = (float)dst->color[1][1] / 255.0f; dst->texCoords[coordNum].z = 1.0f; break; default: - ERROR_LOG_FMT(VIDEO, "Bad tex gen type {}", texinfo.texgentype.Value()); + ERROR_LOG_FMT(VIDEO, "Bad tex gen type {}", texinfo.texgentype); break; } } -- cgit v1.2.3 From 70f9fc4e7526fc9cfc008a43cd33229f62be99b6 Mon Sep 17 00:00:00 2001 From: Pokechu22 Date: Wed, 10 Feb 2021 18:11:31 -0800 Subject: Convert BPMemory to BitField and enum class Additional changes: - For TevStageCombiner's ColorCombiner and AlphaCombiner, op/comparison and scale/compare_mode have been split as there are different meanings and enums if bias is set to compare. (Shift has also been renamed to scale) - In TexMode0, min_filter has been split into min_mip and min_filter. - In TexImage1, image_type is now cache_manually_managed. - The unused bit in GenMode is now exposed. - LPSize's lineaspect is now named adjust_for_aspect_ratio. --- Source/Core/VideoBackends/D3D/D3DState.cpp | 14 +- Source/Core/VideoBackends/D3D12/DX12Pipeline.cpp | 22 +- Source/Core/VideoBackends/OGL/OGLRender.cpp | 14 +- Source/Core/VideoBackends/Software/Clipper.cpp | 7 +- .../Core/VideoBackends/Software/EfbInterface.cpp | 156 +++++----- Source/Core/VideoBackends/Software/Rasterizer.cpp | 5 +- Source/Core/VideoBackends/Software/Tev.cpp | 329 ++++++++++----------- Source/Core/VideoBackends/Software/Tev.h | 2 +- .../Core/VideoBackends/Software/TextureEncoder.cpp | 28 +- .../Core/VideoBackends/Software/TextureSampler.cpp | 28 +- Source/Core/VideoBackends/Vulkan/VKPipeline.cpp | 50 ++-- Source/Core/VideoBackends/Vulkan/VKRenderer.cpp | 6 +- 12 files changed, 321 insertions(+), 340 deletions(-) (limited to 'Source/Core/VideoBackends') diff --git a/Source/Core/VideoBackends/D3D/D3DState.cpp b/Source/Core/VideoBackends/D3D/D3DState.cpp index b345de0a38..b542c2b3de 100644 --- a/Source/Core/VideoBackends/D3D/D3DState.cpp +++ b/Source/Core/VideoBackends/D3D/D3DState.cpp @@ -378,7 +378,7 @@ ID3D11BlendState* StateCache::Get(BlendingState state) D3D11_LOGIC_OP_COPY_INVERTED, D3D11_LOGIC_OP_OR_INVERTED, D3D11_LOGIC_OP_NAND, D3D11_LOGIC_OP_SET}}; tdesc.LogicOpEnable = TRUE; - tdesc.LogicOp = logic_ops[state.logicmode]; + tdesc.LogicOp = logic_ops[u32(state.logicmode.Value())]; ComPtr res; HRESULT hr = D3D::device1->CreateBlendState1(&desc, res.GetAddressOf()); @@ -416,10 +416,10 @@ ID3D11BlendState* StateCache::Get(BlendingState state) use_dual_source ? D3D11_BLEND_INV_SRC1_ALPHA : D3D11_BLEND_INV_SRC_ALPHA, D3D11_BLEND_DEST_ALPHA, D3D11_BLEND_INV_DEST_ALPHA}}; - tdesc.SrcBlend = src_factors[state.srcfactor]; - tdesc.SrcBlendAlpha = src_factors[state.srcfactoralpha]; - tdesc.DestBlend = dst_factors[state.dstfactor]; - tdesc.DestBlendAlpha = dst_factors[state.dstfactoralpha]; + tdesc.SrcBlend = src_factors[u32(state.srcfactor.Value())]; + tdesc.SrcBlendAlpha = src_factors[u32(state.srcfactoralpha.Value())]; + tdesc.DestBlend = dst_factors[u32(state.dstfactor.Value())]; + tdesc.DestBlendAlpha = dst_factors[u32(state.dstfactoralpha.Value())]; tdesc.BlendOp = state.subtract ? D3D11_BLEND_OP_REV_SUBTRACT : D3D11_BLEND_OP_ADD; tdesc.BlendOpAlpha = state.subtractAlpha ? D3D11_BLEND_OP_REV_SUBTRACT : D3D11_BLEND_OP_ADD; @@ -441,7 +441,7 @@ ID3D11RasterizerState* StateCache::Get(RasterizationState state) D3D11_RASTERIZER_DESC desc = {}; desc.FillMode = D3D11_FILL_SOLID; - desc.CullMode = cull_modes[state.cullmode]; + desc.CullMode = cull_modes[u32(state.cullmode.Value())]; desc.ScissorEnable = TRUE; ComPtr res; @@ -477,7 +477,7 @@ ID3D11DepthStencilState* StateCache::Get(DepthState state) depthdc.DepthEnable = TRUE; depthdc.DepthWriteMask = state.updateenable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO; - depthdc.DepthFunc = d3dCmpFuncs[state.func]; + depthdc.DepthFunc = d3dCmpFuncs[u32(state.func.Value())]; } else { diff --git a/Source/Core/VideoBackends/D3D12/DX12Pipeline.cpp b/Source/Core/VideoBackends/D3D12/DX12Pipeline.cpp index dfce47a2fb..4cd75c10e5 100644 --- a/Source/Core/VideoBackends/D3D12/DX12Pipeline.cpp +++ b/Source/Core/VideoBackends/D3D12/DX12Pipeline.cpp @@ -66,7 +66,7 @@ static void GetD3DRasterizerDesc(D3D12_RASTERIZER_DESC* desc, const Rasterizatio {D3D12_CULL_MODE_NONE, D3D12_CULL_MODE_BACK, D3D12_CULL_MODE_FRONT, D3D12_CULL_MODE_FRONT}}; desc->FillMode = D3D12_FILL_MODE_SOLID; - desc->CullMode = cull_modes[rs_state.cullmode]; + desc->CullMode = cull_modes[u32(rs_state.cullmode.Value())]; desc->MultisampleEnable = fb_state.samples > 1; } @@ -80,7 +80,7 @@ static void GetD3DDepthDesc(D3D12_DEPTH_STENCIL_DESC* desc, const DepthState& st D3D12_COMPARISON_FUNC_ALWAYS}}; desc->DepthEnable = state.testenable; - desc->DepthFunc = compare_funcs[state.func]; + desc->DepthFunc = compare_funcs[u32(state.func.Value())]; desc->DepthWriteMask = state.updateenable ? D3D12_DEPTH_WRITE_MASK_ALL : D3D12_DEPTH_WRITE_MASK_ZERO; } @@ -135,24 +135,24 @@ static void GetD3DBlendDesc(D3D12_BLEND_DESC* desc, const BlendingState& state) rtblend->BlendOpAlpha = state.subtractAlpha ? D3D12_BLEND_OP_REV_SUBTRACT : D3D12_BLEND_OP_ADD; if (state.usedualsrc) { - rtblend->SrcBlend = src_dual_src_factors[state.srcfactor]; - rtblend->SrcBlendAlpha = src_dual_src_factors[state.srcfactoralpha]; - rtblend->DestBlend = dst_dual_src_factors[state.dstfactor]; - rtblend->DestBlendAlpha = dst_dual_src_factors[state.dstfactoralpha]; + rtblend->SrcBlend = src_dual_src_factors[u32(state.srcfactor.Value())]; + rtblend->SrcBlendAlpha = src_dual_src_factors[u32(state.srcfactoralpha.Value())]; + rtblend->DestBlend = dst_dual_src_factors[u32(state.dstfactor.Value())]; + rtblend->DestBlendAlpha = dst_dual_src_factors[u32(state.dstfactoralpha.Value())]; } else { - rtblend->SrcBlend = src_factors[state.srcfactor]; - rtblend->SrcBlendAlpha = src_factors[state.srcfactoralpha]; - rtblend->DestBlend = dst_factors[state.dstfactor]; - rtblend->DestBlendAlpha = dst_factors[state.dstfactoralpha]; + rtblend->SrcBlend = src_factors[u32(state.srcfactor.Value())]; + rtblend->SrcBlendAlpha = src_factors[u32(state.srcfactoralpha.Value())]; + rtblend->DestBlend = dst_factors[u32(state.dstfactor.Value())]; + rtblend->DestBlendAlpha = dst_factors[u32(state.dstfactoralpha.Value())]; } } else { rtblend->LogicOpEnable = state.logicopenable; if (state.logicopenable) - rtblend->LogicOp = logic_ops[state.logicmode]; + rtblend->LogicOp = logic_ops[u32(state.logicmode.Value())]; } } diff --git a/Source/Core/VideoBackends/OGL/OGLRender.cpp b/Source/Core/VideoBackends/OGL/OGLRender.cpp index 6b99327fee..3bcf38c2ae 100644 --- a/Source/Core/VideoBackends/OGL/OGLRender.cpp +++ b/Source/Core/VideoBackends/OGL/OGLRender.cpp @@ -1140,11 +1140,11 @@ void Renderer::ApplyRasterizationState(const RasterizationState state) return; // none, ccw, cw, ccw - if (state.cullmode != GenMode::CULL_NONE) + if (state.cullmode != CullMode::None) { // TODO: GX_CULL_ALL not supported, yet! glEnable(GL_CULL_FACE); - glFrontFace(state.cullmode == GenMode::CULL_FRONT ? GL_CCW : GL_CW); + glFrontFace(state.cullmode == CullMode::Front ? GL_CCW : GL_CW); } else { @@ -1166,7 +1166,7 @@ void Renderer::ApplyDepthState(const DepthState state) { glEnable(GL_DEPTH_TEST); glDepthMask(state.updateenable ? GL_TRUE : GL_FALSE); - glDepthFunc(glCmpFuncs[state.func]); + glDepthFunc(glCmpFuncs[u32(state.func.Value())]); } else { @@ -1229,8 +1229,10 @@ void Renderer::ApplyBlendingState(const BlendingState state) GLenum equation = state.subtract ? GL_FUNC_REVERSE_SUBTRACT : GL_FUNC_ADD; GLenum equationAlpha = state.subtractAlpha ? GL_FUNC_REVERSE_SUBTRACT : GL_FUNC_ADD; glBlendEquationSeparate(equation, equationAlpha); - glBlendFuncSeparate(src_factors[state.srcfactor], dst_factors[state.dstfactor], - src_factors[state.srcfactoralpha], dst_factors[state.dstfactoralpha]); + glBlendFuncSeparate(src_factors[u32(state.srcfactor.Value())], + dst_factors[u32(state.dstfactor.Value())], + src_factors[u32(state.srcfactoralpha.Value())], + dst_factors[u32(state.dstfactoralpha.Value())]); } const GLenum logic_op_codes[16] = { @@ -1244,7 +1246,7 @@ void Renderer::ApplyBlendingState(const BlendingState state) if (state.logicopenable) { glEnable(GL_COLOR_LOGIC_OP); - glLogicOp(logic_op_codes[state.logicmode]); + glLogicOp(logic_op_codes[u32(state.logicmode.Value())]); } else { diff --git a/Source/Core/VideoBackends/Software/Clipper.cpp b/Source/Core/VideoBackends/Software/Clipper.cpp index 4c4e0db52d..417bc63fa3 100644 --- a/Source/Core/VideoBackends/Software/Clipper.cpp +++ b/Source/Core/VideoBackends/Software/Clipper.cpp @@ -489,13 +489,16 @@ bool CullTest(const OutputVertexData* v0, const OutputVertexData* v1, const Outp backface = normalZDir <= 0.0f; - if ((bpmem.genMode.cullmode & 1) && !backface) // cull frontfacing + // TODO: Are these tests / the definition of backface above backwards? + if ((bpmem.genMode.cullmode == CullMode::Back || bpmem.genMode.cullmode == CullMode::All) && + !backface) // cull frontfacing { INCSTAT(g_stats.this_frame.num_triangles_culled) return false; } - if ((bpmem.genMode.cullmode & 2) && backface) // cull backfacing + if ((bpmem.genMode.cullmode == CullMode::Front || bpmem.genMode.cullmode == CullMode::All) && + backface) // cull backfacing { INCSTAT(g_stats.this_frame.num_triangles_culled) return false; diff --git a/Source/Core/VideoBackends/Software/EfbInterface.cpp b/Source/Core/VideoBackends/Software/EfbInterface.cpp index 0bd2f0343d..8ef62d5b03 100644 --- a/Source/Core/VideoBackends/Software/EfbInterface.cpp +++ b/Source/Core/VideoBackends/Software/EfbInterface.cpp @@ -41,12 +41,12 @@ static void SetPixelAlphaOnly(u32 offset, u8 a) { switch (bpmem.zcontrol.pixel_format) { - case PEControl::RGB8_Z24: - case PEControl::Z24: - case PEControl::RGB565_Z16: + case PixelFormat::RGB8_Z24: + case PixelFormat::Z24: + case PixelFormat::RGB565_Z16: // do nothing break; - case PEControl::RGBA6_Z24: + case PixelFormat::RGBA6_Z24: { u32 a32 = a; u32* dst = (u32*)&efb[offset]; @@ -56,8 +56,7 @@ static void SetPixelAlphaOnly(u32 offset, u8 a) } break; default: - ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", - static_cast(bpmem.zcontrol.pixel_format)); + ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", bpmem.zcontrol.pixel_format); break; } } @@ -66,8 +65,8 @@ static void SetPixelColorOnly(u32 offset, u8* rgb) { switch (bpmem.zcontrol.pixel_format) { - case PEControl::RGB8_Z24: - case PEControl::Z24: + case PixelFormat::RGB8_Z24: + case PixelFormat::Z24: { u32 src = *(u32*)rgb; u32* dst = (u32*)&efb[offset]; @@ -76,7 +75,7 @@ static void SetPixelColorOnly(u32 offset, u8* rgb) *dst = val; } break; - case PEControl::RGBA6_Z24: + case PixelFormat::RGBA6_Z24: { u32 src = *(u32*)rgb; u32* dst = (u32*)&efb[offset]; @@ -87,7 +86,7 @@ static void SetPixelColorOnly(u32 offset, u8* rgb) *dst = val; } break; - case PEControl::RGB565_Z16: + case PixelFormat::RGB565_Z16: { INFO_LOG_FMT(VIDEO, "RGB565_Z16 is not supported correctly yet"); u32 src = *(u32*)rgb; @@ -98,8 +97,7 @@ static void SetPixelColorOnly(u32 offset, u8* rgb) } break; default: - ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", - static_cast(bpmem.zcontrol.pixel_format)); + ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", bpmem.zcontrol.pixel_format); break; } } @@ -108,8 +106,8 @@ static void SetPixelAlphaColor(u32 offset, u8* color) { switch (bpmem.zcontrol.pixel_format) { - case PEControl::RGB8_Z24: - case PEControl::Z24: + case PixelFormat::RGB8_Z24: + case PixelFormat::Z24: { u32 src = *(u32*)color; u32* dst = (u32*)&efb[offset]; @@ -118,7 +116,7 @@ static void SetPixelAlphaColor(u32 offset, u8* color) *dst = val; } break; - case PEControl::RGBA6_Z24: + case PixelFormat::RGBA6_Z24: { u32 src = *(u32*)color; u32* dst = (u32*)&efb[offset]; @@ -130,7 +128,7 @@ static void SetPixelAlphaColor(u32 offset, u8* color) *dst = val; } break; - case PEControl::RGB565_Z16: + case PixelFormat::RGB565_Z16: { INFO_LOG_FMT(VIDEO, "RGB565_Z16 is not supported correctly yet"); u32 src = *(u32*)color; @@ -141,8 +139,7 @@ static void SetPixelAlphaColor(u32 offset, u8* color) } break; default: - ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", - static_cast(bpmem.zcontrol.pixel_format)); + ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", bpmem.zcontrol.pixel_format); break; } } @@ -154,23 +151,22 @@ static u32 GetPixelColor(u32 offset) switch (bpmem.zcontrol.pixel_format) { - case PEControl::RGB8_Z24: - case PEControl::Z24: + case PixelFormat::RGB8_Z24: + case PixelFormat::Z24: return 0xff | ((src & 0x00ffffff) << 8); - case PEControl::RGBA6_Z24: + case PixelFormat::RGBA6_Z24: return Convert6To8(src & 0x3f) | // Alpha Convert6To8((src >> 6) & 0x3f) << 8 | // Blue Convert6To8((src >> 12) & 0x3f) << 16 | // Green Convert6To8((src >> 18) & 0x3f) << 24; // Red - case PEControl::RGB565_Z16: + case PixelFormat::RGB565_Z16: INFO_LOG_FMT(VIDEO, "RGB565_Z16 is not supported correctly yet"); return 0xff | ((src & 0x00ffffff) << 8); default: - ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", - static_cast(bpmem.zcontrol.pixel_format)); + ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", bpmem.zcontrol.pixel_format); return 0; } } @@ -179,9 +175,9 @@ static void SetPixelDepth(u32 offset, u32 depth) { switch (bpmem.zcontrol.pixel_format) { - case PEControl::RGB8_Z24: - case PEControl::RGBA6_Z24: - case PEControl::Z24: + case PixelFormat::RGB8_Z24: + case PixelFormat::RGBA6_Z24: + case PixelFormat::Z24: { u32* dst = (u32*)&efb[offset]; u32 val = *dst & 0xff000000; @@ -189,7 +185,7 @@ static void SetPixelDepth(u32 offset, u32 depth) *dst = val; } break; - case PEControl::RGB565_Z16: + case PixelFormat::RGB565_Z16: { INFO_LOG_FMT(VIDEO, "RGB565_Z16 is not supported correctly yet"); u32* dst = (u32*)&efb[offset]; @@ -199,8 +195,7 @@ static void SetPixelDepth(u32 offset, u32 depth) } break; default: - ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", - static_cast(bpmem.zcontrol.pixel_format)); + ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", bpmem.zcontrol.pixel_format); break; } } @@ -211,59 +206,58 @@ static u32 GetPixelDepth(u32 offset) switch (bpmem.zcontrol.pixel_format) { - case PEControl::RGB8_Z24: - case PEControl::RGBA6_Z24: - case PEControl::Z24: + case PixelFormat::RGB8_Z24: + case PixelFormat::RGBA6_Z24: + case PixelFormat::Z24: { depth = (*(u32*)&efb[offset]) & 0x00ffffff; } break; - case PEControl::RGB565_Z16: + case PixelFormat::RGB565_Z16: { INFO_LOG_FMT(VIDEO, "RGB565_Z16 is not supported correctly yet"); depth = (*(u32*)&efb[offset]) & 0x00ffffff; } break; default: - ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", - static_cast(bpmem.zcontrol.pixel_format)); + ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}", bpmem.zcontrol.pixel_format); break; } return depth; } -static u32 GetSourceFactor(u8* srcClr, u8* dstClr, BlendMode::BlendFactor mode) +static u32 GetSourceFactor(u8* srcClr, u8* dstClr, SrcBlendFactor mode) { switch (mode) { - case BlendMode::ZERO: + case SrcBlendFactor::Zero: return 0; - case BlendMode::ONE: + case SrcBlendFactor::One: return 0xffffffff; - case BlendMode::DSTCLR: + case SrcBlendFactor::DstClr: return *(u32*)dstClr; - case BlendMode::INVDSTCLR: + case SrcBlendFactor::InvDstClr: return 0xffffffff - *(u32*)dstClr; - case BlendMode::SRCALPHA: + case SrcBlendFactor::SrcAlpha: { u8 alpha = srcClr[ALP_C]; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; return factor; } - case BlendMode::INVSRCALPHA: + case SrcBlendFactor::InvSrcAlpha: { u8 alpha = 0xff - srcClr[ALP_C]; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; return factor; } - case BlendMode::DSTALPHA: + case SrcBlendFactor::DstAlpha: { u8 alpha = dstClr[ALP_C]; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; return factor; } - case BlendMode::INVDSTALPHA: + case SrcBlendFactor::InvDstAlpha: { u8 alpha = 0xff - dstClr[ALP_C]; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; @@ -274,37 +268,37 @@ static u32 GetSourceFactor(u8* srcClr, u8* dstClr, BlendMode::BlendFactor mode) return 0; } -static u32 GetDestinationFactor(u8* srcClr, u8* dstClr, BlendMode::BlendFactor mode) +static u32 GetDestinationFactor(u8* srcClr, u8* dstClr, DstBlendFactor mode) { switch (mode) { - case BlendMode::ZERO: + case DstBlendFactor::Zero: return 0; - case BlendMode::ONE: + case DstBlendFactor::One: return 0xffffffff; - case BlendMode::SRCCLR: + case DstBlendFactor::SrcClr: return *(u32*)srcClr; - case BlendMode::INVSRCCLR: + case DstBlendFactor::InvSrcClr: return 0xffffffff - *(u32*)srcClr; - case BlendMode::SRCALPHA: + case DstBlendFactor::SrcAlpha: { u8 alpha = srcClr[ALP_C]; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; return factor; } - case BlendMode::INVSRCALPHA: + case DstBlendFactor::InvSrcAlpha: { u8 alpha = 0xff - srcClr[ALP_C]; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; return factor; } - case BlendMode::DSTALPHA: + case DstBlendFactor::DstAlpha: { u8 alpha = dstClr[ALP_C] & 0xff; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; return factor; } - case BlendMode::INVDSTALPHA: + case DstBlendFactor::InvDstAlpha: { u8 alpha = 0xff - dstClr[ALP_C]; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; @@ -337,56 +331,56 @@ static void BlendColor(u8* srcClr, u8* dstClr) } } -static void LogicBlend(u32 srcClr, u32* dstClr, BlendMode::LogicOp op) +static void LogicBlend(u32 srcClr, u32* dstClr, LogicOp op) { switch (op) { - case BlendMode::CLEAR: + case LogicOp::Clear: *dstClr = 0; break; - case BlendMode::AND: + case LogicOp::And: *dstClr = srcClr & *dstClr; break; - case BlendMode::AND_REVERSE: + case LogicOp::AndReverse: *dstClr = srcClr & (~*dstClr); break; - case BlendMode::COPY: + case LogicOp::Copy: *dstClr = srcClr; break; - case BlendMode::AND_INVERTED: + case LogicOp::AndInverted: *dstClr = (~srcClr) & *dstClr; break; - case BlendMode::NOOP: + case LogicOp::NoOp: // Do nothing break; - case BlendMode::XOR: + case LogicOp::Xor: *dstClr = srcClr ^ *dstClr; break; - case BlendMode::OR: + case LogicOp::Or: *dstClr = srcClr | *dstClr; break; - case BlendMode::NOR: + case LogicOp::Nor: *dstClr = ~(srcClr | *dstClr); break; - case BlendMode::EQUIV: + case LogicOp::Equiv: *dstClr = ~(srcClr ^ *dstClr); break; - case BlendMode::INVERT: + case LogicOp::Invert: *dstClr = ~*dstClr; break; - case BlendMode::OR_REVERSE: + case LogicOp::OrReverse: *dstClr = srcClr | (~*dstClr); break; - case BlendMode::COPY_INVERTED: + case LogicOp::CopyInverted: *dstClr = ~srcClr; break; - case BlendMode::OR_INVERTED: + case LogicOp::OrInverted: *dstClr = (~srcClr) | *dstClr; break; - case BlendMode::NAND: + case LogicOp::Nand: *dstClr = ~(srcClr & *dstClr); break; - case BlendMode::SET: + case LogicOp::Set: *dstClr = 0xffffffff; break; } @@ -404,7 +398,7 @@ static void SubtractBlend(u8* srcClr, u8* dstClr) static void Dither(u16 x, u16 y, u8* color) { // No blending for RGB8 mode - if (!bpmem.blendmode.dither || bpmem.zcontrol.pixel_format != PEControl::PixelFormat::RGBA6_Z24) + if (!bpmem.blendmode.dither || bpmem.zcontrol.pixel_format != PixelFormat::RGBA6_Z24) return; // Flipper uses a standard 2x2 Bayer Matrix for 6 bit dithering @@ -662,33 +656,33 @@ bool ZCompare(u16 x, u16 y, u32 z) switch (bpmem.zmode.func) { - case ZMode::NEVER: + case CompareMode::Never: pass = false; break; - case ZMode::LESS: + case CompareMode::Less: pass = z < depth; break; - case ZMode::EQUAL: + case CompareMode::Equal: pass = z == depth; break; - case ZMode::LEQUAL: + case CompareMode::LEqual: pass = z <= depth; break; - case ZMode::GREATER: + case CompareMode::Greater: pass = z > depth; break; - case ZMode::NEQUAL: + case CompareMode::NEqual: pass = z != depth; break; - case ZMode::GEQUAL: + case CompareMode::GEqual: pass = z >= depth; break; - case ZMode::ALWAYS: + case CompareMode::Always: pass = true; break; default: pass = false; - ERROR_LOG_FMT(VIDEO, "Bad Z compare mode {}", static_cast(bpmem.zmode.func)); + ERROR_LOG_FMT(VIDEO, "Bad Z compare mode {}", bpmem.zmode.func); break; } diff --git a/Source/Core/VideoBackends/Software/Rasterizer.cpp b/Source/Core/VideoBackends/Software/Rasterizer.cpp index 394bfea41e..e987817c8c 100644 --- a/Source/Core/VideoBackends/Software/Rasterizer.cpp +++ b/Source/Core/VideoBackends/Software/Rasterizer.cpp @@ -173,7 +173,7 @@ static inline void CalculateLOD(s32* lodp, bool* linear, u32 texmap, u32 texcoor const TexMode1& tm1 = texUnit.texMode1[subTexmap]; float sDelta, tDelta; - if (tm0.diag_lod) + if (tm0.diag_lod == LODType::Diagonal) { float* uv0 = rasterBlock.Pixel[0][0].Uv[texcoord]; float* uv1 = rasterBlock.Pixel[1][1].Uv[texcoord]; @@ -199,7 +199,8 @@ static inline void CalculateLOD(s32* lodp, bool* linear, u32 texmap, u32 texcoor bias >>= 1; lod += bias; - *linear = ((lod > 0 && (tm0.min_filter & 4)) || (lod <= 0 && tm0.mag_filter)); + *linear = ((lod > 0 && tm0.min_filter == FilterMode::Linear) || + (lod <= 0 && tm0.mag_filter == FilterMode::Linear)); // NOTE: The order of comparisons for this clamp check matters. if (lod > static_cast(tm1.max_lod)) diff --git a/Source/Core/VideoBackends/Software/Tev.cpp b/Source/Core/VideoBackends/Software/Tev.cpp index fed65d2bec..65227339e4 100644 --- a/Source/Core/VideoBackends/Software/Tev.cpp +++ b/Source/Core/VideoBackends/Software/Tev.cpp @@ -172,11 +172,11 @@ static inline s16 Clamp1024(s16 in) return in > 1023 ? 1023 : (in < -1024 ? -1024 : in); } -void Tev::SetRasColor(int colorChan, int swaptable) +void Tev::SetRasColor(RasColorChan colorChan, int swaptable) { switch (colorChan) { - case 0: // Color0 + case RasColorChan::Color0: { const u8* color = Color[0]; RasColor[RED_C] = color[bpmem.tevksel[swaptable].swap1]; @@ -186,7 +186,7 @@ void Tev::SetRasColor(int colorChan, int swaptable) RasColor[ALP_C] = color[bpmem.tevksel[swaptable].swap2]; } break; - case 1: // Color1 + case RasColorChan::Color1: { const u8* color = Color[1]; RasColor[RED_C] = color[bpmem.tevksel[swaptable].swap1]; @@ -196,7 +196,7 @@ void Tev::SetRasColor(int colorChan, int swaptable) RasColor[ALP_C] = color[bpmem.tevksel[swaptable].swap2]; } break; - case 5: // alpha bump + case RasColorChan::AlphaBump: { for (s16& comp : RasColor) { @@ -204,7 +204,7 @@ void Tev::SetRasColor(int colorChan, int swaptable) } } break; - case 6: // alpha bump normalized + case RasColorChan::NormalizedAlphaBump: { const u8 normalized = AlphaBump | AlphaBump >> 5; for (s16& comp : RasColor) @@ -213,8 +213,11 @@ void Tev::SetRasColor(int colorChan, int swaptable) } } break; - default: // zero + default: { + if (colorChan != RasColorChan::Zero) + PanicAlertFmt("Invalid ras color channel: {}", colorChan); + for (s16& comp : RasColor) { comp = 0; @@ -226,22 +229,24 @@ void Tev::SetRasColor(int colorChan, int swaptable) void Tev::DrawColorRegular(const TevStageCombiner::ColorCombiner& cc, const InputRegType inputs[4]) { - for (int i = 0; i < 3; i++) + for (int i = BLU_C; i <= RED_C; i++) { - const InputRegType& InputReg = inputs[BLU_C + i]; + const InputRegType& InputReg = inputs[i]; const u16 c = InputReg.c + (InputReg.c >> 7); s32 temp = InputReg.a * (256 - c) + (InputReg.b * c); - temp <<= m_ScaleLShiftLUT[cc.shift]; - temp += (cc.shift == 3) ? 0 : (cc.op == 1) ? 127 : 128; + temp <<= m_ScaleLShiftLUT[u32(cc.scale.Value())]; + temp += (cc.scale == TevScale::Divide2) ? 0 : (cc.op == TevOp::Sub) ? 127 : 128; temp >>= 8; - temp = cc.op ? -temp : temp; + temp = cc.op == TevOp::Sub ? -temp : temp; - s32 result = ((InputReg.d + m_BiasLUT[cc.bias]) << m_ScaleLShiftLUT[cc.shift]) + temp; - result = result >> m_ScaleRShiftLUT[cc.shift]; + s32 result = ((InputReg.d + m_BiasLUT[u32(cc.bias.Value())]) + << m_ScaleLShiftLUT[u32(cc.scale.Value())]) + + temp; + result = result >> m_ScaleRShiftLUT[u32(cc.scale.Value())]; - Reg[cc.dest][BLU_C + i] = result; + Reg[u32(cc.dest.Value())][i] = result; } } @@ -249,56 +254,38 @@ void Tev::DrawColorCompare(const TevStageCombiner::ColorCombiner& cc, const Inpu { for (int i = BLU_C; i <= RED_C; i++) { - switch ((cc.shift << 1) | cc.op | 8) // encoded compare mode + u32 a, b; + switch (cc.compare_mode) { - case TEVCMP_R8_GT: - Reg[cc.dest][i] = inputs[i].d + ((inputs[RED_C].a > inputs[RED_C].b) ? inputs[i].c : 0); + case TevCompareMode::R8: + a = inputs[RED_C].a; + b = inputs[RED_C].b; break; - case TEVCMP_R8_EQ: - Reg[cc.dest][i] = inputs[i].d + ((inputs[RED_C].a == inputs[RED_C].b) ? inputs[i].c : 0); + case TevCompareMode::GR16: + a = (inputs[GRN_C].a << 8) | inputs[RED_C].a; + b = (inputs[GRN_C].b << 8) | inputs[RED_C].b; break; - case TEVCMP_GR16_GT: - { - const u32 a = (inputs[GRN_C].a << 8) | inputs[RED_C].a; - const u32 b = (inputs[GRN_C].b << 8) | inputs[RED_C].b; - Reg[cc.dest][i] = inputs[i].d + ((a > b) ? inputs[i].c : 0); - } - break; - - case TEVCMP_GR16_EQ: - { - const u32 a = (inputs[GRN_C].a << 8) | inputs[RED_C].a; - const u32 b = (inputs[GRN_C].b << 8) | inputs[RED_C].b; - Reg[cc.dest][i] = inputs[i].d + ((a == b) ? inputs[i].c : 0); - } - break; - - case TEVCMP_BGR24_GT: - { - const u32 a = (inputs[BLU_C].a << 16) | (inputs[GRN_C].a << 8) | inputs[RED_C].a; - const u32 b = (inputs[BLU_C].b << 16) | (inputs[GRN_C].b << 8) | inputs[RED_C].b; - Reg[cc.dest][i] = inputs[i].d + ((a > b) ? inputs[i].c : 0); - } - break; - - case TEVCMP_BGR24_EQ: - { - const u32 a = (inputs[BLU_C].a << 16) | (inputs[GRN_C].a << 8) | inputs[RED_C].a; - const u32 b = (inputs[BLU_C].b << 16) | (inputs[GRN_C].b << 8) | inputs[RED_C].b; - Reg[cc.dest][i] = inputs[i].d + ((a == b) ? inputs[i].c : 0); - } - break; - - case TEVCMP_RGB8_GT: - Reg[cc.dest][i] = inputs[i].d + ((inputs[i].a > inputs[i].b) ? inputs[i].c : 0); + case TevCompareMode::BGR24: + a = (inputs[BLU_C].a << 16) | (inputs[GRN_C].a << 8) | inputs[RED_C].a; + b = (inputs[BLU_C].b << 16) | (inputs[GRN_C].b << 8) | inputs[RED_C].b; break; - case TEVCMP_RGB8_EQ: - Reg[cc.dest][i] = inputs[i].d + ((inputs[i].a == inputs[i].b) ? inputs[i].c : 0); + case TevCompareMode::RGB8: + a = inputs[i].a; + b = inputs[i].b; break; + + default: + PanicAlertFmt("Invalid compare mode {}", cc.compare_mode); + continue; } + + if (cc.comparison == TevComparison::GT) + Reg[u32(cc.dest.Value())][i] = inputs[i].d + ((a > b) ? inputs[i].c : 0); + else + Reg[u32(cc.dest.Value())][i] = inputs[i].d + ((a == b) ? inputs[i].c : 0); } } @@ -309,95 +296,76 @@ void Tev::DrawAlphaRegular(const TevStageCombiner::AlphaCombiner& ac, const Inpu const u16 c = InputReg.c + (InputReg.c >> 7); s32 temp = InputReg.a * (256 - c) + (InputReg.b * c); - temp <<= m_ScaleLShiftLUT[ac.shift]; - temp += (ac.shift != 3) ? 0 : (ac.op == 1) ? 127 : 128; - temp = ac.op ? (-temp >> 8) : (temp >> 8); + temp <<= m_ScaleLShiftLUT[u32(ac.scale.Value())]; + temp += (ac.scale != TevScale::Divide2) ? 0 : (ac.op == TevOp::Sub) ? 127 : 128; + temp = ac.op == TevOp::Sub ? (-temp >> 8) : (temp >> 8); - s32 result = ((InputReg.d + m_BiasLUT[ac.bias]) << m_ScaleLShiftLUT[ac.shift]) + temp; - result = result >> m_ScaleRShiftLUT[ac.shift]; + s32 result = + ((InputReg.d + m_BiasLUT[u32(ac.bias.Value())]) << m_ScaleLShiftLUT[u32(ac.scale.Value())]) + + temp; + result = result >> m_ScaleRShiftLUT[u32(ac.scale.Value())]; - Reg[ac.dest][ALP_C] = result; + Reg[u32(ac.dest.Value())][ALP_C] = result; } void Tev::DrawAlphaCompare(const TevStageCombiner::AlphaCombiner& ac, const InputRegType inputs[4]) { - switch ((ac.shift << 1) | ac.op | 8) // encoded compare mode + u32 a, b; + switch (ac.compare_mode) { - case TEVCMP_R8_GT: - Reg[ac.dest][ALP_C] = - inputs[ALP_C].d + ((inputs[RED_C].a > inputs[RED_C].b) ? inputs[ALP_C].c : 0); + case TevCompareMode::R8: + a = inputs[RED_C].a; + b = inputs[RED_C].b; break; - case TEVCMP_R8_EQ: - Reg[ac.dest][ALP_C] = - inputs[ALP_C].d + ((inputs[RED_C].a == inputs[RED_C].b) ? inputs[ALP_C].c : 0); + case TevCompareMode::GR16: + a = (inputs[GRN_C].a << 8) | inputs[RED_C].a; + b = (inputs[GRN_C].b << 8) | inputs[RED_C].b; break; - case TEVCMP_GR16_GT: - { - const u32 a = (inputs[GRN_C].a << 8) | inputs[RED_C].a; - const u32 b = (inputs[GRN_C].b << 8) | inputs[RED_C].b; - Reg[ac.dest][ALP_C] = inputs[ALP_C].d + ((a > b) ? inputs[ALP_C].c : 0); - } - break; - - case TEVCMP_GR16_EQ: - { - const u32 a = (inputs[GRN_C].a << 8) | inputs[RED_C].a; - const u32 b = (inputs[GRN_C].b << 8) | inputs[RED_C].b; - Reg[ac.dest][ALP_C] = inputs[ALP_C].d + ((a == b) ? inputs[ALP_C].c : 0); - } - break; - - case TEVCMP_BGR24_GT: - { - const u32 a = (inputs[BLU_C].a << 16) | (inputs[GRN_C].a << 8) | inputs[RED_C].a; - const u32 b = (inputs[BLU_C].b << 16) | (inputs[GRN_C].b << 8) | inputs[RED_C].b; - Reg[ac.dest][ALP_C] = inputs[ALP_C].d + ((a > b) ? inputs[ALP_C].c : 0); - } - break; - - case TEVCMP_BGR24_EQ: - { - const u32 a = (inputs[BLU_C].a << 16) | (inputs[GRN_C].a << 8) | inputs[RED_C].a; - const u32 b = (inputs[BLU_C].b << 16) | (inputs[GRN_C].b << 8) | inputs[RED_C].b; - Reg[ac.dest][ALP_C] = inputs[ALP_C].d + ((a == b) ? inputs[ALP_C].c : 0); - } - break; - - case TEVCMP_A8_GT: - Reg[ac.dest][ALP_C] = - inputs[ALP_C].d + ((inputs[ALP_C].a > inputs[ALP_C].b) ? inputs[ALP_C].c : 0); + case TevCompareMode::BGR24: + a = (inputs[BLU_C].a << 16) | (inputs[GRN_C].a << 8) | inputs[RED_C].a; + b = (inputs[BLU_C].b << 16) | (inputs[GRN_C].b << 8) | inputs[RED_C].b; break; - case TEVCMP_A8_EQ: - Reg[ac.dest][ALP_C] = - inputs[ALP_C].d + ((inputs[ALP_C].a == inputs[ALP_C].b) ? inputs[ALP_C].c : 0); + case TevCompareMode::A8: + a = inputs[ALP_C].a; + b = inputs[ALP_C].b; break; + + default: + PanicAlertFmt("Invalid compare mode {}", ac.compare_mode); + return; } + + if (ac.comparison == TevComparison::GT) + Reg[u32(ac.dest.Value())][ALP_C] = inputs[ALP_C].d + ((a > b) ? inputs[ALP_C].c : 0); + else + Reg[u32(ac.dest.Value())][ALP_C] = inputs[ALP_C].d + ((a == b) ? inputs[ALP_C].c : 0); } -static bool AlphaCompare(int alpha, int ref, AlphaTest::CompareMode comp) +static bool AlphaCompare(int alpha, int ref, CompareMode comp) { switch (comp) { - case AlphaTest::ALWAYS: + case CompareMode::Always: return true; - case AlphaTest::NEVER: + case CompareMode::Never: return false; - case AlphaTest::LEQUAL: + case CompareMode::LEqual: return alpha <= ref; - case AlphaTest::LESS: + case CompareMode::Less: return alpha < ref; - case AlphaTest::GEQUAL: + case CompareMode::GEqual: return alpha >= ref; - case AlphaTest::GREATER: + case CompareMode::Greater: return alpha > ref; - case AlphaTest::EQUAL: + case CompareMode::Equal: return alpha == ref; - case AlphaTest::NEQUAL: + case CompareMode::NEqual: return alpha != ref; default: + PanicAlertFmt("Invalid compare mode {}", comp); return true; } } @@ -409,38 +377,40 @@ static bool TevAlphaTest(int alpha) switch (bpmem.alpha_test.logic) { - case 0: - return comp0 && comp1; // and - case 1: - return comp0 || comp1; // or - case 2: - return comp0 ^ comp1; // xor - case 3: - return !(comp0 ^ comp1); // xnor + case AlphaTestOp::And: + return comp0 && comp1; + case AlphaTestOp::Or: + return comp0 || comp1; + case AlphaTestOp::Xor: + return comp0 ^ comp1; + case AlphaTestOp::Xnor: + return !(comp0 ^ comp1); default: + PanicAlertFmt("Invalid AlphaTestOp {}", bpmem.alpha_test.logic); return true; } } -static inline s32 WrapIndirectCoord(s32 coord, int wrapMode) +static inline s32 WrapIndirectCoord(s32 coord, IndTexWrap wrapMode) { switch (wrapMode) { - case ITW_OFF: + case IndTexWrap::ITW_OFF: return coord; - case ITW_256: + case IndTexWrap::ITW_256: return (coord & ((256 << 7) - 1)); - case ITW_128: + case IndTexWrap::ITW_128: return (coord & ((128 << 7) - 1)); - case ITW_64: + case IndTexWrap::ITW_64: return (coord & ((64 << 7) - 1)); - case ITW_32: + case IndTexWrap::ITW_32: return (coord & ((32 << 7) - 1)); - case ITW_16: + case IndTexWrap::ITW_16: return (coord & ((16 << 7) - 1)); - case ITW_0: + case IndTexWrap::ITW_0: return 0; default: + PanicAlertFmt("Invalid indirect wrap mode {}", wrapMode); return 0; } } @@ -455,56 +425,59 @@ void Tev::Indirect(unsigned int stageNum, s32 s, s32 t) // alpha bump select switch (indirect.bs) { - case ITBA_OFF: + case IndTexBumpAlpha::Off: AlphaBump = 0; break; - case ITBA_S: + case IndTexBumpAlpha::S: AlphaBump = indmap[TextureSampler::ALP_SMP]; break; - case ITBA_T: + case IndTexBumpAlpha::T: AlphaBump = indmap[TextureSampler::BLU_SMP]; break; - case ITBA_U: + case IndTexBumpAlpha::U: AlphaBump = indmap[TextureSampler::GRN_SMP]; break; + default: + PanicAlertFmt("Invalid alpha bump {}", indirect.bs); + return; } // bias select - const s16 biasValue = indirect.fmt == ITF_8 ? -128 : 1; + const s16 biasValue = indirect.fmt == IndTexFormat::ITF_8 ? -128 : 1; s16 bias[3]; - bias[0] = indirect.bias & 1 ? biasValue : 0; - bias[1] = indirect.bias & 2 ? biasValue : 0; - bias[2] = indirect.bias & 4 ? biasValue : 0; + bias[0] = indirect.bias_s ? biasValue : 0; + bias[1] = indirect.bias_t ? biasValue : 0; + bias[2] = indirect.bias_u ? biasValue : 0; // format switch (indirect.fmt) { - case ITF_8: + case IndTexFormat::ITF_8: indcoord[0] = indmap[TextureSampler::ALP_SMP] + bias[0]; indcoord[1] = indmap[TextureSampler::BLU_SMP] + bias[1]; indcoord[2] = indmap[TextureSampler::GRN_SMP] + bias[2]; AlphaBump = AlphaBump & 0xf8; break; - case ITF_5: + case IndTexFormat::ITF_5: indcoord[0] = (indmap[TextureSampler::ALP_SMP] & 0x1f) + bias[0]; indcoord[1] = (indmap[TextureSampler::BLU_SMP] & 0x1f) + bias[1]; indcoord[2] = (indmap[TextureSampler::GRN_SMP] & 0x1f) + bias[2]; AlphaBump = AlphaBump & 0xe0; break; - case ITF_4: + case IndTexFormat::ITF_4: indcoord[0] = (indmap[TextureSampler::ALP_SMP] & 0x0f) + bias[0]; indcoord[1] = (indmap[TextureSampler::BLU_SMP] & 0x0f) + bias[1]; indcoord[2] = (indmap[TextureSampler::GRN_SMP] & 0x0f) + bias[2]; AlphaBump = AlphaBump & 0xf0; break; - case ITF_3: + case IndTexFormat::ITF_3: indcoord[0] = (indmap[TextureSampler::ALP_SMP] & 0x07) + bias[0]; indcoord[1] = (indmap[TextureSampler::BLU_SMP] & 0x07) + bias[1]; indcoord[2] = (indmap[TextureSampler::GRN_SMP] & 0x07) + bias[2]; AlphaBump = AlphaBump & 0xf8; break; default: - PanicAlertFmt("Tev::Indirect"); + PanicAlertFmt("Invalid indirect format {}", indirect.fmt); return; } @@ -648,8 +621,8 @@ void Tev::Draw() } // set konst for this stage - const int kc = kSel.getKC(stageOdd); - const int ka = kSel.getKA(stageOdd); + const auto kc = u32(kSel.getKC(stageOdd)); + const auto ka = u32(kSel.getKA(stageOdd)); StageKonst[RED_C] = *(m_KonstLUT[kc][RED_C]); StageKonst[GRN_C] = *(m_KonstLUT[kc][GRN_C]); StageKonst[BLU_C] = *(m_KonstLUT[kc][BLU_C]); @@ -662,43 +635,43 @@ void Tev::Draw() InputRegType inputs[4]; for (int i = 0; i < 3; i++) { - inputs[BLU_C + i].a = *m_ColorInputLUT[cc.a][i]; - inputs[BLU_C + i].b = *m_ColorInputLUT[cc.b][i]; - inputs[BLU_C + i].c = *m_ColorInputLUT[cc.c][i]; - inputs[BLU_C + i].d = *m_ColorInputLUT[cc.d][i]; + inputs[BLU_C + i].a = *m_ColorInputLUT[u32(cc.a.Value())][i]; + inputs[BLU_C + i].b = *m_ColorInputLUT[u32(cc.b.Value())][i]; + inputs[BLU_C + i].c = *m_ColorInputLUT[u32(cc.c.Value())][i]; + inputs[BLU_C + i].d = *m_ColorInputLUT[u32(cc.d.Value())][i]; } - inputs[ALP_C].a = *m_AlphaInputLUT[ac.a]; - inputs[ALP_C].b = *m_AlphaInputLUT[ac.b]; - inputs[ALP_C].c = *m_AlphaInputLUT[ac.c]; - inputs[ALP_C].d = *m_AlphaInputLUT[ac.d]; + inputs[ALP_C].a = *m_AlphaInputLUT[u32(ac.a.Value())]; + inputs[ALP_C].b = *m_AlphaInputLUT[u32(ac.b.Value())]; + inputs[ALP_C].c = *m_AlphaInputLUT[u32(ac.c.Value())]; + inputs[ALP_C].d = *m_AlphaInputLUT[u32(ac.d.Value())]; - if (cc.bias != 3) + if (cc.bias != TevBias::Compare) DrawColorRegular(cc, inputs); else DrawColorCompare(cc, inputs); if (cc.clamp) { - Reg[cc.dest][RED_C] = Clamp255(Reg[cc.dest][RED_C]); - Reg[cc.dest][GRN_C] = Clamp255(Reg[cc.dest][GRN_C]); - Reg[cc.dest][BLU_C] = Clamp255(Reg[cc.dest][BLU_C]); + Reg[u32(cc.dest.Value())][RED_C] = Clamp255(Reg[u32(cc.dest.Value())][RED_C]); + Reg[u32(cc.dest.Value())][GRN_C] = Clamp255(Reg[u32(cc.dest.Value())][GRN_C]); + Reg[u32(cc.dest.Value())][BLU_C] = Clamp255(Reg[u32(cc.dest.Value())][BLU_C]); } else { - Reg[cc.dest][RED_C] = Clamp1024(Reg[cc.dest][RED_C]); - Reg[cc.dest][GRN_C] = Clamp1024(Reg[cc.dest][GRN_C]); - Reg[cc.dest][BLU_C] = Clamp1024(Reg[cc.dest][BLU_C]); + Reg[u32(cc.dest.Value())][RED_C] = Clamp1024(Reg[u32(cc.dest.Value())][RED_C]); + Reg[u32(cc.dest.Value())][GRN_C] = Clamp1024(Reg[u32(cc.dest.Value())][GRN_C]); + Reg[u32(cc.dest.Value())][BLU_C] = Clamp1024(Reg[u32(cc.dest.Value())][BLU_C]); } - if (ac.bias != 3) + if (ac.bias != TevBias::Compare) DrawAlphaRegular(ac, inputs); else DrawAlphaCompare(ac, inputs); if (ac.clamp) - Reg[ac.dest][ALP_C] = Clamp255(Reg[ac.dest][ALP_C]); + Reg[u32(ac.dest.Value())][ALP_C] = Clamp255(Reg[u32(ac.dest.Value())][ALP_C]); else - Reg[ac.dest][ALP_C] = Clamp1024(Reg[ac.dest][ALP_C]); + Reg[u32(ac.dest.Value())][ALP_C] = Clamp1024(Reg[u32(ac.dest.Value())][ALP_C]); #if ALLOW_TEV_DUMPS if (g_ActiveConfig.bDumpTevStages) @@ -712,8 +685,8 @@ void Tev::Draw() // convert to 8 bits per component // the results of the last tev stage are put onto the screen, // regardless of the used destination register - TODO: Verify! - const u32 color_index = bpmem.combiners[bpmem.genMode.numtevstages].colorC.dest; - const u32 alpha_index = bpmem.combiners[bpmem.genMode.numtevstages].alphaC.dest; + const u32 color_index = u32(bpmem.combiners[bpmem.genMode.numtevstages].colorC.dest.Value()); + const u32 alpha_index = u32(bpmem.combiners[bpmem.genMode.numtevstages].alphaC.dest.Value()); u8 output[4] = {(u8)Reg[alpha_index][ALP_C], (u8)Reg[color_index][BLU_C], (u8)Reg[color_index][GRN_C], (u8)Reg[color_index][RED_C]}; @@ -721,34 +694,36 @@ void Tev::Draw() return; // z texture - if (bpmem.ztex2.op) + if (bpmem.ztex2.op != ZTexOp::Disabled) { u32 ztex = bpmem.ztex1.bias; switch (bpmem.ztex2.type) { - case 0: // 8 bit + case ZTexFormat::U8: ztex += TexColor[ALP_C]; break; - case 1: // 16 bit + case ZTexFormat::U16: ztex += TexColor[ALP_C] << 8 | TexColor[RED_C]; break; - case 2: // 24 bit + case ZTexFormat::U24: ztex += TexColor[RED_C] << 16 | TexColor[GRN_C] << 8 | TexColor[BLU_C]; break; + default: + PanicAlertFmt("Invalid ztex format {}", bpmem.ztex2.type); } - if (bpmem.ztex2.op == ZTEXTURE_ADD) + if (bpmem.ztex2.op == ZTexOp::Add) ztex += Position[2]; Position[2] = ztex & 0x00ffffff; } // fog - if (bpmem.fog.c_proj_fsel.fsel) + if (bpmem.fog.c_proj_fsel.fsel != FogType::Off) { float ze; - if (bpmem.fog.c_proj_fsel.proj == 0) + if (bpmem.fog.c_proj_fsel.proj == FogProjection::Perspective) { // perspective // ze = A/(B - (Zs >> B_SHF)) @@ -804,17 +779,17 @@ void Tev::Draw() switch (bpmem.fog.c_proj_fsel.fsel) { - case 4: // exp + case FogType::Exp: fog = 1.0f - pow(2.0f, -8.0f * fog); break; - case 5: // exp2 + case FogType::ExpSq: fog = 1.0f - pow(2.0f, -8.0f * fog * fog); break; - case 6: // backward exp + case FogType::BackwardsExp: fog = 1.0f - fog; fog = pow(2.0f, -8.0f * fog); break; - case 7: // backward exp2 + case FogType::BackwardsExpSq: fog = 1.0f - fog; fog = pow(2.0f, -8.0f * fog * fog); break; diff --git a/Source/Core/VideoBackends/Software/Tev.h b/Source/Core/VideoBackends/Software/Tev.h index 41d880be86..119ab91bd1 100644 --- a/Source/Core/VideoBackends/Software/Tev.h +++ b/Source/Core/VideoBackends/Software/Tev.h @@ -57,7 +57,7 @@ class Tev INDIRECT = 32 }; - void SetRasColor(int colorChan, int swaptable); + void SetRasColor(RasColorChan colorChan, int swaptable); void DrawColorRegular(const TevStageCombiner::ColorCombiner& cc, const InputRegType inputs[4]); void DrawColorCompare(const TevStageCombiner::ColorCombiner& cc, const InputRegType inputs[4]); diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp index ff1dd97b96..5ca84558dd 100644 --- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp +++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp @@ -504,7 +504,7 @@ static void EncodeRGBA6(u8* dst, const u8* src, EFBCopyFormat format, bool yuv) break; default: - PanicAlertFmt("Unknown texture copy format: {:#x}\n", format); + PanicAlertFmt("Unknown texture copy format: {}\n", format); break; } } @@ -743,7 +743,7 @@ static void EncodeRGBA6halfscale(u8* dst, const u8* src, EFBCopyFormat format, b break; default: - PanicAlertFmt("Unknown texture copy format: {:#x}\n", format); + PanicAlertFmt("Unknown texture copy format: {}\n", format); break; } } @@ -960,7 +960,7 @@ static void EncodeRGB8(u8* dst, const u8* src, EFBCopyFormat format, bool yuv) break; default: - PanicAlertFmt("Unknown texture copy format: {:#x}\n", format); + PanicAlertFmt("Unknown texture copy format: {}\n", format); break; } } @@ -1192,7 +1192,7 @@ static void EncodeRGB8halfscale(u8* dst, const u8* src, EFBCopyFormat format, bo break; default: - PanicAlertFmt("Unknown texture copy format: {:#x}\n", format); + PanicAlertFmt("Unknown texture copy format: {}\n", format); break; } } @@ -1300,7 +1300,7 @@ static void EncodeZ24(u8* dst, const u8* src, EFBCopyFormat format) break; default: - PanicAlertFmt("Unknown texture copy format: {:#x}\n", format); + PanicAlertFmt("Unknown texture copy format: {}\n", format); break; } } @@ -1414,7 +1414,7 @@ static void EncodeZ24halfscale(u8* dst, const u8* src, EFBCopyFormat format) break; default: - PanicAlertFmt("Unknown texture copy format: {:#x}\n", format); + PanicAlertFmt("Unknown texture copy format: {}\n", format); break; } } @@ -1431,16 +1431,16 @@ void EncodeEfbCopy(u8* dst, const EFBCopyParams& params, u32 native_width, u32 b { switch (params.efb_format) { - case PEControl::RGBA6_Z24: + case PixelFormat::RGBA6_Z24: EncodeRGBA6halfscale(dst, src, params.copy_format, params.yuv); break; - case PEControl::RGB8_Z24: + case PixelFormat::RGB8_Z24: EncodeRGB8halfscale(dst, src, params.copy_format, params.yuv); break; - case PEControl::RGB565_Z16: + case PixelFormat::RGB565_Z16: EncodeRGB8halfscale(dst, src, params.copy_format, params.yuv); break; - case PEControl::Z24: + case PixelFormat::Z24: EncodeZ24halfscale(dst, src, params.copy_format); break; default: @@ -1451,16 +1451,16 @@ void EncodeEfbCopy(u8* dst, const EFBCopyParams& params, u32 native_width, u32 b { switch (params.efb_format) { - case PEControl::RGBA6_Z24: + case PixelFormat::RGBA6_Z24: EncodeRGBA6(dst, src, params.copy_format, params.yuv); break; - case PEControl::RGB8_Z24: + case PixelFormat::RGB8_Z24: EncodeRGB8(dst, src, params.copy_format, params.yuv); break; - case PEControl::RGB565_Z16: + case PixelFormat::RGB565_Z16: EncodeRGB8(dst, src, params.copy_format, params.yuv); break; - case PEControl::Z24: + case PixelFormat::Z24: EncodeZ24(dst, src, params.copy_format); break; default: diff --git a/Source/Core/VideoBackends/Software/TextureSampler.cpp b/Source/Core/VideoBackends/Software/TextureSampler.cpp index 93ff4ba44e..799db7c49b 100644 --- a/Source/Core/VideoBackends/Software/TextureSampler.cpp +++ b/Source/Core/VideoBackends/Software/TextureSampler.cpp @@ -8,6 +8,7 @@ #include #include "Common/CommonTypes.h" +#include "Common/MsgHandler.h" #include "Core/HW/Memmap.h" #include "VideoCommon/BPMemory.h" @@ -18,27 +19,29 @@ namespace TextureSampler { -static inline void WrapCoord(int* coordp, int wrapMode, int imageSize) +static inline void WrapCoord(int* coordp, WrapMode wrapMode, int imageSize) { int coord = *coordp; switch (wrapMode) { - case 0: // clamp + case WrapMode::Clamp: coord = (coord > imageSize) ? imageSize : (coord < 0) ? 0 : coord; break; - case 1: // wrap + case WrapMode::Repeat: coord = coord % (imageSize + 1); coord = (coord < 0) ? imageSize + coord : coord; break; - case 2: // mirror + case WrapMode::Mirror: { const int sizePlus1 = imageSize + 1; const int div = coord / sizePlus1; coord = coord - (div * sizePlus1); coord = (coord < 0) ? -coord : coord; coord = (div & 1) ? imageSize - coord : coord; + break; } - break; + default: + PanicAlertFmt("Invalid wrap mode: {}", wrapMode); } *coordp = coord; } @@ -74,10 +77,11 @@ void Sample(s32 s, s32 t, s32 lod, bool linear, u8 texmap, u8* sample) { // use mipmap baseMip = lod >> 4; - mipLinear = (lodFract && tm0.min_filter & TexMode0::TEXF_LINEAR); + mipLinear = (lodFract && tm0.mipmap_filter == MipMode::Linear); // if using nearest mip filter and lodFract >= 0.5 round up to next mip - baseMip += (lodFract >> 3) & (tm0.min_filter & TexMode0::TEXF_POINT); + if (tm0.mipmap_filter == MipMode::Point && lodFract >= 8) + baseMip++; } if (mipLinear) @@ -111,12 +115,12 @@ void SampleMip(s32 s, s32 t, s32 mip, bool linear, u8 texmap, u8* sample) const TexMode0& tm0 = texUnit.texMode0[subTexmap]; const TexImage0& ti0 = texUnit.texImage0[subTexmap]; const TexTLUT& texTlut = texUnit.texTlut[subTexmap]; - const TextureFormat texfmt = static_cast(ti0.format); - const TLUTFormat tlutfmt = static_cast(texTlut.tlut_format); + const TextureFormat texfmt = ti0.format; + const TLUTFormat tlutfmt = texTlut.tlut_format; const u8* imageSrc; const u8* imageSrcOdd = nullptr; - if (texUnit.texImage1[subTexmap].image_type) + if (texUnit.texImage1[subTexmap].cache_manually_managed) { imageSrc = &texMem[texUnit.texImage1[subTexmap].tmem_even * TMEM_LINE_SIZE]; if (texfmt == TextureFormat::RGBA8) @@ -188,7 +192,7 @@ void SampleMip(s32 s, s32 t, s32 mip, bool linear, u8 texmap, u8* sample) WrapCoord(&imageSPlus1, tm0.wrap_s, imageWidth); WrapCoord(&imageTPlus1, tm0.wrap_t, imageHeight); - if (!(texfmt == TextureFormat::RGBA8 && texUnit.texImage1[subTexmap].image_type)) + if (!(texfmt == TextureFormat::RGBA8 && texUnit.texImage1[subTexmap].cache_manually_managed)) { TexDecoder_DecodeTexel(sampledTex, imageSrc, imageS, imageT, imageWidth, texfmt, tlut, tlutfmt); @@ -240,7 +244,7 @@ void SampleMip(s32 s, s32 t, s32 mip, bool linear, u8 texmap, u8* sample) WrapCoord(&imageS, tm0.wrap_s, imageWidth); WrapCoord(&imageT, tm0.wrap_t, imageHeight); - if (!(texfmt == TextureFormat::RGBA8 && texUnit.texImage1[subTexmap].image_type)) + if (!(texfmt == TextureFormat::RGBA8 && texUnit.texImage1[subTexmap].cache_manually_managed)) TexDecoder_DecodeTexel(sample, imageSrc, imageS, imageT, imageWidth, texfmt, tlut, tlutfmt); else TexDecoder_DecodeTexelRGBA8FromTmem(sample, imageSrc, imageSrcOdd, imageS, imageT, diff --git a/Source/Core/VideoBackends/Vulkan/VKPipeline.cpp b/Source/Core/VideoBackends/Vulkan/VKPipeline.cpp index b7c656bec9..048f84b9b9 100644 --- a/Source/Core/VideoBackends/Vulkan/VKPipeline.cpp +++ b/Source/Core/VideoBackends/Vulkan/VKPipeline.cpp @@ -52,13 +52,13 @@ GetVulkanRasterizationState(const RasterizationState& state) depth_clamp, // VkBool32 depthClampEnable VK_FALSE, // VkBool32 rasterizerDiscardEnable VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode - cull_modes[state.cullmode], // VkCullModeFlags cullMode - VK_FRONT_FACE_CLOCKWISE, // VkFrontFace frontFace - VK_FALSE, // VkBool32 depthBiasEnable - 0.0f, // float depthBiasConstantFactor - 0.0f, // float depthBiasClamp - 0.0f, // float depthBiasSlopeFactor - 1.0f // float lineWidth + cull_modes[u32(state.cullmode.Value())], // VkCullModeFlags cullMode + VK_FRONT_FACE_CLOCKWISE, // VkFrontFace frontFace + VK_FALSE, // VkBool32 depthBiasEnable + 0.0f, // float depthBiasConstantFactor + 0.0f, // float depthBiasClamp + 0.0f, // float depthBiasSlopeFactor + 1.0f // float lineWidth }; } @@ -85,31 +85,32 @@ static VkPipelineDepthStencilStateCreateInfo GetVulkanDepthStencilState(const De bool inverted_depth = !g_ActiveConfig.backend_info.bSupportsReversedDepthRange; switch (state.func) { - case ZMode::NEVER: + case CompareMode::Never: compare_op = VK_COMPARE_OP_NEVER; break; - case ZMode::LESS: + case CompareMode::Less: compare_op = inverted_depth ? VK_COMPARE_OP_GREATER : VK_COMPARE_OP_LESS; break; - case ZMode::EQUAL: + case CompareMode::Equal: compare_op = VK_COMPARE_OP_EQUAL; break; - case ZMode::LEQUAL: + case CompareMode::LEqual: compare_op = inverted_depth ? VK_COMPARE_OP_GREATER_OR_EQUAL : VK_COMPARE_OP_LESS_OR_EQUAL; break; - case ZMode::GREATER: + case CompareMode::Greater: compare_op = inverted_depth ? VK_COMPARE_OP_LESS : VK_COMPARE_OP_GREATER; break; - case ZMode::NEQUAL: + case CompareMode::NEqual: compare_op = VK_COMPARE_OP_NOT_EQUAL; break; - case ZMode::GEQUAL: + case CompareMode::GEqual: compare_op = inverted_depth ? VK_COMPARE_OP_LESS_OR_EQUAL : VK_COMPARE_OP_GREATER_OR_EQUAL; break; - case ZMode::ALWAYS: + case CompareMode::Always: compare_op = VK_COMPARE_OP_ALWAYS; break; default: + PanicAlertFmt("Invalid compare mode {}", state.func); compare_op = VK_COMPARE_OP_ALWAYS; break; } @@ -150,10 +151,10 @@ static VkPipelineColorBlendAttachmentState GetVulkanAttachmentBlendState(const B VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, VK_BLEND_FACTOR_DST_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA}}; - vk_state.srcColorBlendFactor = src_factors[state.srcfactor]; - vk_state.srcAlphaBlendFactor = src_factors[state.srcfactoralpha]; - vk_state.dstColorBlendFactor = dst_factors[state.dstfactor]; - vk_state.dstAlphaBlendFactor = dst_factors[state.dstfactoralpha]; + vk_state.srcColorBlendFactor = src_factors[u32(state.srcfactor.Value())]; + vk_state.srcAlphaBlendFactor = src_factors[u32(state.srcfactoralpha.Value())]; + vk_state.dstColorBlendFactor = dst_factors[u32(state.dstfactor.Value())]; + vk_state.dstAlphaBlendFactor = dst_factors[u32(state.dstfactoralpha.Value())]; } else { @@ -169,10 +170,10 @@ static VkPipelineColorBlendAttachmentState GetVulkanAttachmentBlendState(const B VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, VK_BLEND_FACTOR_DST_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA}}; - vk_state.srcColorBlendFactor = src_factors[state.srcfactor]; - vk_state.srcAlphaBlendFactor = src_factors[state.srcfactoralpha]; - vk_state.dstColorBlendFactor = dst_factors[state.dstfactor]; - vk_state.dstAlphaBlendFactor = dst_factors[state.dstfactoralpha]; + vk_state.srcColorBlendFactor = src_factors[u32(state.srcfactor.Value())]; + vk_state.srcAlphaBlendFactor = src_factors[u32(state.srcfactoralpha.Value())]; + vk_state.dstColorBlendFactor = dst_factors[u32(state.dstfactor.Value())]; + vk_state.dstAlphaBlendFactor = dst_factors[u32(state.dstfactoralpha.Value())]; } if (state.colorupdate) @@ -211,7 +212,8 @@ GetVulkanColorBlendState(const BlendingState& state, vk_logic_op_enable = VK_FALSE; } - VkLogicOp vk_logic_op = vk_logic_op_enable ? vk_logic_ops[state.logicmode] : VK_LOGIC_OP_CLEAR; + VkLogicOp vk_logic_op = + vk_logic_op_enable ? vk_logic_ops[u32(state.logicmode.Value())] : VK_LOGIC_OP_CLEAR; VkPipelineColorBlendStateCreateInfo vk_state = { VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType diff --git a/Source/Core/VideoBackends/Vulkan/VKRenderer.cpp b/Source/Core/VideoBackends/Vulkan/VKRenderer.cpp index b2f3f45072..489ee8b8df 100644 --- a/Source/Core/VideoBackends/Vulkan/VKRenderer.cpp +++ b/Source/Core/VideoBackends/Vulkan/VKRenderer.cpp @@ -166,9 +166,9 @@ void Renderer::ClearScreen(const MathUtil::Rectangle& rc, bool color_enable // Determine whether the EFB has an alpha channel. If it doesn't, we can clear the alpha // channel to 0xFF. This hopefully allows us to use the fast path in most cases. - if (bpmem.zcontrol.pixel_format == PEControl::RGB565_Z16 || - bpmem.zcontrol.pixel_format == PEControl::RGB8_Z24 || - bpmem.zcontrol.pixel_format == PEControl::Z24) + if (bpmem.zcontrol.pixel_format == PixelFormat::RGB565_Z16 || + bpmem.zcontrol.pixel_format == PixelFormat::RGB8_Z24 || + bpmem.zcontrol.pixel_format == PixelFormat::Z24) { // Force alpha writes, and clear the alpha channel. This is different to the other backends, // where the existing values of the alpha channel are preserved. -- cgit v1.2.3