summaryrefslogtreecommitdiffstats
path: root/src/video_core
diff options
context:
space:
mode:
Diffstat (limited to 'src/video_core')
-rw-r--r--src/video_core/debug_utils/debug_utils.cpp152
-rw-r--r--src/video_core/pica.h58
-rw-r--r--src/video_core/rasterizer.cpp120
-rw-r--r--src/video_core/renderer_opengl/renderer_opengl.cpp4
-rw-r--r--src/video_core/vertex_shader.cpp144
5 files changed, 420 insertions, 58 deletions
diff --git a/src/video_core/debug_utils/debug_utils.cpp b/src/video_core/debug_utils/debug_utils.cpp
index a494465b9..12f0009bd 100644
--- a/src/video_core/debug_utils/debug_utils.cpp
+++ b/src/video_core/debug_utils/debug_utils.cpp
@@ -18,6 +18,7 @@
#include "common/log.h"
#include "common/file_util.h"
+#include "common/math_util.h"
#include "video_core/color.h"
#include "video_core/math.h"
@@ -337,25 +338,31 @@ const Math::Vec4<u8> LookupTexture(const u8* source, int x, int y, const Texture
i = (i ^ (i << 1)) & 0x1515; // ---2 -1-0
i = (i | (i >> 7)) & 0x3F;
- source += coarse_y * info.stride;
- const unsigned int offset = coarse_x * block_height + i;
+ if (info.format != Regs::TextureFormat::ETC1 &&
+ info.format != Regs::TextureFormat::ETC1A4) {
+ // TODO(neobrain): Fix code design to unify vertical block offsets!
+ source += coarse_y * info.stride;
+ }
+ const unsigned int offset = coarse_x * block_height;
+
+ // TODO: Assert that width/height are multiples of block dimensions
switch (info.format) {
case Regs::TextureFormat::RGBA8:
{
- const u8* source_ptr = source + offset * 4;
+ const u8* source_ptr = source + offset * 4 + i * 4;
return { source_ptr[3], source_ptr[2], source_ptr[1], disable_alpha ? (u8)255 : source_ptr[0] };
}
case Regs::TextureFormat::RGB8:
{
- const u8* source_ptr = source + offset * 3;
+ const u8* source_ptr = source + offset * 3 + i * 3;
return { source_ptr[2], source_ptr[1], source_ptr[0], 255 };
}
case Regs::TextureFormat::RGBA5551:
{
- const u16 source_ptr = *(const u16*)(source + offset * 2);
+ const u16 source_ptr = *(const u16*)(source + offset * 2 + i * 2);
u8 r = (source_ptr >> 11) & 0x1F;
u8 g = ((source_ptr) >> 6) & 0x1F;
u8 b = (source_ptr >> 1) & 0x1F;
@@ -366,7 +373,7 @@ const Math::Vec4<u8> LookupTexture(const u8* source, int x, int y, const Texture
case Regs::TextureFormat::RGB565:
{
- const u16 source_ptr = *(const u16*)(source + offset * 2);
+ const u16 source_ptr = *(const u16*)(source + offset * 2 + i * 2);
u8 r = Color::Convert5To8((source_ptr >> 11) & 0x1F);
u8 g = Color::Convert6To8(((source_ptr) >> 5) & 0x3F);
u8 b = Color::Convert5To8((source_ptr) & 0x1F);
@@ -375,7 +382,7 @@ const Math::Vec4<u8> LookupTexture(const u8* source, int x, int y, const Texture
case Regs::TextureFormat::RGBA4:
{
- const u8* source_ptr = source + offset * 2;
+ const u8* source_ptr = source + offset * 2 + i * 2;
u8 r = Color::Convert4To8(source_ptr[1] >> 4);
u8 g = Color::Convert4To8(source_ptr[1] & 0xF);
u8 b = Color::Convert4To8(source_ptr[0] >> 4);
@@ -385,7 +392,7 @@ const Math::Vec4<u8> LookupTexture(const u8* source, int x, int y, const Texture
case Regs::TextureFormat::IA8:
{
- const u8* source_ptr = source + offset * 2;
+ const u8* source_ptr = source + offset * 2 + i * 2;
if (disable_alpha) {
// Show intensity as red, alpha as green
@@ -397,13 +404,13 @@ const Math::Vec4<u8> LookupTexture(const u8* source, int x, int y, const Texture
case Regs::TextureFormat::I8:
{
- const u8* source_ptr = source + offset;
+ const u8* source_ptr = source + offset + i;
return { *source_ptr, *source_ptr, *source_ptr, 255 };
}
case Regs::TextureFormat::A8:
{
- const u8* source_ptr = source + offset;
+ const u8* source_ptr = source + offset + i;
if (disable_alpha) {
return { *source_ptr, *source_ptr, *source_ptr, 255 };
@@ -414,7 +421,7 @@ const Math::Vec4<u8> LookupTexture(const u8* source, int x, int y, const Texture
case Regs::TextureFormat::IA4:
{
- const u8* source_ptr = source + offset;
+ const u8* source_ptr = source + offset + i;
u8 i = Color::Convert4To8(((*source_ptr) & 0xF0) >> 4);
u8 a = Color::Convert4To8((*source_ptr) & 0xF);
@@ -429,7 +436,7 @@ const Math::Vec4<u8> LookupTexture(const u8* source, int x, int y, const Texture
case Regs::TextureFormat::A4:
{
- const u8* source_ptr = source + offset / 2;
+ const u8* source_ptr = source + offset / 2 + i / 2;
u8 a = (coarse_x % 2) ? ((*source_ptr)&0xF) : (((*source_ptr) & 0xF0) >> 4);
a = Color::Convert4To8(a);
@@ -441,6 +448,127 @@ const Math::Vec4<u8> LookupTexture(const u8* source, int x, int y, const Texture
}
}
+ case Regs::TextureFormat::ETC1:
+ case Regs::TextureFormat::ETC1A4:
+ {
+ bool has_alpha = (info.format == Regs::TextureFormat::ETC1A4);
+
+ // ETC1 further subdivides each 8x8 tile into four 4x4 subtiles
+ const int subtile_width = 4;
+ const int subtile_height = 4;
+
+ int subtile_index = ((x / subtile_width) & 1) + 2 * ((y / subtile_height) & 1);
+ unsigned subtile_bytes = has_alpha ? 2 : 1; // TODO: Name...
+
+ const u64* source_ptr = (const u64*)(source
+ + coarse_x * subtile_bytes * 4
+ + coarse_y * subtile_bytes * 4 * (info.width / 8)
+ + subtile_index * subtile_bytes * 8);
+ u64 alpha = 0xFFFFFFFFFFFFFFFF;
+ if (has_alpha) {
+ alpha = *source_ptr;
+ source_ptr++;
+ }
+
+ union ETC1Tile {
+ // Each of these two is a collection of 16 bits (one per lookup value)
+ BitField< 0, 16, u64> table_subindexes;
+ BitField<16, 16, u64> negation_flags;
+
+ unsigned GetTableSubIndex(unsigned index) const {
+ return (table_subindexes >> index) & 1;
+ }
+
+ bool GetNegationFlag(unsigned index) const {
+ return ((negation_flags >> index) & 1) == 1;
+ }
+
+ BitField<32, 1, u64> flip;
+ BitField<33, 1, u64> differential_mode;
+
+ BitField<34, 3, u64> table_index_2;
+ BitField<37, 3, u64> table_index_1;
+
+ union {
+ // delta value + base value
+ BitField<40, 3, s64> db;
+ BitField<43, 5, u64> b;
+
+ BitField<48, 3, s64> dg;
+ BitField<51, 5, u64> g;
+
+ BitField<56, 3, s64> dr;
+ BitField<59, 5, u64> r;
+ } differential;
+
+ union {
+ BitField<40, 4, u64> b2;
+ BitField<44, 4, u64> b1;
+
+ BitField<48, 4, u64> g2;
+ BitField<52, 4, u64> g1;
+
+ BitField<56, 4, u64> r2;
+ BitField<60, 4, u64> r1;
+ } separate;
+
+ const Math::Vec3<u8> GetRGB(int x, int y) const {
+ int texel = 4 * x + y;
+
+ if (flip)
+ std::swap(x, y);
+
+ // Lookup base value
+ Math::Vec3<int> ret;
+ if (differential_mode) {
+ ret.r() = differential.r;
+ ret.g() = differential.g;
+ ret.b() = differential.b;
+ if (x >= 2) {
+ ret.r() += differential.dr;
+ ret.g() += differential.dg;
+ ret.b() += differential.db;
+ }
+ ret.r() = Color::Convert5To8(ret.r());
+ ret.g() = Color::Convert5To8(ret.g());
+ ret.b() = Color::Convert5To8(ret.b());
+ } else {
+ if (x < 2) {
+ ret.r() = Color::Convert4To8(separate.r1);
+ ret.g() = Color::Convert4To8(separate.g1);
+ ret.b() = Color::Convert4To8(separate.b1);
+ } else {
+ ret.r() = Color::Convert4To8(separate.r2);
+ ret.g() = Color::Convert4To8(separate.g2);
+ ret.b() = Color::Convert4To8(separate.b2);
+ }
+ }
+
+ // Add modifier
+ unsigned table_index = (x < 2) ? table_index_2.Value() : table_index_1.Value();
+
+ static const auto etc1_modifier_table = std::array<std::array<u8, 2>, 8>{{
+ { 2, 8 }, { 5, 17 }, { 9, 29 }, { 13, 42 },
+ { 18, 60 }, { 24, 80 }, { 33, 106 }, { 47, 183 }
+ }};
+
+ int modifier = etc1_modifier_table.at(table_index).at(GetTableSubIndex(texel));
+ if (GetNegationFlag(texel))
+ modifier *= -1;
+
+ ret.r() = MathUtil::Clamp(ret.r() + modifier, 0, 255);
+ ret.g() = MathUtil::Clamp(ret.g() + modifier, 0, 255);
+ ret.b() = MathUtil::Clamp(ret.b() + modifier, 0, 255);
+
+ return ret.Cast<u8>();
+ }
+ } const *etc1_tile = reinterpret_cast<const ETC1Tile*>(source_ptr);
+
+ alpha >>= 4 * ((x & 3) * 4 + (y & 3));
+ return Math::MakeVec(etc1_tile->GetRGB(x & 3, y & 3),
+ disable_alpha ? (u8)255 : Color::Convert4To8(alpha & 0xF));
+ }
+
default:
LOG_ERROR(HW_GPU, "Unknown texture format: %x", (u32)info.format);
_dbg_assert_(HW_GPU, 0);
diff --git a/src/video_core/pica.h b/src/video_core/pica.h
index f5771ed84..2506bf78e 100644
--- a/src/video_core/pica.h
+++ b/src/video_core/pica.h
@@ -161,8 +161,8 @@ struct Regs {
IA4 = 9,
A4 = 11,
- // TODO: Support for the other formats is not implemented, yet.
- // Seems like they are luminance formats and compressed textures.
+ ETC1 = 12, // compressed
+ ETC1A4 = 13, // compressed
};
static unsigned NibblesPerPixel(TextureFormat format) {
@@ -310,10 +310,15 @@ struct Regs {
};
struct {
- enum DepthFunc : u32 {
- Always = 1,
- LessThan = 4,
- GreaterThan = 6,
+ enum CompareFunc : u32 {
+ Never = 0,
+ Always = 1,
+ Equal = 2,
+ NotEqual = 3,
+ LessThan = 4,
+ LessThanOrEqual = 5,
+ GreaterThan = 6,
+ GreaterThanOrEqual = 7,
};
union {
@@ -327,11 +332,21 @@ struct Regs {
};
enum BlendFactor : u32 {
- Zero = 0,
- One = 1,
-
- SourceAlpha = 6,
- OneMinusSourceAlpha = 7,
+ Zero = 0,
+ One = 1,
+ SourceColor = 2,
+ OneMinusSourceColor = 3,
+ DestColor = 4,
+ OneMinusDestColor = 5,
+ SourceAlpha = 6,
+ OneMinusSourceAlpha = 7,
+ DestAlpha = 8,
+ OneMinusDestAlpha = 9,
+ ConstantColor = 10,
+ OneMinusConstantColor = 11,
+ ConstantAlpha = 12,
+ OneMinusConstantAlpha = 13,
+ SourceAlphaSaturate = 14
};
BitField< 0, 8, BlendEquation> blend_equation_rgb;
@@ -352,11 +367,28 @@ struct Regs {
BitField<0, 4, Op> op;
} logic_op;
- INSERT_PADDING_WORDS(0x4);
+ union {
+ BitField< 0, 8, u32> r;
+ BitField< 8, 8, u32> g;
+ BitField<16, 8, u32> b;
+ BitField<24, 8, u32> a;
+ } blend_const;
+
+ union {
+ BitField< 0, 1, u32> enable;
+ BitField< 4, 3, CompareFunc> func;
+ BitField< 8, 8, u32> ref;
+ } alpha_test;
+
+ INSERT_PADDING_WORDS(0x2);
union {
BitField< 0, 1, u32> depth_test_enable;
- BitField< 4, 3, DepthFunc> depth_test_func;
+ BitField< 4, 3, CompareFunc> depth_test_func;
+ BitField< 8, 1, u32> red_enable;
+ BitField< 9, 1, u32> green_enable;
+ BitField<10, 1, u32> blue_enable;
+ BitField<11, 1, u32> alpha_enable;
BitField<12, 1, u32> depth_write_enable;
};
diff --git a/src/video_core/rasterizer.cpp b/src/video_core/rasterizer.cpp
index 025d4e484..845f1c4b2 100644
--- a/src/video_core/rasterizer.cpp
+++ b/src/video_core/rasterizer.cpp
@@ -431,6 +431,47 @@ void ProcessTriangle(const VertexShader::OutputVertex& v0,
combiner_output = Math::MakeVec(color_output, alpha_output);
}
+ if (registers.output_merger.alpha_test.enable) {
+ bool pass = false;
+
+ switch (registers.output_merger.alpha_test.func) {
+ case registers.output_merger.Never:
+ pass = false;
+ break;
+
+ case registers.output_merger.Always:
+ pass = true;
+ break;
+
+ case registers.output_merger.Equal:
+ pass = combiner_output.a() == registers.output_merger.alpha_test.ref;
+ break;
+
+ case registers.output_merger.NotEqual:
+ pass = combiner_output.a() != registers.output_merger.alpha_test.ref;
+ break;
+
+ case registers.output_merger.LessThan:
+ pass = combiner_output.a() < registers.output_merger.alpha_test.ref;
+ break;
+
+ case registers.output_merger.LessThanOrEqual:
+ pass = combiner_output.a() <= registers.output_merger.alpha_test.ref;
+ break;
+
+ case registers.output_merger.GreaterThan:
+ pass = combiner_output.a() > registers.output_merger.alpha_test.ref;
+ break;
+
+ case registers.output_merger.GreaterThanOrEqual:
+ pass = combiner_output.a() >= registers.output_merger.alpha_test.ref;
+ break;
+ }
+
+ if (!pass)
+ continue;
+ }
+
// TODO: Does depth indeed only get written even if depth testing is enabled?
if (registers.output_merger.depth_test_enable) {
u16 z = (u16)(-(v0.screenpos[2].ToFloat32() * w0 +
@@ -441,20 +482,36 @@ void ProcessTriangle(const VertexShader::OutputVertex& v0,
bool pass = false;
switch (registers.output_merger.depth_test_func) {
+ case registers.output_merger.Never:
+ pass = false;
+ break;
+
case registers.output_merger.Always:
pass = true;
break;
+ case registers.output_merger.Equal:
+ pass = z == ref_z;
+ break;
+
+ case registers.output_merger.NotEqual:
+ pass = z != ref_z;
+ break;
+
case registers.output_merger.LessThan:
pass = z < ref_z;
break;
+ case registers.output_merger.LessThanOrEqual:
+ pass = z <= ref_z;
+ break;
+
case registers.output_merger.GreaterThan:
pass = z > ref_z;
break;
- default:
- LOG_ERROR(HW_GPU, "Unknown depth test function %x", registers.output_merger.depth_test_func.Value());
+ case registers.output_merger.GreaterThanOrEqual:
+ pass = z >= ref_z;
break;
}
@@ -471,18 +528,48 @@ void ProcessTriangle(const VertexShader::OutputVertex& v0,
auto params = registers.output_merger.alpha_blending;
auto LookupFactorRGB = [&](decltype(params)::BlendFactor factor) -> Math::Vec3<u8> {
- switch(factor) {
+ switch (factor) {
case params.Zero:
return Math::Vec3<u8>(0, 0, 0);
case params.One:
return Math::Vec3<u8>(255, 255, 255);
+ case params.SourceColor:
+ return combiner_output.rgb();
+
+ case params.OneMinusSourceColor:
+ return Math::Vec3<u8>(255 - combiner_output.r(), 255 - combiner_output.g(), 255 - combiner_output.b());
+
+ case params.DestColor:
+ return dest.rgb();
+
+ case params.OneMinusDestColor:
+ return Math::Vec3<u8>(255 - dest.r(), 255 - dest.g(), 255 - dest.b());
+
case params.SourceAlpha:
- return Math::MakeVec(combiner_output.a(), combiner_output.a(), combiner_output.a());
+ return Math::Vec3<u8>(combiner_output.a(), combiner_output.a(), combiner_output.a());
case params.OneMinusSourceAlpha:
- return Math::Vec3<u8>(255-combiner_output.a(), 255-combiner_output.a(), 255-combiner_output.a());
+ return Math::Vec3<u8>(255 - combiner_output.a(), 255 - combiner_output.a(), 255 - combiner_output.a());
+
+ case params.DestAlpha:
+ return Math::Vec3<u8>(dest.a(), dest.a(), dest.a());
+
+ case params.OneMinusDestAlpha:
+ return Math::Vec3<u8>(255 - dest.a(), 255 - dest.a(), 255 - dest.a());
+
+ case params.ConstantColor:
+ return Math::Vec3<u8>(registers.output_merger.blend_const.r, registers.output_merger.blend_const.g, registers.output_merger.blend_const.b);
+
+ case params.OneMinusConstantColor:
+ return Math::Vec3<u8>(255 - registers.output_merger.blend_const.r, 255 - registers.output_merger.blend_const.g, 255 - registers.output_merger.blend_const.b);
+
+ case params.ConstantAlpha:
+ return Math::Vec3<u8>(registers.output_merger.blend_const.a, registers.output_merger.blend_const.a, registers.output_merger.blend_const.a);
+
+ case params.OneMinusConstantAlpha:
+ return Math::Vec3<u8>(255 - registers.output_merger.blend_const.a, 255 - registers.output_merger.blend_const.a, 255 - registers.output_merger.blend_const.a);
default:
LOG_CRITICAL(HW_GPU, "Unknown color blend factor %x", factor);
@@ -492,7 +579,7 @@ void ProcessTriangle(const VertexShader::OutputVertex& v0,
};
auto LookupFactorA = [&](decltype(params)::BlendFactor factor) -> u8 {
- switch(factor) {
+ switch (factor) {
case params.Zero:
return 0;
@@ -505,6 +592,18 @@ void ProcessTriangle(const VertexShader::OutputVertex& v0,
case params.OneMinusSourceAlpha:
return 255 - combiner_output.a();
+ case params.DestAlpha:
+ return dest.a();
+
+ case params.OneMinusDestAlpha:
+ return 255 - dest.a();
+
+ case params.ConstantAlpha:
+ return registers.output_merger.blend_const.a;
+
+ case params.OneMinusConstantAlpha:
+ return 255 - registers.output_merger.blend_const.a;
+
default:
LOG_CRITICAL(HW_GPU, "Unknown alpha blend factor %x", factor);
exit(0);
@@ -537,7 +636,14 @@ void ProcessTriangle(const VertexShader::OutputVertex& v0,
exit(0);
}
- DrawPixel(x >> 4, y >> 4, combiner_output);
+ const Math::Vec4<u8> result = {
+ registers.output_merger.red_enable ? combiner_output.r() : dest.r(),
+ registers.output_merger.green_enable ? combiner_output.g() : dest.g(),
+ registers.output_merger.blue_enable ? combiner_output.b() : dest.b(),
+ registers.output_merger.alpha_enable ? combiner_output.a() : dest.a()
+ };
+
+ DrawPixel(x >> 4, y >> 4, result);
}
}
}
diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp
index 29d220e8d..aa47bd616 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.cpp
+++ b/src/video_core/renderer_opengl/renderer_opengl.cpp
@@ -88,10 +88,8 @@ void RendererOpenGL::SwapBuffers() {
void RendererOpenGL::LoadFBToActiveGLTexture(const GPU::Regs::FramebufferConfig& framebuffer,
const TextureInfo& texture) {
- // TODO: Why are active_fb and the valid framebuffer flipped compared to 3dbrew documentation
- // and GSP definitions?
const VAddr framebuffer_vaddr = Memory::PhysicalToVirtualAddress(
- framebuffer.active_fb == 0 ? framebuffer.address_left2 : framebuffer.address_left1);
+ framebuffer.active_fb == 0 ? framebuffer.address_left1 : framebuffer.address_left2);
LOG_TRACE(Render_OpenGL, "0x%08x bytes from 0x%08x(%dx%d), fmt %x",
framebuffer.stride * framebuffer.height,
diff --git a/src/video_core/vertex_shader.cpp b/src/video_core/vertex_shader.cpp
index ff825e2e1..48977380e 100644
--- a/src/video_core/vertex_shader.cpp
+++ b/src/video_core/vertex_shader.cpp
@@ -348,13 +348,114 @@ static void ProcessShaderCode(VertexShaderState& state) {
break;
}
+
+ case Instruction::OpCodeType::MultiplyAdd:
+ {
+ if (instr.opcode.EffectiveOpCode() == Instruction::OpCode::MAD) {
+ const SwizzlePattern& swizzle = *(SwizzlePattern*)&swizzle_data[instr.mad.operand_desc_id];
+
+ const float24* src1_ = LookupSourceRegister(instr.mad.src1);
+ const float24* src2_ = LookupSourceRegister(instr.mad.src2);
+ const float24* src3_ = LookupSourceRegister(instr.mad.src3);
+
+ const bool negate_src1 = ((bool)swizzle.negate_src1 != false);
+ const bool negate_src2 = ((bool)swizzle.negate_src2 != false);
+ const bool negate_src3 = ((bool)swizzle.negate_src3 != false);
+
+ float24 src1[4] = {
+ src1_[(int)swizzle.GetSelectorSrc1(0)],
+ src1_[(int)swizzle.GetSelectorSrc1(1)],
+ src1_[(int)swizzle.GetSelectorSrc1(2)],
+ src1_[(int)swizzle.GetSelectorSrc1(3)],
+ };
+ if (negate_src1) {
+ src1[0] = src1[0] * float24::FromFloat32(-1);
+ src1[1] = src1[1] * float24::FromFloat32(-1);
+ src1[2] = src1[2] * float24::FromFloat32(-1);
+ src1[3] = src1[3] * float24::FromFloat32(-1);
+ }
+ float24 src2[4] = {
+ src2_[(int)swizzle.GetSelectorSrc2(0)],
+ src2_[(int)swizzle.GetSelectorSrc2(1)],
+ src2_[(int)swizzle.GetSelectorSrc2(2)],
+ src2_[(int)swizzle.GetSelectorSrc2(3)],
+ };
+ if (negate_src2) {
+ src2[0] = src2[0] * float24::FromFloat32(-1);
+ src2[1] = src2[1] * float24::FromFloat32(-1);
+ src2[2] = src2[2] * float24::FromFloat32(-1);
+ src2[3] = src2[3] * float24::FromFloat32(-1);
+ }
+ float24 src3[4] = {
+ src3_[(int)swizzle.GetSelectorSrc3(0)],
+ src3_[(int)swizzle.GetSelectorSrc3(1)],
+ src3_[(int)swizzle.GetSelectorSrc3(2)],
+ src3_[(int)swizzle.GetSelectorSrc3(3)],
+ };
+ if (negate_src3) {
+ src3[0] = src3[0] * float24::FromFloat32(-1);
+ src3[1] = src3[1] * float24::FromFloat32(-1);
+ src3[2] = src3[2] * float24::FromFloat32(-1);
+ src3[3] = src3[3] * float24::FromFloat32(-1);
+ }
+
+ float24* dest = (instr.mad.dest < 0x08) ? state.output_register_table[4*instr.mad.dest.GetIndex()]
+ : (instr.mad.dest < 0x10) ? dummy_vec4_float24
+ : (instr.mad.dest < 0x20) ? &state.temporary_registers[instr.mad.dest.GetIndex()][0]
+ : dummy_vec4_float24;
+
+ for (int i = 0; i < 4; ++i) {
+ if (!swizzle.DestComponentEnabled(i))
+ continue;
+
+ dest[i] = src1[i] * src2[i] + src3[i];
+ }
+ } else {
+ LOG_ERROR(HW_GPU, "Unhandled multiply-add instruction: 0x%02x (%s): 0x%08x",
+ (int)instr.opcode.Value(), instr.opcode.GetInfo().name, instr.hex);
+ }
+ break;
+ }
+
default:
+ {
+ static auto evaluate_condition = [](const VertexShaderState& state, bool refx, bool refy, Instruction::FlowControlType flow_control) {
+ bool results[2] = { refx == state.conditional_code[0],
+ refy == state.conditional_code[1] };
+
+ switch (flow_control.op) {
+ case flow_control.Or:
+ return results[0] || results[1];
+
+ case flow_control.And:
+ return results[0] && results[1];
+
+ case flow_control.JustX:
+ return results[0];
+
+ case flow_control.JustY:
+ return results[1];
+ }
+ };
+
// Handle each instruction on its own
switch (instr.opcode) {
case Instruction::OpCode::END:
exit_loop = true;
break;
+ case Instruction::OpCode::JMPC:
+ if (evaluate_condition(state, instr.flow_control.refx, instr.flow_control.refy, instr.flow_control)) {
+ state.program_counter = &shader_memory[instr.flow_control.dest_offset] - 1;
+ }
+ break;
+
+ case Instruction::OpCode::JMPU:
+ if (shader_uniforms.b[instr.flow_control.bool_uniform_id]) {
+ state.program_counter = &shader_memory[instr.flow_control.dest_offset] - 1;
+ }
+ break;
+
case Instruction::OpCode::CALL:
call(state,
instr.flow_control.dest_offset,
@@ -362,6 +463,24 @@ static void ProcessShaderCode(VertexShaderState& state) {
binary_offset + 1);
break;
+ case Instruction::OpCode::CALLU:
+ if (shader_uniforms.b[instr.flow_control.bool_uniform_id]) {
+ call(state,
+ instr.flow_control.dest_offset,
+ instr.flow_control.num_instructions,
+ binary_offset + 1);
+ }
+ break;
+
+ case Instruction::OpCode::CALLC:
+ if (evaluate_condition(state, instr.flow_control.refx, instr.flow_control.refy, instr.flow_control)) {
+ call(state,
+ instr.flow_control.dest_offset,
+ instr.flow_control.num_instructions,
+ binary_offset + 1);
+ }
+ break;
+
case Instruction::OpCode::NOP:
break;
@@ -384,29 +503,7 @@ static void ProcessShaderCode(VertexShaderState& state) {
{
// TODO: Do we need to consider swizzlers here?
- auto flow_control = instr.flow_control;
- bool results[3] = { (bool)flow_control.refx == state.conditional_code[0],
- (bool)flow_control.refy == state.conditional_code[1] };
-
- switch (flow_control.op) {
- case flow_control.Or:
- results[2] = results[0] || results[1];
- break;
-
- case flow_control.And:
- results[2] = results[0] && results[1];
- break;
-
- case flow_control.JustX:
- results[2] = results[0];
- break;
-
- case flow_control.JustY:
- results[2] = results[1];
- break;
- }
-
- if (results[2]) {
+ if (evaluate_condition(state, instr.flow_control.refx, instr.flow_control.refy, instr.flow_control)) {
call(state,
binary_offset + 1,
instr.flow_control.dest_offset - binary_offset - 1,
@@ -429,6 +526,7 @@ static void ProcessShaderCode(VertexShaderState& state) {
break;
}
+ }
++state.program_counter;
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-21 15:30:01 +0200