emu-mirror/citra-nightly
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor software renderer (#6621)

Browse Source
This commit is contained in:
GPUCode 2023-06-24 01:59:18 +03:00 committed by GitHub
parent 7198243319
commit 9b82de6b24
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
39 changed files with 1815 additions and 1796 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/citra/citra.cpp
View File

@ -344,11 +344,14 @@ int main(int argc, char** argv) {
return -1;
}
auto& system = Core::System::GetInstance();
auto& movie = Core::Movie::GetInstance();
if (!movie_record.empty()) {
Core::Movie::GetInstance().PrepareForRecording();
movie.PrepareForRecording();
}
if (!movie_play.empty()) {
Core::Movie::GetInstance().PrepareForPlayback(movie_play);
movie.PrepareForPlayback(movie_play);
}
// Apply the command line arguments
@ -361,13 +364,13 @@ int main(int argc, char** argv) {
EmuWindow_SDL2::InitializeSDL2();
const auto create_emu_window = [](bool fullscreen,
const auto create_emu_window = [&](bool fullscreen,
bool is_secondary) -> std::unique_ptr<EmuWindow_SDL2> {
switch (Settings::values.graphics_api.GetValue()) {
case Settings::GraphicsAPI::OpenGL:
return std::make_unique<EmuWindow_SDL2_GL>(fullscreen, is_secondary);
case Settings::GraphicsAPI::Software:
return std::make_unique<EmuWindow_SDL2_SW>(fullscreen, is_secondary);
return std::make_unique<EmuWindow_SDL2_SW>(system, fullscreen, is_secondary);
}
LOG_ERROR(Frontend, "Invalid Graphics API, using OpenGL");
return std::make_unique<EmuWindow_SDL2_GL>(fullscreen, is_secondary);
@ -385,7 +388,6 @@ int main(int argc, char** argv) {
Common::g_scm_desc);
Settings::LogSettings();
Core::System& system = Core::System::GetInstance();
const Core::System::ResultStatus load_result{
system.Load(*emu_window, filepath, secondary_window.get())};
@ -437,21 +439,21 @@ int main(int argc, char** argv) {
}
if (!movie_play.empty()) {
auto metadata = Core::Movie::GetInstance().GetMovieMetadata(movie_play);
auto metadata = movie.GetMovieMetadata(movie_play);
LOG_INFO(Movie, "Author: {}", metadata.author);
LOG_INFO(Movie, "Rerecord count: {}", metadata.rerecord_count);
LOG_INFO(Movie, "Input count: {}", metadata.input_count);
Core::Movie::GetInstance().StartPlayback(movie_play);
movie.StartPlayback(movie_play);
}
if (!movie_record.empty()) {
Core::Movie::GetInstance().StartRecording(movie_record, movie_record_author);
movie.StartRecording(movie_record, movie_record_author);
}
if (!dump_video.empty() && DynamicLibrary::FFmpeg::LoadFFmpeg()) {
Layout::FramebufferLayout layout{Layout::FrameLayoutFromResolutionScale(
VideoCore::g_renderer->GetResolutionScaleFactor())};
const auto layout{
Layout::FrameLayoutFromResolutionScale(system.Renderer().GetResolutionScaleFactor())};
auto dumper = std::make_shared<VideoDumper::FFmpegBackend>();
if (dumper->StartDumping(dump_video, layout)) {
Core::System::GetInstance().RegisterVideoDumper(dumper);
system.RegisterVideoDumper(dumper);
}
}
@ -494,7 +496,7 @@ int main(int argc, char** argv) {
main_render_thread.join();
secondary_render_thread.join();
Core::Movie::GetInstance().Shutdown();
movie.Shutdown();
auto video_dumper = system.GetVideoDumper();
if (video_dumper && video_dumper->IsDumping()) {

64
src/citra/emu_window/emu_window_sdl2_sw.cpp
View File

@ -9,18 +9,16 @@
#include <SDL.h>
#include <SDL_rect.h>
#include "citra/emu_window/emu_window_sdl2_sw.h"
#include "common/color.h"
#include "common/scm_rev.h"
#include "common/settings.h"
#include "core/core.h"
#include "core/frontend/emu_window.h"
#include "core/hw/gpu.h"
#include "core/memory.h"
#include "video_core/video_core.h"
#include "video_core/renderer_software/renderer_software.h"
class DummyContext : public Frontend::GraphicsContext {};
EmuWindow_SDL2_SW::EmuWindow_SDL2_SW(bool fullscreen, bool is_secondary)
: EmuWindow_SDL2{is_secondary} {
EmuWindow_SDL2_SW::EmuWindow_SDL2_SW(Core::System& system_, bool fullscreen, bool is_secondary)
: EmuWindow_SDL2{is_secondary}, system{system_} {
std::string window_title = fmt::format("Citra {} | {}-{}", Common::g_build_fullname,
Common::g_scm_branch, Common::g_scm_desc);
render_window =
@ -67,6 +65,8 @@ void EmuWindow_SDL2_SW::Present() {
const auto layout{Layout::DefaultFrameLayout(
Core::kScreenTopWidth, Core::kScreenTopHeight + Core::kScreenBottomHeight, false, false)};
using VideoCore::ScreenId;
while (IsOpen()) {
SDL_SetRenderDrawColor(renderer,
static_cast<Uint8>(Settings::values.bg_red.GetValue() * 255),
@ -74,62 +74,34 @@ void EmuWindow_SDL2_SW::Present() {
static_cast<Uint8>(Settings::values.bg_blue.GetValue() * 255), 0xFF);
SDL_RenderClear(renderer);
const auto draw_screen = [&](int fb_id) {
const auto dst_rect = fb_id == 0 ? layout.top_screen : layout.bottom_screen;
const auto draw_screen = [&](ScreenId screen_id) {
const auto dst_rect =
screen_id == ScreenId::TopLeft ? layout.top_screen : layout.bottom_screen;
SDL_Rect sdl_rect{static_cast<int>(dst_rect.left), static_cast<int>(dst_rect.top),
static_cast<int>(dst_rect.GetWidth()),
static_cast<int>(dst_rect.GetHeight())};
SDL_Surface* screen = LoadFramebuffer(fb_id);
SDL_Surface* screen = LoadFramebuffer(screen_id);
SDL_BlitSurface(screen, nullptr, window_surface, &sdl_rect);
SDL_FreeSurface(screen);
};
draw_screen(0);
draw_screen(1);
draw_screen(ScreenId::TopLeft);
draw_screen(ScreenId::Bottom);
SDL_RenderPresent(renderer);
SDL_UpdateWindowSurface(render_window);
}
}
SDL_Surface* EmuWindow_SDL2_SW::LoadFramebuffer(int fb_id) {
const auto& framebuffer = GPU::g_regs.framebuffer_config[fb_id];
const PAddr framebuffer_addr =
framebuffer.active_fb == 0 ? framebuffer.address_left1 : framebuffer.address_left2;
Memory::RasterizerFlushRegion(framebuffer_addr, framebuffer.stride * framebuffer.height);
const u8* framebuffer_data = VideoCore::g_memory->GetPhysicalPointer(framebuffer_addr);
const int width = framebuffer.height;
const int height = framebuffer.width;
const int bpp = GPU::Regs::BytesPerPixel(framebuffer.color_format);
SDL_Surface* EmuWindow_SDL2_SW::LoadFramebuffer(VideoCore::ScreenId screen_id) {
const auto& renderer = static_cast<SwRenderer::RendererSoftware&>(system.Renderer());
const auto& info = renderer.Screen(screen_id);
const int width = static_cast<int>(info.width);
const int height = static_cast<int>(info.height);
SDL_Surface* surface =
SDL_CreateRGBSurfaceWithFormat(0, width, height, 0, SDL_PIXELFORMAT_ABGR8888);
SDL_LockSurface(surface);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
const u8* pixel = framebuffer_data + (x * height + height - y) * bpp;
const Common::Vec4 color = [&] {
switch (framebuffer.color_format) {
case GPU::Regs::PixelFormat::RGBA8:
return Common::Color::DecodeRGBA8(pixel);
case GPU::Regs::PixelFormat::RGB8:
return Common::Color::DecodeRGB8(pixel);
case GPU::Regs::PixelFormat::RGB565:
return Common::Color::DecodeRGB565(pixel);
case GPU::Regs::PixelFormat::RGB5A1:
return Common::Color::DecodeRGB5A1(pixel);
case GPU::Regs::PixelFormat::RGBA4:
return Common::Color::DecodeRGBA4(pixel);
}
UNREACHABLE();
}();
u8* dst_pixel = reinterpret_cast<u8*>(surface->pixels) + (y * width + x) * 4;
std::memcpy(dst_pixel, color.AsArray(), sizeof(color));
}
}
std::memcpy(surface->pixels, info.pixels.data(), info.pixels.size());
SDL_UnlockSurface(surface);
return surface;
}

15
src/citra/emu_window/emu_window_sdl2_sw.h
View File

@ -10,9 +10,17 @@
struct SDL_Renderer;
struct SDL_Surface;
namespace VideoCore {
enum class ScreenId : u32;
}
namespace Core {
class System;
}
class EmuWindow_SDL2_SW : public EmuWindow_SDL2 {
public:
explicit EmuWindow_SDL2_SW(bool fullscreen, bool is_secondary);
explicit EmuWindow_SDL2_SW(Core::System& system, bool fullscreen, bool is_secondary);
~EmuWindow_SDL2_SW();
void Present() override;
@ -22,7 +30,10 @@ public:
private:
/// Loads a framebuffer to an SDL surface
SDL_Surface* LoadFramebuffer(int fb_id);
SDL_Surface* LoadFramebuffer(VideoCore::ScreenId screen_id);
/// The system class.
Core::System& system;
/// The SDL software renderer
SDL_Renderer* renderer;

74
src/citra_qt/bootmanager.cpp
View File

@ -25,6 +25,7 @@
#include "input_common/motion_emu.h"
#include "video_core/custom_textures/custom_tex_manager.h"
#include "video_core/renderer_base.h"
#include "video_core/renderer_software/renderer_software.h"
#include "video_core/video_core.h"
#ifdef HAS_OPENGL
@ -288,7 +289,8 @@ private:
#endif
struct SoftwareRenderWidget : public RenderWidget {
explicit SoftwareRenderWidget(GRenderWindow* parent) : RenderWidget(parent) {}
explicit SoftwareRenderWidget(GRenderWindow* parent, Core::System& system_)
: RenderWidget(parent), system(system_) {}
void Present() override {
if (!isVisible()) {
@ -298,61 +300,40 @@ struct SoftwareRenderWidget : public RenderWidget {
return;
}
using VideoCore::ScreenId;
const auto layout{Layout::DefaultFrameLayout(width(), height(), false, false)};
QPainter painter(this);
const auto draw_screen = [&](int fb_id) {
const auto rect = fb_id == 0 ? layout.top_screen : layout.bottom_screen;
const QImage screen = LoadFramebuffer(fb_id).scaled(rect.GetWidth(), rect.GetHeight());
const auto draw_screen = [&](ScreenId screen_id) {
const auto rect =
screen_id == ScreenId::TopLeft ? layout.top_screen : layout.bottom_screen;
const QImage screen =
LoadFramebuffer(screen_id).scaled(rect.GetWidth(), rect.GetHeight());
painter.drawImage(rect.left, rect.top, screen);
};
painter.fillRect(rect(), qRgb(Settings::values.bg_red.GetValue() * 255,
Settings::values.bg_green.GetValue() * 255,
Settings::values.bg_blue.GetValue() * 255));
draw_screen(0);
draw_screen(1);
draw_screen(ScreenId::TopLeft);
draw_screen(ScreenId::Bottom);
painter.end();
}
QImage LoadFramebuffer(int fb_id) {
const auto& framebuffer = GPU::g_regs.framebuffer_config[fb_id];
const PAddr framebuffer_addr =
framebuffer.active_fb == 0 ? framebuffer.address_left1 : framebuffer.address_left2;
Memory::RasterizerFlushRegion(framebuffer_addr, framebuffer.stride * framebuffer.height);
const u8* framebuffer_data = VideoCore::g_memory->GetPhysicalPointer(framebuffer_addr);
const int width = framebuffer.height;
const int height = framebuffer.width;
const int bpp = GPU::Regs::BytesPerPixel(framebuffer.color_format);
QImage image{width, height, QImage::Format_RGBA8888};
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
const u8* pixel = framebuffer_data + (x * height + height - y) * bpp;
const Common::Vec4 color = [&] {
switch (framebuffer.color_format) {
case GPU::Regs::PixelFormat::RGBA8:
return Common::Color::DecodeRGBA8(pixel);
case GPU::Regs::PixelFormat::RGB8:
return Common::Color::DecodeRGB8(pixel);
case GPU::Regs::PixelFormat::RGB565:
return Common::Color::DecodeRGB565(pixel);
case GPU::Regs::PixelFormat::RGB5A1:
return Common::Color::DecodeRGB5A1(pixel);
case GPU::Regs::PixelFormat::RGBA4:
return Common::Color::DecodeRGBA4(pixel);
}
UNREACHABLE();
}();
image.setPixel(x, y, qRgba(color.r(), color.g(), color.b(), color.a()));
}
}
QImage LoadFramebuffer(VideoCore::ScreenId screen_id) {
const auto& renderer = static_cast<SwRenderer::RendererSoftware&>(system.Renderer());
const auto& info = renderer.Screen(screen_id);
const int width = static_cast<int>(info.width);
const int height = static_cast<int>(info.height);
QImage image{height, width, QImage::Format_RGBA8888};
std::memcpy(image.bits(), info.pixels.data(), info.pixels.size());
return image;
}
private:
Core::System& system;
};
static Frontend::WindowSystemType GetWindowSystemType() {
@ -401,8 +382,9 @@ static Frontend::EmuWindow::WindowSystemInfo GetWindowSystemInfo(QWindow* window
std::unique_ptr<Frontend::GraphicsContext> GRenderWindow::main_context;
GRenderWindow::GRenderWindow(QWidget* parent_, EmuThread* emu_thread, bool is_secondary_)
: QWidget(parent_), EmuWindow(is_secondary_), emu_thread(emu_thread) {
GRenderWindow::GRenderWindow(QWidget* parent_, EmuThread* emu_thread_, Core::System& system_,
bool is_secondary_)
: QWidget(parent_), EmuWindow(is_secondary_), emu_thread(emu_thread_), system{system_} {
setWindowTitle(QStringLiteral("Citra %1 | %2-%3")
.arg(QString::fromUtf8(Common::g_build_name),
@ -652,12 +634,12 @@ void GRenderWindow::ReleaseRenderTarget() {
void GRenderWindow::CaptureScreenshot(u32 res_scale, const QString& screenshot_path) {
if (res_scale == 0) {
res_scale = VideoCore::g_renderer->GetResolutionScaleFactor();
res_scale = system.Renderer().GetResolutionScaleFactor();
}
const auto layout{Layout::FrameLayoutFromResolutionScale(res_scale, is_secondary)};
screenshot_image = QImage(QSize(layout.width, layout.height), QImage::Format_RGB32);
VideoCore::g_renderer->RequestScreenshot(
system.Renderer().RequestScreenshot(
screenshot_image.bits(),
[this, screenshot_path] {
const std::string std_screenshot_path = screenshot_path.toStdString();
@ -708,7 +690,7 @@ bool GRenderWindow::InitializeOpenGL() {
}
void GRenderWindow::InitializeSoftware() {
child_widget = new SoftwareRenderWidget(this);
child_widget = new SoftwareRenderWidget(this, system);
main_context = std::make_unique<DummyContext>();
}

3
src/citra_qt/bootmanager.h
View File

@ -112,7 +112,7 @@ class GRenderWindow : public QWidget, public Frontend::EmuWindow {
Q_OBJECT
public:
GRenderWindow(QWidget* parent, EmuThread* emu_thread, bool is_secondary);
GRenderWindow(QWidget* parent, EmuThread* emu_thread, Core::System& system, bool is_secondary);
~GRenderWindow() override;
// EmuWindow implementation.
@ -188,6 +188,7 @@ private:
QWidget* child_widget = nullptr;
EmuThread* emu_thread;
Core::System& system;
/// Main context that will be shared with all other contexts that are requested.
/// If this is used in a shared context setting, then this should not be used directly, but

4
src/citra_qt/debugger/graphics/graphics_vertex_shader.cpp
View File

@ -550,8 +550,8 @@ void GraphicsVertexShaderWidget::OnResumed() {
}
void GraphicsVertexShaderWidget::OnInputAttributeChanged(int index) {
float value = input_data[index]->text().toFloat();
input_vertex.attr[index / 4][index % 4] = Pica::float24::FromFloat32(value);
const f32 value = input_data[index]->text().toFloat();
input_vertex.attr[index / 4][index % 4] = Pica::f24::FromFloat32(value);
// Re-execute shader with updated value
Reload();
}

4
src/citra_qt/main.cpp
View File

@ -297,8 +297,8 @@ void GMainWindow::InitializeWidgets() {
#ifdef CITRA_ENABLE_COMPATIBILITY_REPORTING
ui->action_Report_Compatibility->setVisible(true);
#endif
render_window = new GRenderWindow(this, emu_thread.get(), false);
secondary_window = new GRenderWindow(this, emu_thread.get(), true);
render_window = new GRenderWindow(this, emu_thread.get(), system, false);
secondary_window = new GRenderWindow(this, emu_thread.get(), system, true);
render_window->hide();
secondary_window->hide();
secondary_window->setParent(nullptr);

9
src/tests/video_core/shader/shader_jit_x64_compiler.cpp
View File

@ -14,7 +14,6 @@
#include "video_core/shader/shader_interpreter.h"
#include "video_core/shader/shader_jit_x64_compiler.h"
using float24 = Pica::float24;
using JitShader = Pica::Shader::JitShader;
using ShaderInterpreter = Pica::Shader::InterpreterEngine;
@ -51,14 +50,14 @@ public:
}
void RunJit(Pica::Shader::UnitState& shader_unit, float input) {
shader_unit.registers.input[0].x = float24::FromFloat32(input);
shader_unit.registers.temporary[0].x = float24::FromFloat32(0);
shader_unit.registers.input[0].x = Pica::f24::FromFloat32(input);
shader_unit.registers.temporary[0].x = Pica::f24::Zero();
shader_jit.Run(*shader_setup, shader_unit, 0);
}
void RunInterpreter(Pica::Shader::UnitState& shader_unit, float input) {
shader_unit.registers.input[0].x = float24::FromFloat32(input);
shader_unit.registers.temporary[0].x = float24::FromFloat32(0);
shader_unit.registers.input[0].x = Pica::f24::FromFloat32(input);
shader_unit.registers.temporary[0].x = Pica::f24::Zero();
shader_interpreter.Run(*shader_setup, shader_unit);
}

2
src/video_core/CMakeLists.txt
View File

@ -83,8 +83,6 @@ add_library(video_core STATIC
renderer_opengl/post_processing_opengl.h
renderer_opengl/renderer_opengl.cpp
renderer_opengl/renderer_opengl.h
renderer_software/rasterizer.cpp
renderer_software/rasterizer.h
renderer_software/renderer_software.cpp
renderer_software/renderer_software.h
renderer_software/sw_clipper.cpp

20
src/video_core/command_processor.cpp
View File

@ -90,16 +90,16 @@ static void WriteUniformFloatReg(ShaderRegs& config, Shader::ShaderSetup& setup,
for (auto i : {0, 1, 2, 3}) {
float buffer_value;
std::memcpy(&buffer_value, &uniform_write_buffer[i], sizeof(float));
uniform[3 - i] = float24::FromFloat32(buffer_value);
uniform[3 - i] = f24::FromFloat32(buffer_value);
}
} else {
// TODO: Untested
uniform.w = float24::FromRaw(uniform_write_buffer[0] >> 8);
uniform.z = float24::FromRaw(((uniform_write_buffer[0] & 0xFF) << 16) |
uniform.w = f24::FromRaw(uniform_write_buffer[0] >> 8);
uniform.z = f24::FromRaw(((uniform_write_buffer[0] & 0xFF) << 16) |
((uniform_write_buffer[1] >> 16) & 0xFFFF));
uniform.y = float24::FromRaw(((uniform_write_buffer[1] & 0xFFFF) << 8) |
uniform.y = f24::FromRaw(((uniform_write_buffer[1] & 0xFFFF) << 8) |
((uniform_write_buffer[2] >> 24) & 0xFF));
uniform.x = float24::FromRaw(uniform_write_buffer[2] & 0xFFFFFF);
uniform.x = f24::FromRaw(uniform_write_buffer[2] & 0xFFFFFF);
}
LOG_TRACE(HW_GPU, "Set {} float uniform {:x} to ({} {} {} {})",
@ -182,15 +182,15 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
break;
}
Common::Vec4<float24> attribute;
Common::Vec4<f24> attribute;
// NOTE: The destination component order indeed is "backwards"
attribute.w = float24::FromRaw(g_state.default_attr_write_buffer[0] >> 8);
attribute.z = float24::FromRaw(((g_state.default_attr_write_buffer[0] & 0xFF) << 16) |
attribute.w = f24::FromRaw(g_state.default_attr_write_buffer[0] >> 8);
attribute.z = f24::FromRaw(((g_state.default_attr_write_buffer[0] & 0xFF) << 16) |
((g_state.default_attr_write_buffer[1] >> 16) & 0xFFFF));
attribute.y = float24::FromRaw(((g_state.default_attr_write_buffer[1] & 0xFFFF) << 8) |
attribute.y = f24::FromRaw(((g_state.default_attr_write_buffer[1] & 0xFFFF) << 8) |
((g_state.default_attr_write_buffer[2] >> 24) & 0xFF));
attribute.x = float24::FromRaw(g_state.default_attr_write_buffer[2] & 0xFFFFFF);
attribute.x = f24::FromRaw(g_state.default_attr_write_buffer[2] & 0xFFFFFF);
LOG_TRACE(HW_GPU, "Set default VS attribute {:x} to ({} {} {} {})", (int)setup.index,
attribute.x.ToFloat32(), attribute.y.ToFloat32(), attribute.z.ToFloat32(),

14
src/video_core/geometry_pipeline.cpp
View File

@ -85,8 +85,8 @@ private:
const Regs& regs;
Shader::GSUnitState& unit;
Shader::AttributeBuffer attribute_buffer;
Common::Vec4<float24>* buffer_cur;
Common::Vec4<float24>* buffer_end;
Common::Vec4<f24>* buffer_cur;
Common::Vec4<f24>* buffer_end;
unsigned int vs_output_num;
GeometryPipeline_Point() : regs(g_state.regs), unit(g_state.gs_unit) {}
@ -146,7 +146,7 @@ public:
DEBUG_ASSERT(need_index);
// The number of vertex input is put to the uniform register
float24 vertex_num = float24::FromFloat32(static_cast<float>(val));
f24 vertex_num = f24::FromFloat32(static_cast<float>(val));
setup.uniforms.f[0] = Common::MakeVec(vertex_num, vertex_num, vertex_num, vertex_num);
// The second uniform register and so on are used for receiving input vertices
@ -183,7 +183,7 @@ private:
Shader::ShaderSetup& setup;
unsigned int main_vertex_num;
unsigned int total_vertex_num;
Common::Vec4<float24>* buffer_cur;
Common::Vec4<f24>* buffer_cur;
unsigned int vs_output_num;
GeometryPipeline_VariablePrimitive() : regs(g_state.regs), setup(g_state.gs) {}
@ -257,9 +257,9 @@ public:
private:
[[maybe_unused]] const Regs& regs;
Shader::ShaderSetup& setup;
Common::Vec4<float24>* buffer_begin;
Common::Vec4<float24>* buffer_cur;
Common::Vec4<float24>* buffer_end;
Common::Vec4<f24>* buffer_begin;
Common::Vec4<f24>* buffer_cur;
Common::Vec4<f24>* buffer_end;
unsigned int vs_output_num;
GeometryPipeline_FixedPrimitive() : regs(g_state.regs), setup(g_state.gs) {}

64
src/video_core/pica_types.h
View File

@ -25,20 +25,20 @@ namespace Pica {
template <unsigned M, unsigned E>
struct Float {
public:
static Float<M, E> FromFloat32(float val) {
static constexpr Float<M, E> FromFloat32(float val) {
Float<M, E> ret;
ret.value = val;
return ret;
}
static Float<M, E> FromRaw(u32 hex) {
static constexpr Float<M, E> FromRaw(u32 hex) {
Float<M, E> res;
const int width = M + E + 1;
const int bias = 128 - (1 << (E - 1));
int exponent = (hex >> M) & ((1 << E) - 1);
const unsigned mantissa = hex & ((1 << M) - 1);
const unsigned sign = (hex >> (E + M)) << 31;
const s32 width = M + E + 1;
const s32 bias = 128 - (1 << (E - 1));
s32 exponent = (hex >> M) & ((1 << E) - 1);
const u32 mantissa = hex & ((1 << M) - 1);
const u32 sign = (hex >> (E + M)) << 31;
if (hex & ((1 << (width - 1)) - 1)) {
if (exponent == (1 << E) - 1)
@ -55,16 +55,20 @@ public:
return res;
}
static Float<M, E> Zero() {
static constexpr Float<M, E> Zero() {
return FromFloat32(0.f);
}
static constexpr Float<M, E> One() {
return FromFloat32(1.f);
}
// Not recommended for anything but logging
float ToFloat32() const {
constexpr float ToFloat32() const {
return value;
}
Float<M, E> operator*(const Float<M, E>& flt) const {
constexpr Float<M, E> operator*(const Float<M, E>& flt) const {
float result = value * flt.ToFloat32();
// PICA gives 0 instead of NaN when multiplying by inf
if (std::isnan(result))
@ -73,70 +77,70 @@ public:
return Float<M, E>::FromFloat32(result);
}
Float<M, E> operator/(const Float<M, E>& flt) const {
constexpr Float<M, E> operator/(const Float<M, E>& flt) const {
return Float<M, E>::FromFloat32(ToFloat32() / flt.ToFloat32());
}
Float<M, E> operator+(const Float<M, E>& flt) const {
constexpr Float<M, E> operator+(const Float<M, E>& flt) const {
return Float<M, E>::FromFloat32(ToFloat32() + flt.ToFloat32());
}
Float<M, E> operator-(const Float<M, E>& flt) const {
constexpr Float<M, E> operator-(const Float<M, E>& flt) const {
return Float<M, E>::FromFloat32(ToFloat32() - flt.ToFloat32());
}
Float<M, E>& operator*=(const Float<M, E>& flt) {
constexpr Float<M, E>& operator*=(const Float<M, E>& flt) {
value = operator*(flt).value;
return *this;
}
Float<M, E>& operator/=(const Float<M, E>& flt) {
constexpr Float<M, E>& operator/=(const Float<M, E>& flt) {
value /= flt.ToFloat32();
return *this;
}
Float<M, E>& operator+=(const Float<M, E>& flt) {
constexpr Float<M, E>& operator+=(const Float<M, E>& flt) {
value += flt.ToFloat32();
return *this;
}
Float<M, E>& operator-=(const Float<M, E>& flt) {
constexpr Float<M, E>& operator-=(const Float<M, E>& flt) {
value -= flt.ToFloat32();
return *this;
}
Float<M, E> operator-() const {
constexpr Float<M, E> operator-() const {
return Float<M, E>::FromFloat32(-ToFloat32());
}
bool operator<(const Float<M, E>& flt) const {
constexpr bool operator<(const Float<M, E>& flt) const {
return ToFloat32() < flt.ToFloat32();
}
bool operator>(const Float<M, E>& flt) const {
constexpr bool operator>(const Float<M, E>& flt) const {
return ToFloat32() > flt.ToFloat32();
}
bool operator>=(const Float<M, E>& flt) const {
constexpr bool operator>=(const Float<M, E>& flt) const {
return ToFloat32() >= flt.ToFloat32();
}
bool operator<=(const Float<M, E>& flt) const {
constexpr bool operator<=(const Float<M, E>& flt) const {
return ToFloat32() <= flt.ToFloat32();
}
bool operator==(const Float<M, E>& flt) const {
constexpr bool operator==(const Float<M, E>& flt) const {
return ToFloat32() == flt.ToFloat32();
}
bool operator!=(const Float<M, E>& flt) const {
constexpr bool operator!=(const Float<M, E>& flt) const {
return ToFloat32() != flt.ToFloat32();
}
private:
static const unsigned MASK = (1 << (M + E + 1)) - 1;
static const unsigned MANTISSA_MASK = (1 << M) - 1;
static const unsigned EXPONENT_MASK = (1 << E) - 1;
static constexpr u32 MASK = (1 << (M + E + 1)) - 1;
static constexpr u32 MANTISSA_MASK = (1 << M) - 1;
static constexpr u32 EXPONENT_MASK = (1 << E) - 1;
// Stored as a regular float, merely for convenience
// TODO: Perform proper arithmetic on this!
@ -149,8 +153,8 @@ private:
}
};
using float24 = Float<16, 7>;
using float20 = Float<12, 7>;
using float16 = Float<10, 5>;
using f24 = Pica::Float<16, 7>;
using f20 = Pica::Float<12, 7>;
using f16 = Pica::Float<10, 5>;
} // namespace Pica

55
src/video_core/rasterizer_accelerated.cpp
View File

@ -10,6 +10,8 @@
namespace VideoCore {
using Pica::f24;
static Common::Vec4f ColorRGBA8(const u32 color) {
const auto rgba =
Common::Vec4u{color >> 0 & 0xFF, color >> 8 & 0xFF, color >> 16 & 0xFF, color >> 24 & 0xFF};
@ -73,7 +75,7 @@ RasterizerAccelerated::RasterizerAccelerated(Memory::MemorySystem& memory_)
* Fortunately however, the 3DS hardware happens to also use this exact same logic to work around
* these issues, making this basic implementation actually more accurate to the hardware.
*/
static bool AreQuaternionsOpposite(Common::Vec4<Pica::float24> qa, Common::Vec4<Pica::float24> qb) {
static bool AreQuaternionsOpposite(Common::Vec4<f24> qa, Common::Vec4<f24> qb) {
Common::Vec4f a{qa.x.ToFloat32(), qa.y.ToFloat32(), qa.z.ToFloat32(), qa.w.ToFloat32()};
Common::Vec4f b{qb.x.ToFloat32(), qb.y.ToFloat32(), qb.z.ToFloat32(), qb.w.ToFloat32()};
@ -612,7 +614,7 @@ void RasterizerAccelerated::NotifyPicaRegisterChanged(u32 id) {
}
void RasterizerAccelerated::SyncDepthScale() {
float depth_scale = Pica::float24::FromRaw(regs.rasterizer.viewport_depth_range).ToFloat32();
const f32 depth_scale = f24::FromRaw(regs.rasterizer.viewport_depth_range).ToFloat32();
if (depth_scale != uniform_block_data.data.depth_scale) {
uniform_block_data.data.depth_scale = depth_scale;
@ -621,8 +623,7 @@ void RasterizerAccelerated::SyncDepthScale() {
}
void RasterizerAccelerated::SyncDepthOffset() {
float depth_offset =
Pica::float24::FromRaw(regs.rasterizer.viewport_depth_near_plane).ToFloat32();
const f32 depth_offset = f24::FromRaw(regs.rasterizer.viewport_depth_near_plane).ToFloat32();
if (depth_offset != uniform_block_data.data.depth_offset) {
uniform_block_data.data.depth_offset = depth_offset;
@ -646,16 +647,16 @@ void RasterizerAccelerated::SyncFogColor() {
void RasterizerAccelerated::SyncProcTexNoise() {
const Common::Vec2f proctex_noise_f = {
Pica::float16::FromRaw(regs.texturing.proctex_noise_frequency.u).ToFloat32(),
Pica::float16::FromRaw(regs.texturing.proctex_noise_frequency.v).ToFloat32(),
Pica::f16::FromRaw(regs.texturing.proctex_noise_frequency.u).ToFloat32(),
Pica::f16::FromRaw(regs.texturing.proctex_noise_frequency.v).ToFloat32(),
};
const Common::Vec2f proctex_noise_a = {
regs.texturing.proctex_noise_u.amplitude / 4095.0f,
regs.texturing.proctex_noise_v.amplitude / 4095.0f,
};
const Common::Vec2f proctex_noise_p = {
Pica::float16::FromRaw(regs.texturing.proctex_noise_u.phase).ToFloat32(),
Pica::float16::FromRaw(regs.texturing.proctex_noise_v.phase).ToFloat32(),
Pica::f16::FromRaw(regs.texturing.proctex_noise_u.phase).ToFloat32(),
Pica::f16::FromRaw(regs.texturing.proctex_noise_v.phase).ToFloat32(),
};
if (proctex_noise_f != uniform_block_data.data.proctex_noise_f ||
@ -669,7 +670,7 @@ void RasterizerAccelerated::SyncProcTexNoise() {
}
void RasterizerAccelerated::SyncProcTexBias() {
const auto proctex_bias = Pica::float16::FromRaw(regs.texturing.proctex.bias_low |
const auto proctex_bias = Pica::f16::FromRaw(regs.texturing.proctex.bias_low |
(regs.texturing.proctex_lut.bias_high << 8))
.ToFloat32();
if (proctex_bias != uniform_block_data.data.proctex_bias) {
@ -687,7 +688,7 @@ void RasterizerAccelerated::SyncAlphaTest() {
}
void RasterizerAccelerated::SyncCombinerColor() {
auto combiner_color = ColorRGBA8(regs.texturing.tev_combiner_buffer_color.raw);
const auto combiner_color = ColorRGBA8(regs.texturing.tev_combiner_buffer_color.raw);
if (combiner_color != uniform_block_data.data.tev_combiner_buffer_color) {
uniform_block_data.data.tev_combiner_buffer_color = combiner_color;
uniform_block_data.dirty = true;
@ -695,7 +696,7 @@ void RasterizerAccelerated::SyncCombinerColor() {
}
void RasterizerAccelerated::SyncTevConstColor(
std::size_t stage_index, const Pica::TexturingRegs::TevStageConfig& tev_stage) {
const size_t stage_index, const Pica::TexturingRegs::TevStageConfig& tev_stage) {
const auto const_color = ColorRGBA8(tev_stage.const_color);
if (const_color == uniform_block_data.data.const_color[stage_index]) {
@ -707,7 +708,7 @@ void RasterizerAccelerated::SyncTevConstColor(
}
void RasterizerAccelerated::SyncGlobalAmbient() {
auto color = LightColor(regs.lighting.global_ambient);
const auto color = LightColor(regs.lighting.global_ambient);
if (color != uniform_block_data.data.lighting_global_ambient) {
uniform_block_data.data.lighting_global_ambient = color;
uniform_block_data.dirty = true;
@ -715,7 +716,7 @@ void RasterizerAccelerated::SyncGlobalAmbient() {
}
void RasterizerAccelerated::SyncLightSpecular0(int light_index) {
auto color = LightColor(regs.lighting.light[light_index].specular_0);
const auto color = LightColor(regs.lighting.light[light_index].specular_0);
if (color != uniform_block_data.data.light_src[light_index].specular_0) {
uniform_block_data.data.light_src[light_index].specular_0 = color;
uniform_block_data.dirty = true;
@ -723,7 +724,7 @@ void RasterizerAccelerated::SyncLightSpecular0(int light_index) {
}
void RasterizerAccelerated::SyncLightSpecular1(int light_index) {
auto color = LightColor(regs.lighting.light[light_index].specular_1);
const auto color = LightColor(regs.lighting.light[light_index].specular_1);
if (color != uniform_block_data.data.light_src[light_index].specular_1) {
uniform_block_data.data.light_src[light_index].specular_1 = color;
uniform_block_data.dirty = true;
@ -731,7 +732,7 @@ void RasterizerAccelerated::SyncLightSpecular1(int light_index) {
}
void RasterizerAccelerated::SyncLightDiffuse(int light_index) {
auto color = LightColor(regs.lighting.light[light_index].diffuse);
const auto color = LightColor(regs.lighting.light[light_index].diffuse);
if (color != uniform_block_data.data.light_src[light_index].diffuse) {
uniform_block_data.data.light_src[light_index].diffuse = color;
uniform_block_data.dirty = true;
@ -739,7 +740,7 @@ void RasterizerAccelerated::SyncLightDiffuse(int light_index) {
}
void RasterizerAccelerated::SyncLightAmbient(int light_index) {
auto color = LightColor(regs.lighting.light[light_index].ambient);
const auto color = LightColor(regs.lighting.light[light_index].ambient);
if (color != uniform_block_data.data.light_src[light_index].ambient) {
uniform_block_data.data.light_src[light_index].ambient = color;
uniform_block_data.dirty = true;
@ -748,9 +749,9 @@ void RasterizerAccelerated::SyncLightAmbient(int light_index) {
void RasterizerAccelerated::SyncLightPosition(int light_index) {
const Common::Vec3f position = {
Pica::float16::FromRaw(regs.lighting.light[light_index].x).ToFloat32(),
Pica::float16::FromRaw(regs.lighting.light[light_index].y).ToFloat32(),
Pica::float16::FromRaw(regs.lighting.light[light_index].z).ToFloat32(),
Pica::f16::FromRaw(regs.lighting.light[light_index].x).ToFloat32(),
Pica::f16::FromRaw(regs.lighting.light[light_index].y).ToFloat32(),
Pica::f16::FromRaw(regs.lighting.light[light_index].z).ToFloat32(),
};
if (position != uniform_block_data.data.light_src[light_index].position) {
@ -771,8 +772,8 @@ void RasterizerAccelerated::SyncLightSpotDirection(int light_index) {
}
void RasterizerAccelerated::SyncLightDistanceAttenuationBias(int light_index) {
float dist_atten_bias =
Pica::float20::FromRaw(regs.lighting.light[light_index].dist_atten_bias).ToFloat32();
const f32 dist_atten_bias =
Pica::f20::FromRaw(regs.lighting.light[light_index].dist_atten_bias).ToFloat32();
if (dist_atten_bias != uniform_block_data.data.light_src[light_index].dist_atten_bias) {
uniform_block_data.data.light_src[light_index].dist_atten_bias = dist_atten_bias;
@ -781,8 +782,8 @@ void RasterizerAccelerated::SyncLightDistanceAttenuationBias(int light_index) {
}
void RasterizerAccelerated::SyncLightDistanceAttenuationScale(int light_index) {
float dist_atten_scale =
Pica::float20::FromRaw(regs.lighting.light[light_index].dist_atten_scale).ToFloat32();
const f32 dist_atten_scale =
Pica::f20::FromRaw(regs.lighting.light[light_index].dist_atten_scale).ToFloat32();
if (dist_atten_scale != uniform_block_data.data.light_src[light_index].dist_atten_scale) {
uniform_block_data.data.light_src[light_index].dist_atten_scale = dist_atten_scale;
@ -792,8 +793,8 @@ void RasterizerAccelerated::SyncLightDistanceAttenuationScale(int light_index) {
void RasterizerAccelerated::SyncShadowBias() {
const auto& shadow = regs.framebuffer.shadow;
float constant = Pica::float16::FromRaw(shadow.constant).ToFloat32();
float linear = Pica::float16::FromRaw(shadow.linear).ToFloat32();
const f32 constant = Pica::f16::FromRaw(shadow.constant).ToFloat32();
const f32 linear = Pica::f16::FromRaw(shadow.linear).ToFloat32();
if (constant != uniform_block_data.data.shadow_bias_constant ||
linear != uniform_block_data.data.shadow_bias_linear) {
@ -804,7 +805,7 @@ void RasterizerAccelerated::SyncShadowBias() {
}
void RasterizerAccelerated::SyncShadowTextureBias() {
int bias = regs.texturing.shadow.bias << 1;
const s32 bias = regs.texturing.shadow.bias << 1;
if (bias != uniform_block_data.data.shadow_texture_bias) {
uniform_block_data.data.shadow_texture_bias = bias;
uniform_block_data.dirty = true;
@ -813,7 +814,7 @@ void RasterizerAccelerated::SyncShadowTextureBias() {
void RasterizerAccelerated::SyncTextureLodBias(int tex_index) {
const auto pica_textures = regs.texturing.GetTextures();
const float bias = pica_textures[tex_index].config.lod.bias / 256.0f;
const f32 bias = pica_textures[tex_index].config.lod.bias / 256.0f;
if (bias != uniform_block_data.data.tex_lod_bias[tex_index]) {
uniform_block_data.data.tex_lod_bias[tex_index] = bias;
uniform_block_data.dirty = true;

10
src/video_core/regs_rasterizer.h
View File

@ -37,9 +37,9 @@ struct RasterizerRegs {
BitField<0, 1, u32> clip_enable;
BitField<0, 24, u32> clip_coef[4]; // float24
Common::Vec4<float24> GetClipCoef() const {
return {float24::FromRaw(clip_coef[0]), float24::FromRaw(clip_coef[1]),
float24::FromRaw(clip_coef[2]), float24::FromRaw(clip_coef[3])};
Common::Vec4<f24> GetClipCoef() const {
return {f24::FromRaw(clip_coef[0]), f24::FromRaw(clip_coef[1]), f24::FromRaw(clip_coef[2]),
f24::FromRaw(clip_coef[3])};
}
Common::Rectangle<s32> GetViewportRect() const {
@ -47,9 +47,9 @@ struct RasterizerRegs {
// These registers hold half-width and half-height, so must be multiplied by 2
viewport_corner.x, // left
viewport_corner.y + // top
static_cast<s32>(float24::FromRaw(viewport_size_y).ToFloat32() * 2),
static_cast<s32>(f24::FromRaw(viewport_size_y).ToFloat32() * 2),
viewport_corner.x + // right
static_cast<s32>(float24::FromRaw(viewport_size_x).ToFloat32() * 2),
static_cast<s32>(f24::FromRaw(viewport_size_x).ToFloat32() * 2),
viewport_corner.y // bottom
};
}

10
src/video_core/renderer_base.h
View File

@ -18,6 +18,12 @@ class System;
namespace VideoCore {
enum class ScreenId : u32 {
TopLeft,
TopRight,
Bottom,
};
struct RendererSettings {
// Screenshot
std::atomic_bool screenshot_requested{false};
@ -75,7 +81,7 @@ public:
return current_fps;
}
int GetCurrentFrame() const {
s32 GetCurrentFrame() const {
return current_frame;
}
@ -108,7 +114,7 @@ protected:
Frontend::EmuWindow& render_window; ///< Reference to the render window handle.
Frontend::EmuWindow* secondary_window; ///< Reference to the secondary render window handle.
f32 current_fps = 0.0f; ///< Current framerate, should be set by the renderer
int current_frame = 0; ///< Current frame, should be set by the renderer
s32 current_frame = 0; ///< Current frame, should be set by the renderer
};
} // namespace VideoCore

901
src/video_core/renderer_software/rasterizer.cpp
View File

@ -1,901 +0,0 @@
// Copyright 2014 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <algorithm>
#include <array>
#include <cmath>
#include <tuple>
#include "common/assert.h"
#include "common/bit_field.h"
#include "common/color.h"
#include "common/common_types.h"
#include "common/logging/log.h"
#include "common/microprofile.h"
#include "common/quaternion.h"
#include "common/vector_math.h"
#include "core/hw/gpu.h"
#include "core/memory.h"
#include "video_core/debug_utils/debug_utils.h"
#include "video_core/pica_state.h"
#include "video_core/pica_types.h"
#include "video_core/regs_framebuffer.h"
#include "video_core/regs_rasterizer.h"
#include "video_core/regs_texturing.h"
#include "video_core/renderer_software/rasterizer.h"
#include "video_core/renderer_software/sw_framebuffer.h"
#include "video_core/renderer_software/sw_lighting.h"
#include "video_core/renderer_software/sw_proctex.h"
#include "video_core/renderer_software/sw_texturing.h"
#include "video_core/shader/shader.h"
#include "video_core/texture/texture_decode.h"
#include "video_core/utils.h"
#include "video_core/video_core.h"
namespace Pica::Rasterizer {
// NOTE: Assuming that rasterizer coordinates are 12.4 fixed-point values
struct Fix12P4 {
Fix12P4() {}
Fix12P4(u16 val) : val(val) {}
static u16 FracMask() {
return 0xF;
}
static u16 IntMask() {
return (u16)~0xF;
}
operator u16() const {
return val;
}
bool operator<(const Fix12P4& oth) const {
return (u16) * this < (u16)oth;
}
private:
u16 val;
};
/**
* Calculate signed area of the triangle spanned by the three argument vertices.
* The sign denotes an orientation.
*
* @todo define orientation concretely.
*/
static int SignedArea(const Common::Vec2<Fix12P4>& vtx1, const Common::Vec2<Fix12P4>& vtx2,
const Common::Vec2<Fix12P4>& vtx3) {
const auto vec1 = Common::MakeVec(vtx2 - vtx1, 0);
const auto vec2 = Common::MakeVec(vtx3 - vtx1, 0);
// TODO: There is a very small chance this will overflow for sizeof(int) == 4
return Common::Cross(vec1, vec2).z;
};
/// Convert a 3D vector for cube map coordinates to 2D texture coordinates along with the face name
static std::tuple<float24, float24, float24, PAddr> ConvertCubeCoord(float24 u, float24 v,
float24 w,
const TexturingRegs& regs) {
const float abs_u = std::abs(u.ToFloat32());
const float abs_v = std::abs(v.ToFloat32());
const float abs_w = std::abs(w.ToFloat32());
float24 x, y, z;
PAddr addr;
if (abs_u > abs_v && abs_u > abs_w) {
if (u > float24::FromFloat32(0)) {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::PositiveX);
y = -v;
} else {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::NegativeX);
y = v;
}
x = -w;
z = u;
} else if (abs_v > abs_w) {
if (v > float24::FromFloat32(0)) {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::PositiveY);
x = u;
} else {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::NegativeY);
x = -u;
}
y = w;
z = v;
} else {
if (w > float24::FromFloat32(0)) {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::PositiveZ);
y = -v;
} else {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::NegativeZ);
y = v;
}
x = u;
z = w;
}
float24 z_abs = float24::FromFloat32(std::abs(z.ToFloat32()));
const float24 half = float24::FromFloat32(0.5f);
return std::make_tuple(x / z * half + half, y / z * half + half, z_abs, addr);
}
MICROPROFILE_DEFINE(GPU_Rasterization, "GPU", "Rasterization", MP_RGB(50, 50, 240));
/**
* Helper function for ProcessTriangle with the "reversed" flag to allow for implementing
* culling via recursion.
*/
static void ProcessTriangleInternal(const Vertex& v0, const Vertex& v1, const Vertex& v2,
bool reversed = false) {
const auto& regs = g_state.regs;
MICROPROFILE_SCOPE(GPU_Rasterization);
// vertex positions in rasterizer coordinates
static auto FloatToFix = [](float24 flt) {
// TODO: Rounding here is necessary to prevent garbage pixels at
// triangle borders. Is it that the correct solution, though?
return Fix12P4(static_cast<unsigned short>(round(flt.ToFloat32() * 16.0f)));
};
static auto ScreenToRasterizerCoordinates = [](const Common::Vec3<float24>& vec) {
return Common::Vec3<Fix12P4>{FloatToFix(vec.x), FloatToFix(vec.y), FloatToFix(vec.z)};
};
Common::Vec3<Fix12P4> vtxpos[3]{ScreenToRasterizerCoordinates(v0.screenpos),
ScreenToRasterizerCoordinates(v1.screenpos),
ScreenToRasterizerCoordinates(v2.screenpos)};
if (regs.rasterizer.cull_mode == RasterizerRegs::CullMode::KeepAll) {
// Make sure we always end up with a triangle wound counter-clockwise
if (!reversed && SignedArea(vtxpos[0].xy(), vtxpos[1].xy(), vtxpos[2].xy()) <= 0) {
ProcessTriangleInternal(v0, v2, v1, true);
return;
}
} else {
if (!reversed && regs.rasterizer.cull_mode == RasterizerRegs::CullMode::KeepClockWise) {
// Reverse vertex order and use the CCW code path.
ProcessTriangleInternal(v0, v2, v1, true);
return;
}
// Cull away triangles which are wound clockwise.
if (SignedArea(vtxpos[0].xy(), vtxpos[1].xy(), vtxpos[2].xy()) <= 0)
return;
}
u16 min_x = std::min({vtxpos[0].x, vtxpos[1].x, vtxpos[2].x});
u16 min_y = std::min({vtxpos[0].y, vtxpos[1].y, vtxpos[2].y});
u16 max_x = std::max({vtxpos[0].x, vtxpos[1].x, vtxpos[2].x});
u16 max_y = std::max({vtxpos[0].y, vtxpos[1].y, vtxpos[2].y});
// Convert the scissor box coordinates to 12.4 fixed point
u16 scissor_x1 = (u16)(regs.rasterizer.scissor_test.x1 << 4);
u16 scissor_y1 = (u16)(regs.rasterizer.scissor_test.y1 << 4);
// x2,y2 have +1 added to cover the entire sub-pixel area
u16 scissor_x2 = (u16)((regs.rasterizer.scissor_test.x2 + 1) << 4);
u16 scissor_y2 = (u16)((regs.rasterizer.scissor_test.y2 + 1) << 4);
if (regs.rasterizer.scissor_test.mode == RasterizerRegs::ScissorMode::Include) {
// Calculate the new bounds
min_x = std::max(min_x, scissor_x1);
min_y = std::max(min_y, scissor_y1);
max_x = std::min(max_x, scissor_x2);
max_y = std::min(max_y, scissor_y2);
}
min_x &= Fix12P4::IntMask();
min_y &= Fix12P4::IntMask();
max_x = ((max_x + Fix12P4::FracMask()) & Fix12P4::IntMask());
max_y = ((max_y + Fix12P4::FracMask()) & Fix12P4::IntMask());
// Triangle filling rules: Pixels on the right-sided edge or on flat bottom edges are not
// drawn. Pixels on any other triangle border are drawn. This is implemented with three bias
// values which are added to the barycentric coordinates w0, w1 and w2, respectively.
// NOTE: These are the PSP filling rules. Not sure if the 3DS uses the same ones...
auto IsRightSideOrFlatBottomEdge = [](const Common::Vec2<Fix12P4>& vtx,
const Common::Vec2<Fix12P4>& line1,
const Common::Vec2<Fix12P4>& line2) {
if (line1.y == line2.y) {
// just check if vertex is above us => bottom line parallel to x-axis
return vtx.y < line1.y;
} else {
// check if vertex is on our left => right side
// TODO: Not sure how likely this is to overflow
return (int)vtx.x < (int)line1.x + ((int)line2.x - (int)line1.x) *
((int)vtx.y - (int)line1.y) /
((int)line2.y - (int)line1.y);
}
};
int bias0 =
IsRightSideOrFlatBottomEdge(vtxpos[0].xy(), vtxpos[1].xy(), vtxpos[2].xy()) ? -1 : 0;
int bias1 =
IsRightSideOrFlatBottomEdge(vtxpos[1].xy(), vtxpos[2].xy(), vtxpos[0].xy()) ? -1 : 0;
int bias2 =
IsRightSideOrFlatBottomEdge(vtxpos[2].xy(), vtxpos[0].xy(), vtxpos[1].xy()) ? -1 : 0;
auto w_inverse = Common::MakeVec(v0.pos.w, v1.pos.w, v2.pos.w);
auto textures = regs.texturing.GetTextures();
auto tev_stages = regs.texturing.GetTevStages();
bool stencil_action_enable =
g_state.regs.framebuffer.output_merger.stencil_test.enable &&
g_state.regs.framebuffer.framebuffer.depth_format == FramebufferRegs::DepthFormat::D24S8;
const auto stencil_test = g_state.regs.framebuffer.output_merger.stencil_test;
// Enter rasterization loop, starting at the center of the topleft bounding box corner.
// TODO: Not sure if looping through x first might be faster
for (u16 y = min_y + 8; y < max_y; y += 0x10) {
for (u16 x = min_x + 8; x < max_x; x += 0x10) {
// Do not process the pixel if it's inside the scissor box and the scissor mode is set
// to Exclude
if (regs.rasterizer.scissor_test.mode == RasterizerRegs::ScissorMode::Exclude) {
if (x >= scissor_x1 && x < scissor_x2 && y >= scissor_y1 && y < scissor_y2)
continue;
}
// Calculate the barycentric coordinates w0, w1 and w2
int w0 = bias0 + SignedArea(vtxpos[1].xy(), vtxpos[2].xy(), {x, y});
int w1 = bias1 + SignedArea(vtxpos[2].xy(), vtxpos[0].xy(), {x, y});
int w2 = bias2 + SignedArea(vtxpos[0].xy(), vtxpos[1].xy(), {x, y});
int wsum = w0 + w1 + w2;
// If current pixel is not covered by the current primitive
if (w0 < 0 || w1 < 0 || w2 < 0)
continue;
auto baricentric_coordinates =
Common::MakeVec(float24::FromFloat32(static_cast<float>(w0)),
float24::FromFloat32(static_cast<float>(w1)),
float24::FromFloat32(static_cast<float>(w2)));
float24 interpolated_w_inverse =
float24::FromFloat32(1.0f) / Common::Dot(w_inverse, baricentric_coordinates);
// interpolated_z = z / w
float interpolated_z_over_w =
(v0.screenpos[2].ToFloat32() * w0 + v1.screenpos[2].ToFloat32() * w1 +
v2.screenpos[2].ToFloat32() * w2) /
wsum;
// Not fully accurate. About 3 bits in precision are missing.
// Z-Buffer (z / w * scale + offset)
float depth_scale = float24::FromRaw(regs.rasterizer.viewport_depth_range).ToFloat32();
float depth_offset =
float24::FromRaw(regs.rasterizer.viewport_depth_near_plane).ToFloat32();
float depth = interpolated_z_over_w * depth_scale + depth_offset;
// Potentially switch to W-Buffer
if (regs.rasterizer.depthmap_enable ==
Pica::RasterizerRegs::DepthBuffering::WBuffering) {
// W-Buffer (z * scale + w * offset = (z / w * scale + offset) * w)
depth *= interpolated_w_inverse.ToFloat32() * wsum;
}
// Clamp the result
depth = std::clamp(depth, 0.0f, 1.0f);
// Perspective correct attribute interpolation:
// Attribute values cannot be calculated by simple linear interpolation since
// they are not linear in screen space. For example, when interpolating a
// texture coordinate across two vertices, something simple like
// u = (u0*w0 + u1*w1)/(w0+w1)
// will not work. However, the attribute value divided by the
// clipspace w-coordinate (u/w) and and the inverse w-coordinate (1/w) are linear
// in screenspace. Hence, we can linearly interpolate these two independently and
// calculate the interpolated attribute by dividing the results.
// I.e.
// u_over_w = ((u0/v0.pos.w)*w0 + (u1/v1.pos.w)*w1)/(w0+w1)
// one_over_w = (( 1/v0.pos.w)*w0 + ( 1/v1.pos.w)*w1)/(w0+w1)
// u = u_over_w / one_over_w
//
// The generalization to three vertices is straightforward in baricentric coordinates.
auto GetInterpolatedAttribute = [&](float24 attr0, float24 attr1, float24 attr2) {
auto attr_over_w = Common::MakeVec(attr0, attr1, attr2);
float24 interpolated_attr_over_w =
Common::Dot(attr_over_w, baricentric_coordinates);
return interpolated_attr_over_w * interpolated_w_inverse;
};
Common::Vec4<u8> primary_color{
static_cast<u8>(round(
GetInterpolatedAttribute(v0.color.r(), v1.color.r(), v2.color.r()).ToFloat32() *
255)),
static_cast<u8>(round(
GetInterpolatedAttribute(v0.color.g(), v1.color.g(), v2.color.g()).ToFloat32() *
255)),
static_cast<u8>(round(
GetInterpolatedAttribute(v0.color.b(), v1.color.b(), v2.color.b()).ToFloat32() *
255)),
static_cast<u8>(round(
GetInterpolatedAttribute(v0.color.a(), v1.color.a(), v2.color.a()).ToFloat32() *
255)),
};
Common::Vec2<float24> uv[3];
uv[0].u() = GetInterpolatedAttribute(v0.tc0.u(), v1.tc0.u(), v2.tc0.u());
uv[0].v() = GetInterpolatedAttribute(v0.tc0.v(), v1.tc0.v(), v2.tc0.v());
uv[1].u() = GetInterpolatedAttribute(v0.tc1.u(), v1.tc1.u(), v2.tc1.u());
uv[1].v() = GetInterpolatedAttribute(v0.tc1.v(), v1.tc1.v(), v2.tc1.v());
uv[2].u() = GetInterpolatedAttribute(v0.tc2.u(), v1.tc2.u(), v2.tc2.u());
uv[2].v() = GetInterpolatedAttribute(v0.tc2.v(), v1.tc2.v(), v2.tc2.v());
Common::Vec4<u8> texture_color[4]{};
for (int i = 0; i < 3; ++i) {
const auto& texture = textures[i];
if (!texture.enabled)
continue;
if (texture.config.address == 0) {
texture_color[i] = {0, 0, 0, 255};
continue;
}
int coordinate_i =
(i == 2 && regs.texturing.main_config.texture2_use_coord1) ? 1 : i;
float24 u = uv[coordinate_i].u();
float24 v = uv[coordinate_i].v();
// Only unit 0 respects the texturing type (according to 3DBrew)
// TODO: Refactor so cubemaps and shadowmaps can be handled
PAddr texture_address = texture.config.GetPhysicalAddress();
float24 shadow_z;
if (i == 0) {
switch (texture.config.type) {
case TexturingRegs::TextureConfig::Texture2D:
break;
case TexturingRegs::TextureConfig::ShadowCube:
case TexturingRegs::TextureConfig::TextureCube: {
auto w = GetInterpolatedAttribute(v0.tc0_w, v1.tc0_w, v2.tc0_w);
std::tie(u, v, shadow_z, texture_address) =
ConvertCubeCoord(u, v, w, regs.texturing);
break;
}
case TexturingRegs::TextureConfig::Projection2D: {
auto tc0_w = GetInterpolatedAttribute(v0.tc0_w, v1.tc0_w, v2.tc0_w);
u /= tc0_w;
v /= tc0_w;
break;
}
case TexturingRegs::TextureConfig::Shadow2D: {
auto tc0_w = GetInterpolatedAttribute(v0.tc0_w, v1.tc0_w, v2.tc0_w);
if (!regs.texturing.shadow.orthographic) {
u /= tc0_w;
v /= tc0_w;
}
shadow_z = float24::FromFloat32(std::abs(tc0_w.ToFloat32()));
break;
}
case TexturingRegs::TextureConfig::Disabled:
continue; // skip this unit and continue to the next unit
default:
LOG_ERROR(HW_GPU, "Unhandled texture type {:x}", (int)texture.config.type);
UNIMPLEMENTED();
break;
}
}
int s = (int)(u * float24::FromFloat32(static_cast<float>(texture.config.width)))
.ToFloat32();
int t = (int)(v * float24::FromFloat32(static_cast<float>(texture.config.height)))
.ToFloat32();
bool use_border_s = false;
bool use_border_t = false;
if (texture.config.wrap_s == TexturingRegs::TextureConfig::ClampToBorder) {
use_border_s = s < 0 || s >= static_cast<int>(texture.config.width);
} else if (texture.config.wrap_s == TexturingRegs::TextureConfig::ClampToBorder2) {
use_border_s = s >= static_cast<int>(texture.config.width);
}
if (texture.config.wrap_t == TexturingRegs::TextureConfig::ClampToBorder) {
use_border_t = t < 0 || t >= static_cast<int>(texture.config.height);
} else if (texture.config.wrap_t == TexturingRegs::TextureConfig::ClampToBorder2) {
use_border_t = t >= static_cast<int>(texture.config.height);
}
if (use_border_s || use_border_t) {
auto border_color = texture.config.border_color;
texture_color[i] =
Common::MakeVec(border_color.r.Value(), border_color.g.Value(),
border_color.b.Value(), border_color.a.Value())
.Cast<u8>();
} else {
// Textures are laid out from bottom to top, hence we invert the t coordinate.
// NOTE: This may not be the right place for the inversion.
// TODO: Check if this applies to ETC textures, too.
s = GetWrappedTexCoord(texture.config.wrap_s, s, texture.config.width);
t = texture.config.height - 1 -
GetWrappedTexCoord(texture.config.wrap_t, t, texture.config.height);
const u8* texture_data =
VideoCore::g_memory->GetPhysicalPointer(texture_address);
auto info =
Texture::TextureInfo::FromPicaRegister(texture.config, texture.format);
// TODO: Apply the min and mag filters to the texture
texture_color[i] = Texture::LookupTexture(texture_data, s, t, info);
}
if (i == 0 && (texture.config.type == TexturingRegs::TextureConfig::Shadow2D ||
texture.config.type == TexturingRegs::TextureConfig::ShadowCube)) {
s32 z_int = static_cast<s32>(std::min(shadow_z.ToFloat32(), 1.0f) * 0xFFFFFF);
z_int -= regs.texturing.shadow.bias << 1;
auto& color = texture_color[i];
s32 z_ref = (color.w << 16) | (color.z << 8) | color.y;
u8 density;
if (z_ref >= z_int) {
density = color.x;
} else {
density = 0;
}
texture_color[i] = {density, density, density, density};
}
}
// sample procedural texture
if (regs.texturing.main_config.texture3_enable) {
const auto& proctex_uv = uv[regs.texturing.main_config.texture3_coordinates];
texture_color[3] = ProcTex(proctex_uv.u().ToFloat32(), proctex_uv.v().ToFloat32(),
g_state.regs.texturing, g_state.proctex);
}
// Texture environment - consists of 6 stages of color and alpha combining.
//
// Color combiners take three input color values from some source (e.g. interpolated
// vertex color, texture color, previous stage, etc), perform some very simple
// operations on each of them (e.g. inversion) and then calculate the output color
// with some basic arithmetic. Alpha combiners can be configured separately but work
// analogously.
Common::Vec4<u8> combiner_output;
Common::Vec4<u8> combiner_buffer = {0, 0, 0, 0};
Common::Vec4<u8> next_combiner_buffer =
Common::MakeVec(regs.texturing.tev_combiner_buffer_color.r.Value(),
regs.texturing.tev_combiner_buffer_color.g.Value(),
regs.texturing.tev_combiner_buffer_color.b.Value(),
regs.texturing.tev_combiner_buffer_color.a.Value())
.Cast<u8>();
Common::Vec4<u8> primary_fragment_color = {0, 0, 0, 0};
Common::Vec4<u8> secondary_fragment_color = {0, 0, 0, 0};
if (!g_state.regs.lighting.disable) {
Common::Quaternion<float> normquat =
Common::Quaternion<float>{
{GetInterpolatedAttribute(v0.quat.x, v1.quat.x, v2.quat.x).ToFloat32(),
GetInterpolatedAttribute(v0.quat.y, v1.quat.y, v2.quat.y).ToFloat32(),
GetInterpolatedAttribute(v0.quat.z, v1.quat.z, v2.quat.z).ToFloat32()},
GetInterpolatedAttribute(v0.quat.w, v1.quat.w, v2.quat.w).ToFloat32(),
}
.Normalized();
Common::Vec3<float> view{
GetInterpolatedAttribute(v0.view.x, v1.view.x, v2.view.x).ToFloat32(),
GetInterpolatedAttribute(v0.view.y, v1.view.y, v2.view.y).ToFloat32(),
GetInterpolatedAttribute(v0.view.z, v1.view.z, v2.view.z).ToFloat32(),
};
std::tie(primary_fragment_color, secondary_fragment_color) = ComputeFragmentsColors(
g_state.regs.lighting, g_state.lighting, normquat, view, texture_color);
}
for (unsigned tev_stage_index = 0; tev_stage_index < tev_stages.size();
++tev_stage_index) {
const auto& tev_stage = tev_stages[tev_stage_index];
using Source = TexturingRegs::TevStageConfig::Source;
auto GetSource = [&](Source source) -> Common::Vec4<u8> {
switch (source) {
case Source::PrimaryColor:
return primary_color;
case Source::PrimaryFragmentColor:
return primary_fragment_color;
case Source::SecondaryFragmentColor:
return secondary_fragment_color;
case Source::Texture0:
return texture_color[0];
case Source::Texture1:
return texture_color[1];
case Source::Texture2:
return texture_color[2];
case Source::Texture3:
return texture_color[3];
case Source::PreviousBuffer:
return combiner_buffer;
case Source::Constant:
return Common::MakeVec(tev_stage.const_r.Value(), tev_stage.const_g.Value(),
tev_stage.const_b.Value(), tev_stage.const_a.Value())
.Cast<u8>();
case Source::Previous:
return combiner_output;
default:
LOG_ERROR(HW_GPU, "Unknown color combiner source {}", (int)source);
UNIMPLEMENTED();
return {0, 0, 0, 0};
}
};
// color combiner
// NOTE: Not sure if the alpha combiner might use the color output of the previous
// stage as input. Hence, we currently don't directly write the result to
// combiner_output.rgb(), but instead store it in a temporary variable until
// alpha combining has been done.
Common::Vec3<u8> color_result[3] = {
GetColorModifier(tev_stage.color_modifier1, GetSource(tev_stage.color_source1)),
GetColorModifier(tev_stage.color_modifier2, GetSource(tev_stage.color_source2)),
GetColorModifier(tev_stage.color_modifier3, GetSource(tev_stage.color_source3)),
};
auto color_output = ColorCombine(tev_stage.color_op, color_result);
u8 alpha_output;
if (tev_stage.color_op == TexturingRegs::TevStageConfig::Operation::Dot3_RGBA) {
// result of Dot3_RGBA operation is also placed to the alpha component
alpha_output = color_output.x;
} else {
// alpha combiner
std::array<u8, 3> alpha_result = {{
GetAlphaModifier(tev_stage.alpha_modifier1,
GetSource(tev_stage.alpha_source1)),
GetAlphaModifier(tev_stage.alpha_modifier2,
GetSource(tev_stage.alpha_source2)),
GetAlphaModifier(tev_stage.alpha_modifier3,
GetSource(tev_stage.alpha_source3)),
}};
alpha_output = AlphaCombine(tev_stage.alpha_op, alpha_result);
}
combiner_output[0] =
std::min((unsigned)255, color_output.r() * tev_stage.GetColorMultiplier());
combiner_output[1] =
std::min((unsigned)255, color_output.g() * tev_stage.GetColorMultiplier());
combiner_output[2] =
std::min((unsigned)255, color_output.b() * tev_stage.GetColorMultiplier());
combiner_output[3] =
std::min((unsigned)255, alpha_output * tev_stage.GetAlphaMultiplier());
combiner_buffer = next_combiner_buffer;
if (regs.texturing.tev_combiner_buffer_input.TevStageUpdatesCombinerBufferColor(
tev_stage_index)) {
next_combiner_buffer.r() = combiner_output.r();
next_combiner_buffer.g() = combiner_output.g();
next_combiner_buffer.b() = combiner_output.b();
}
if (regs.texturing.tev_combiner_buffer_input.TevStageUpdatesCombinerBufferAlpha(
tev_stage_index)) {
next_combiner_buffer.a() = combiner_output.a();
}
}
const auto& output_merger = regs.framebuffer.output_merger;
if (output_merger.fragment_operation_mode ==
FramebufferRegs::FragmentOperationMode::Shadow) {
u32 depth_int = static_cast<u32>(depth * 0xFFFFFF);
// use green color as the shadow intensity
u8 stencil = combiner_output.y;
DrawShadowMapPixel(x >> 4, y >> 4, depth_int, stencil);
// skip the normal output merger pipeline if it is in shadow mode
continue;
}
// TODO: Does alpha testing happen before or after stencil?
if (output_merger.alpha_test.enable) {
bool pass = false;
switch (output_merger.alpha_test.func) {
case FramebufferRegs::CompareFunc::Never:
pass = false;
break;
case FramebufferRegs::CompareFunc::Always:
pass = true;
break;
case FramebufferRegs::CompareFunc::Equal:
pass = combiner_output.a() == output_merger.alpha_test.ref;
break;
case FramebufferRegs::CompareFunc::NotEqual:
pass = combiner_output.a() != output_merger.alpha_test.ref;
break;
case FramebufferRegs::CompareFunc::LessThan:
pass = combiner_output.a() < output_merger.alpha_test.ref;
break;
case FramebufferRegs::CompareFunc::LessThanOrEqual:
pass = combiner_output.a() <= output_merger.alpha_test.ref;
break;
case FramebufferRegs::CompareFunc::GreaterThan:
pass = combiner_output.a() > output_merger.alpha_test.ref;
break;
case FramebufferRegs::CompareFunc::GreaterThanOrEqual:
pass = combiner_output.a() >= output_merger.alpha_test.ref;
break;
}
if (!pass)
continue;
}
// Apply fog combiner
// Not fully accurate. We'd have to know what data type is used to
// store the depth etc. Using float for now until we know more
// about Pica datatypes
if (regs.texturing.fog_mode == TexturingRegs::FogMode::Fog) {
const Common::Vec3<u8> fog_color =
Common::MakeVec(regs.texturing.fog_color.r.Value(),
regs.texturing.fog_color.g.Value(),
regs.texturing.fog_color.b.Value())
.Cast<u8>();
// Get index into fog LUT
float fog_index;
if (g_state.regs.texturing.fog_flip) {
fog_index = (1.0f - depth) * 128.0f;
} else {
fog_index = depth * 128.0f;
}
// Generate clamped fog factor from LUT for given fog index
float fog_i = std::clamp(floorf(fog_index), 0.0f, 127.0f);
float fog_f = fog_index - fog_i;
const auto& fog_lut_entry = g_state.fog.lut[static_cast<unsigned int>(fog_i)];
float fog_factor = fog_lut_entry.ToFloat() + fog_lut_entry.DiffToFloat() * fog_f;
fog_factor = std::clamp(fog_factor, 0.0f, 1.0f);
// Blend the fog
for (unsigned i = 0; i < 3; i++) {
combiner_output[i] = static_cast<u8>(fog_factor * combiner_output[i] +
(1.0f - fog_factor) * fog_color[i]);
}
}
u8 old_stencil = 0;
auto UpdateStencil = [stencil_test, x, y,
&old_stencil](Pica::FramebufferRegs::StencilAction action) {
u8 new_stencil =
PerformStencilAction(action, old_stencil, stencil_test.reference_value);
if (g_state.regs.framebuffer.framebuffer.allow_depth_stencil_write != 0)
SetStencil(x >> 4, y >> 4,
(new_stencil & stencil_test.write_mask) |
(old_stencil & ~stencil_test.write_mask));
};
if (stencil_action_enable) {
old_stencil = GetStencil(x >> 4, y >> 4);
u8 dest = old_stencil & stencil_test.input_mask;
u8 ref = stencil_test.reference_value & stencil_test.input_mask;
bool pass = false;
switch (stencil_test.func) {
case FramebufferRegs::CompareFunc::Never:
pass = false;
break;
case FramebufferRegs::CompareFunc::Always:
pass = true;
break;
case FramebufferRegs::CompareFunc::Equal:
pass = (ref == dest);
break;
case FramebufferRegs::CompareFunc::NotEqual:
pass = (ref != dest);
break;
case FramebufferRegs::CompareFunc::LessThan:
pass = (ref < dest);
break;
case FramebufferRegs::CompareFunc::LessThanOrEqual:
pass = (ref <= dest);
break;
case FramebufferRegs::CompareFunc::GreaterThan:
pass = (ref > dest);
break;
case FramebufferRegs::CompareFunc::GreaterThanOrEqual:
pass = (ref >= dest);
break;
}
if (!pass) {
UpdateStencil(stencil_test.action_stencil_fail);
continue;
}
}
// Convert float to integer
unsigned num_bits =
FramebufferRegs::DepthBitsPerPixel(regs.framebuffer.framebuffer.depth_format);
u32 z = (u32)(depth * ((1 << num_bits) - 1));
if (output_merger.depth_test_enable) {
u32 ref_z = GetDepth(x >> 4, y >> 4);
bool pass = false;
switch (output_merger.depth_test_func) {
case FramebufferRegs::CompareFunc::Never:
pass = false;
break;
case FramebufferRegs::CompareFunc::Always:
pass = true;
break;
case FramebufferRegs::CompareFunc::Equal:
pass = z == ref_z;
break;
case FramebufferRegs::CompareFunc::NotEqual:
pass = z != ref_z;
break;
case FramebufferRegs::CompareFunc::LessThan:
pass = z < ref_z;
break;
case FramebufferRegs::CompareFunc::LessThanOrEqual:
pass = z <= ref_z;
break;
case FramebufferRegs::CompareFunc::GreaterThan:
pass = z > ref_z;
break;
case FramebufferRegs::CompareFunc::GreaterThanOrEqual:
pass = z >= ref_z;
break;
}
if (!pass) {
if (stencil_action_enable)
UpdateStencil(stencil_test.action_depth_fail);
continue;
}
}
if (regs.framebuffer.framebuffer.allow_depth_stencil_write != 0 &&
output_merger.depth_write_enable) {
SetDepth(x >> 4, y >> 4, z);
}
// The stencil depth_pass action is executed even if depth testing is disabled
if (stencil_action_enable)
UpdateStencil(stencil_test.action_depth_pass);
auto dest = GetPixel(x >> 4, y >> 4);
Common::Vec4<u8> blend_output = combiner_output;
if (output_merger.alphablend_enable) {
auto params = output_merger.alpha_blending;
auto LookupFactor = [&](unsigned channel,
FramebufferRegs::BlendFactor factor) -> u8 {
DEBUG_ASSERT(channel < 4);
const Common::Vec4<u8> blend_const =
Common::MakeVec(output_merger.blend_const.r.Value(),
output_merger.blend_const.g.Value(),
output_merger.blend_const.b.Value(),
output_merger.blend_const.a.Value())
.Cast<u8>();
switch (factor) {
case FramebufferRegs::BlendFactor::Zero:
return 0;
case FramebufferRegs::BlendFactor::One:
return 255;
case FramebufferRegs::BlendFactor::SourceColor:
return combiner_output[channel];
case FramebufferRegs::BlendFactor::OneMinusSourceColor:
return 255 - combiner_output[channel];
case FramebufferRegs::BlendFactor::DestColor:
return dest[channel];
case FramebufferRegs::BlendFactor::OneMinusDestColor:
return 255 - dest[channel];
case FramebufferRegs::BlendFactor::SourceAlpha:
return combiner_output.a();
case FramebufferRegs::BlendFactor::OneMinusSourceAlpha:
return 255 - combiner_output.a();
case FramebufferRegs::BlendFactor::DestAlpha:
return dest.a();
case FramebufferRegs::BlendFactor::OneMinusDestAlpha:
return 255 - dest.a();
case FramebufferRegs::BlendFactor::ConstantColor:
return blend_const[channel];
case FramebufferRegs::BlendFactor::OneMinusConstantColor:
return 255 - blend_const[channel];
case FramebufferRegs::BlendFactor::ConstantAlpha:
return blend_const.a();
case FramebufferRegs::BlendFactor::OneMinusConstantAlpha:
return 255 - blend_const.a();
case FramebufferRegs::BlendFactor::SourceAlphaSaturate:
// Returns 1.0 for the alpha channel
if (channel == 3)
return 255;
return std::min(combiner_output.a(), static_cast<u8>(255 - dest.a()));
default:
LOG_CRITICAL(HW_GPU, "Unknown blend factor {:x}", factor);
UNIMPLEMENTED();
break;
}
return combiner_output[channel];
};
auto srcfactor = Common::MakeVec(LookupFactor(0, params.factor_source_rgb),
LookupFactor(1, params.factor_source_rgb),
LookupFactor(2, params.factor_source_rgb),
LookupFactor(3, params.factor_source_a));
auto dstfactor = Common::MakeVec(LookupFactor(0, params.factor_dest_rgb),
LookupFactor(1, params.factor_dest_rgb),
LookupFactor(2, params.factor_dest_rgb),
LookupFactor(3, params.factor_dest_a));
blend_output = EvaluateBlendEquation(combiner_output, srcfactor, dest, dstfactor,
params.blend_equation_rgb);
blend_output.a() = EvaluateBlendEquation(combiner_output, srcfactor, dest,
dstfactor, params.blend_equation_a)
.a();
} else {
blend_output =
Common::MakeVec(LogicOp(combiner_output.r(), dest.r(), output_merger.logic_op),
LogicOp(combiner_output.g(), dest.g(), output_merger.logic_op),
LogicOp(combiner_output.b(), dest.b(), output_merger.logic_op),
LogicOp(combiner_output.a(), dest.a(), output_merger.logic_op));
}
const Common::Vec4<u8> result = {
output_merger.red_enable ? blend_output.r() : dest.r(),
output_merger.green_enable ? blend_output.g() : dest.g(),
output_merger.blue_enable ? blend_output.b() : dest.b(),
output_merger.alpha_enable ? blend_output.a() : dest.a(),
};
if (regs.framebuffer.framebuffer.allow_color_write != 0)
DrawPixel(x >> 4, y >> 4, result);
}
}
}
void ProcessTriangle(const Vertex& v0, const Vertex& v1, const Vertex& v2) {
ProcessTriangleInternal(v0, v1, v2);
}
} // namespace Pica::Rasterizer

44
src/video_core/renderer_software/rasterizer.h
View File

@ -1,44 +0,0 @@
// Copyright 2014 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
#include "video_core/shader/shader.h"
namespace Pica::Rasterizer {
struct Vertex : Shader::OutputVertex {
Vertex(const OutputVertex& v) : OutputVertex(v) {}
// Attributes used to store intermediate results
// position after perspective divide
Common::Vec3<float24> screenpos;
// Linear interpolation
// factor: 0=this, 1=vtx
// Note: This function cannot be called after perspective divide
void Lerp(float24 factor, const Vertex& vtx) {
pos = pos * factor + vtx.pos * (float24::FromFloat32(1) - factor);
quat = quat * factor + vtx.quat * (float24::FromFloat32(1) - factor);
color = color * factor + vtx.color * (float24::FromFloat32(1) - factor);
tc0 = tc0 * factor + vtx.tc0 * (float24::FromFloat32(1) - factor);
tc1 = tc1 * factor + vtx.tc1 * (float24::FromFloat32(1) - factor);
tc0_w = tc0_w * factor + vtx.tc0_w * (float24::FromFloat32(1) - factor);
view = view * factor + vtx.view * (float24::FromFloat32(1) - factor);
tc2 = tc2 * factor + vtx.tc2 * (float24::FromFloat32(1) - factor);
}
// Linear interpolation
// factor: 0=v0, 1=v1
// Note: This function cannot be called after perspective divide
static Vertex Lerp(float24 factor, const Vertex& v0, const Vertex& v1) {
Vertex ret = v0;
ret.Lerp(factor, v1);
return ret;
}
};
void ProcessTriangle(const Vertex& v0, const Vertex& v1, const Vertex& v2);
} // namespace Pica::Rasterizer

76
src/video_core/renderer_software/renderer_software.cpp
View File

@ -2,18 +2,86 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/color.h"
#include "core/core.h"
#include "core/hw/gpu.h"
#include "core/hw/hw.h"
#include "core/hw/lcd.h"
#include "video_core/renderer_software/renderer_software.h"
namespace VideoCore {
namespace SwRenderer {
RendererSoftware::RendererSoftware(Core::System& system, Frontend::EmuWindow& window)
: VideoCore::RendererBase{system, window, nullptr},
rasterizer{std::make_unique<RasterizerSoftware>()} {}
: VideoCore::RendererBase{system, window, nullptr}, memory{system.Memory()},
rasterizer{std::make_unique<RasterizerSoftware>(system.Memory())} {}
RendererSoftware::~RendererSoftware() = default;
void RendererSoftware::SwapBuffers() {
PrepareRenderTarget();
EndFrame();
}
} // namespace VideoCore
void RendererSoftware::PrepareRenderTarget() {
for (int i : {0, 1, 2}) {
const int fb_id = i == 2 ? 1 : 0;
const auto& framebuffer = GPU::g_regs.framebuffer_config[fb_id];
auto& info = screen_infos[i];
u32 lcd_color_addr =
(fb_id == 0) ? LCD_REG_INDEX(color_fill_top) : LCD_REG_INDEX(color_fill_bottom);
lcd_color_addr = HW::VADDR_LCD + 4 * lcd_color_addr;
LCD::Regs::ColorFill color_fill = {0};
LCD::Read(color_fill.raw, lcd_color_addr);
if (!color_fill.is_enabled) {
const u32 old_width = std::exchange(info.width, framebuffer.width);
const u32 old_height = std::exchange(info.height, framebuffer.height);
if (framebuffer.width != old_width || framebuffer.height != old_height) [[unlikely]] {
info.pixels.resize(framebuffer.width * framebuffer.height * 4);
}
CopyPixels(i);
}
}
}
void RendererSoftware::CopyPixels(int i) {
const u32 fb_id = i == 2 ? 1 : 0;
const auto& framebuffer = GPU::g_regs.framebuffer_config[fb_id];
const PAddr framebuffer_addr =
framebuffer.active_fb == 0 ? framebuffer.address_left1 : framebuffer.address_left2;
const s32 bpp = GPU::Regs::BytesPerPixel(framebuffer.color_format);
const u8* framebuffer_data = memory.GetPhysicalPointer(framebuffer_addr);
const s32 stride = framebuffer.stride;
const s32 height = framebuffer.height;
ASSERT(stride * height != 0);
u32 output_offset = 0;
for (u32 y = 0; y < framebuffer.height; y++) {
for (u32 x = 0; x < framebuffer.width; x++) {
const u8* pixel = framebuffer_data + (y * stride + x) * bpp;
const Common::Vec4 color = [&] {
switch (framebuffer.color_format) {
case GPU::Regs::PixelFormat::RGBA8:
return Common::Color::DecodeRGBA8(pixel);
case GPU::Regs::PixelFormat::RGB8:
return Common::Color::DecodeRGB8(pixel);
case GPU::Regs::PixelFormat::RGB565:
return Common::Color::DecodeRGB565(pixel);
case GPU::Regs::PixelFormat::RGB5A1:
return Common::Color::DecodeRGB5A1(pixel);
case GPU::Regs::PixelFormat::RGBA4:
return Common::Color::DecodeRGBA4(pixel);
}
UNREACHABLE();
}();
u8* dest = screen_infos[i].pixels.data() + output_offset;
std::memcpy(dest, color.AsArray(), sizeof(color));
output_offset += sizeof(color);
}
}
}
} // namespace SwRenderer

20
src/video_core/renderer_software/renderer_software.h
View File

@ -11,7 +11,13 @@ namespace Core {
class System;
}
namespace VideoCore {
namespace SwRenderer {
struct ScreenInfo {
u32 width;
u32 height;
std::vector<u8> pixels;
};
class RendererSoftware : public VideoCore::RendererBase {
public:
@ -22,12 +28,22 @@ public:
return rasterizer.get();
}
[[nodiscard]] const ScreenInfo& Screen(VideoCore::ScreenId id) const noexcept {
return screen_infos[static_cast<u32>(id)];
}
void SwapBuffers() override;
void TryPresent(int timeout_ms, bool is_secondary) override {}
void Sync() override {}
private:
void PrepareRenderTarget();
void CopyPixels(int i);
private:
Memory::MemorySystem& memory;
std::unique_ptr<RasterizerSoftware> rasterizer;
std::array<ScreenInfo, 3> screen_infos{};
};
} // namespace VideoCore
} // namespace SwRenderer

248
src/video_core/renderer_software/sw_clipper.cpp
View File

@ -1,196 +1,88 @@
// Copyright 2014 Citra Emulator Project
// Copyright 2023 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <algorithm>
#include <array>
#include <cstddef>
#include <boost/container/static_vector.hpp>
#include "common/bit_field.h"
#include "common/common_types.h"
#include "common/logging/log.h"
#include "common/vector_math.h"
#include "video_core/pica_state.h"
#include "video_core/pica_types.h"
#include "video_core/renderer_software/rasterizer.h"
#include "video_core/regs_texturing.h"
#include "video_core/renderer_software/sw_clipper.h"
#include "video_core/shader/shader.h"
using Pica::Rasterizer::Vertex;
namespace SwRenderer {
namespace Pica::Clipper {
using Pica::TexturingRegs;
struct ClippingEdge {
public:
ClippingEdge(Common::Vec4<float24> coeffs,
Common::Vec4<float24> bias = Common::Vec4<float24>(float24::FromFloat32(0),
float24::FromFloat32(0),
float24::FromFloat32(0),
float24::FromFloat32(0)))
: coeffs(coeffs), bias(bias) {}
bool IsInside(const Vertex& vertex) const {
return Common::Dot(vertex.pos + bias, coeffs) >= float24::FromFloat32(0);
}
bool IsOutSide(const Vertex& vertex) const {
return !IsInside(vertex);
}
Vertex GetIntersection(const Vertex& v0, const Vertex& v1) const {
float24 dp = Common::Dot(v0.pos + bias, coeffs);
float24 dp_prev = Common::Dot(v1.pos + bias, coeffs);
float24 factor = dp_prev / (dp_prev - dp);
return Vertex::Lerp(factor, v0, v1);
}
private:
[[maybe_unused]] float24 pos;
Common::Vec4<float24> coeffs;
Common::Vec4<float24> bias;
};
static void InitScreenCoordinates(Vertex& vtx) {
struct {
float24 halfsize_x;
float24 offset_x;
float24 halfsize_y;
float24 offset_y;
float24 zscale;
float24 offset_z;
} viewport;
const auto& regs = g_state.regs;
viewport.halfsize_x = float24::FromRaw(regs.rasterizer.viewport_size_x);
viewport.halfsize_y = float24::FromRaw(regs.rasterizer.viewport_size_y);
viewport.offset_x = float24::FromFloat32(static_cast<float>(regs.rasterizer.viewport_corner.x));
viewport.offset_y = float24::FromFloat32(static_cast<float>(regs.rasterizer.viewport_corner.y));
float24 inv_w = float24::FromFloat32(1.f) / vtx.pos.w;
vtx.pos.w = inv_w;
vtx.quat *= inv_w;
vtx.color *= inv_w;
vtx.tc0 *= inv_w;
vtx.tc1 *= inv_w;
vtx.tc0_w *= inv_w;
vtx.view *= inv_w;
vtx.tc2 *= inv_w;
vtx.screenpos[0] =
(vtx.pos.x * inv_w + float24::FromFloat32(1.0)) * viewport.halfsize_x + viewport.offset_x;
vtx.screenpos[1] =
(vtx.pos.y * inv_w + float24::FromFloat32(1.0)) * viewport.halfsize_y + viewport.offset_y;
vtx.screenpos[2] = vtx.pos.z * inv_w;
}
void ProcessTriangle(const OutputVertex& v0, const OutputVertex& v1, const OutputVertex& v2) {
using boost::container::static_vector;
// Clipping a planar n-gon against a plane will remove at least 1 vertex and introduces 2 at
// the new edge (or less in degenerate cases). As such, we can say that each clipping plane
// introduces at most 1 new vertex to the polygon. Since we start with a triangle and have a
// fixed 6 clipping planes, the maximum number of vertices of the clipped polygon is 3 + 6 = 9.
static const std::size_t MAX_VERTICES = 9;
static_vector<Vertex, MAX_VERTICES> buffer_a = {v0, v1, v2};
static_vector<Vertex, MAX_VERTICES> buffer_b;
auto FlipQuaternionIfOpposite = [](auto& a, const auto& b) {
if (Common::Dot(a, b) < float24::Zero())
a = a * float24::FromFloat32(-1.0f);
};
// Flip the quaternions if they are opposite to prevent interpolating them over the wrong
// direction.
FlipQuaternionIfOpposite(buffer_a[1].quat, buffer_a[0].quat);
FlipQuaternionIfOpposite(buffer_a[2].quat, buffer_a[0].quat);
auto* output_list = &buffer_a;
auto* input_list = &buffer_b;
// NOTE: We clip against a w=epsilon plane to guarantee that the output has a positive w value.
// TODO: Not sure if this is a valid approach. Also should probably instead use the smallest
// epsilon possible within float24 accuracy.
static const float24 EPSILON = float24::FromFloat32(0.00001f);
static const float24 f0 = float24::FromFloat32(0.0);
static const float24 f1 = float24::FromFloat32(1.0);
static const std::array<ClippingEdge, 7> clipping_edges = {{
{Common::MakeVec(-f1, f0, f0, f1)}, // x = +w
{Common::MakeVec(f1, f0, f0, f1)}, // x = -w
{Common::MakeVec(f0, -f1, f0, f1)}, // y = +w
{Common::MakeVec(f0, f1, f0, f1)}, // y = -w
{Common::MakeVec(f0, f0, -f1, f0)}, // z = 0
{Common::MakeVec(f0, f0, f1, f1)}, // z = -w
{Common::MakeVec(f0, f0, f0, f1),
Common::Vec4<float24>(f0, f0, f0, EPSILON)}, // w = EPSILON
}};
// Simple implementation of the Sutherland-Hodgman clipping algorithm.
// TODO: Make this less inefficient (currently lots of useless buffering overhead happens here)
auto Clip = [&](const ClippingEdge& edge) {
std::swap(input_list, output_list);
output_list->clear();
const Vertex* reference_vertex = &input_list->back();
for (const auto& vertex : *input_list) {
// NOTE: This algorithm changes vertex order in some cases!
if (edge.IsInside(vertex)) {
if (edge.IsOutSide(*reference_vertex)) {
output_list->push_back(edge.GetIntersection(vertex, *reference_vertex));
}
output_list->push_back(vertex);
} else if (edge.IsInside(*reference_vertex)) {
output_list->push_back(edge.GetIntersection(vertex, *reference_vertex));
}
reference_vertex = &vertex;
void FlipQuaternionIfOpposite(Common::Vec4<f24>& a, const Common::Vec4<f24>& b) {
if (Common::Dot(a, b) < f24::Zero()) {
a *= f24::FromFloat32(-1.0f);
}
};
for (auto edge : clipping_edges) {
Clip(edge);
int SignedArea(const Common::Vec2<Fix12P4>& vtx1, const Common::Vec2<Fix12P4>& vtx2,
const Common::Vec2<Fix12P4>& vtx3) {
const auto vec1 = Common::MakeVec(vtx2 - vtx1, 0);
const auto vec2 = Common::MakeVec(vtx3 - vtx1, 0);
// TODO: There is a very small chance this will overflow for sizeof(int) == 4
return Common::Cross(vec1, vec2).z;
};
// Need to have at least a full triangle to continue...
if (output_list->size() < 3)
return;
std::tuple<f24, f24, f24, PAddr> ConvertCubeCoord(f24 u, f24 v, f24 w,
const Pica::TexturingRegs& regs) {
const float abs_u = std::abs(u.ToFloat32());
const float abs_v = std::abs(v.ToFloat32());
const float abs_w = std::abs(w.ToFloat32());
f24 x, y, z;
PAddr addr;
if (abs_u > abs_v && abs_u > abs_w) {
if (u > f24::Zero()) {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::PositiveX);
y = -v;
} else {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::NegativeX);
y = v;
}
x = -w;
z = u;
} else if (abs_v > abs_w) {
if (v > f24::Zero()) {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::PositiveY);
x = u;
} else {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::NegativeY);
x = -u;
}
y = w;
z = v;
} else {
if (w > f24::Zero()) {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::PositiveZ);
y = -v;
} else {
addr = regs.GetCubePhysicalAddress(TexturingRegs::CubeFace::NegativeZ);
y = v;
}
x = u;
z = w;
}
const f24 z_abs = f24::FromFloat32(std::abs(z.ToFloat32()));
const f24 half = f24::FromFloat32(0.5f);
return std::make_tuple(x / z * half + half, y / z * half + half, z_abs, addr);
}
if (g_state.regs.rasterizer.clip_enable) {
ClippingEdge custom_edge{g_state.regs.rasterizer.GetClipCoef()};
Clip(custom_edge);
if (output_list->size() < 3)
return;
}
InitScreenCoordinates((*output_list)[0]);
InitScreenCoordinates((*output_list)[1]);
for (std::size_t i = 0; i < output_list->size() - 2; i++) {
Vertex& vtx0 = (*output_list)[0];
Vertex& vtx1 = (*output_list)[i + 1];
Vertex& vtx2 = (*output_list)[i + 2];
InitScreenCoordinates(vtx2);
LOG_TRACE(
Render_Software,
"Triangle {}/{} at position ({:.3}, {:.3}, {:.3}, {:.3f}), "
"({:.3}, {:.3}, {:.3}, {:.3}), ({:.3}, {:.3}, {:.3}, {:.3}) and "
"screen position ({:.2}, {:.2}, {:.2}), ({:.2}, {:.2}, {:.2}), ({:.2}, {:.2}, {:.2})",
i + 1, output_list->size() - 2, vtx0.pos.x.ToFloat32(), vtx0.pos.y.ToFloat32(),
vtx0.pos.z.ToFloat32(), vtx0.pos.w.ToFloat32(), vtx1.pos.x.ToFloat32(),
vtx1.pos.y.ToFloat32(), vtx1.pos.z.ToFloat32(), vtx1.pos.w.ToFloat32(),
vtx2.pos.x.ToFloat32(), vtx2.pos.y.ToFloat32(), vtx2.pos.z.ToFloat32(),
vtx2.pos.w.ToFloat32(), vtx0.screenpos.x.ToFloat32(), vtx0.screenpos.y.ToFloat32(),
vtx0.screenpos.z.ToFloat32(), vtx1.screenpos.x.ToFloat32(),
vtx1.screenpos.y.ToFloat32(), vtx1.screenpos.z.ToFloat32(),
vtx2.screenpos.x.ToFloat32(), vtx2.screenpos.y.ToFloat32(),
vtx2.screenpos.z.ToFloat32());
Rasterizer::ProcessTriangle(vtx0, vtx1, vtx2);
bool IsRightSideOrFlatBottomEdge(const Common::Vec2<Fix12P4>& vtx,
const Common::Vec2<Fix12P4>& line1,
const Common::Vec2<Fix12P4>& line2) {
if (line1.y == line2.y) {
// Just check if vertex is above us => bottom line parallel to x-axis
return vtx.y < line1.y;
} else {
// Check if vertex is on our left => right side
// TODO: Not sure how likely this is to overflow
const auto svtx = vtx.Cast<s32>();
const auto sline1 = line1.Cast<s32>();
const auto sline2 = line2.Cast<s32>();
return svtx.x <
sline1.x + (sline2.x - sline1.x) * (svtx.y - sline1.y) / (sline2.y - sline1.y);
}
}
} // namespace Pica::Clipper
} // namespace SwRenderer

84
src/video_core/renderer_software/sw_clipper.h
View File

@ -1,19 +1,87 @@
// Copyright 2014 Citra Emulator Project
// Copyright 2023 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
#include "common/common_types.h"
#include "common/vector_math.h"
#include "video_core/pica_types.h"
namespace Pica {
namespace Shader {
struct OutputVertex;
struct TexturingRegs;
}
namespace Clipper {
namespace SwRenderer {
using Shader::OutputVertex;
using Pica::f24;
void ProcessTriangle(const OutputVertex& v0, const OutputVertex& v1, const OutputVertex& v2);
// NOTE: Assuming that rasterizer coordinates are 12.4 fixed-point values
struct Fix12P4 {
Fix12P4() {}
Fix12P4(u16 val) : val(val) {}
} // namespace Clipper
} // namespace Pica
static Fix12P4 FromFloat24(f24 flt) {
// TODO: Rounding here is necessary to prevent garbage pixels at
// triangle borders. Is it that the correct solution, though?
return Fix12P4(static_cast<u16>(round(flt.ToFloat32() * 16.0f)));
}
static u16 FracMask() {
return 0xF;
}
static u16 IntMask() {
return static_cast<u16>(~0xF);
}
operator u16() const {
return val;
}
bool operator<(const Fix12P4& oth) const {
return (u16) * this < (u16)oth;
}
private:
u16 val;
};
struct Viewport {
f24 halfsize_x;
f24 offset_x;
f24 halfsize_y;
f24 offset_y;
f24 zscale;
f24 offset_z;
};
/**
* Flips the quaternions if they are opposite to prevent
* interpolating them over the wrong direction.
*/
void FlipQuaternionIfOpposite(Common::Vec4<f24>& a, const Common::Vec4<f24>& b);
/**
* Calculate signed area of the triangle spanned by the three argument vertices.
* The sign denotes an orientation.
**/
int SignedArea(const Common::Vec2<Fix12P4>& vtx1, const Common::Vec2<Fix12P4>& vtx2,
const Common::Vec2<Fix12P4>& vtx3);
/**
* Convert a 3D vector for cube map coordinates to 2D texture coordinates along with the face name.
**/
std::tuple<f24, f24, f24, PAddr> ConvertCubeCoord(f24 u, f24 v, f24 w,
const Pica::TexturingRegs& regs);
/**
* Triangle filling rules: Pixels on the right-sided edge or on flat bottom edges are not
* drawn. Pixels on any other triangle border are drawn. This is implemented with three bias
* values which are added to the barycentric coordinates w0, w1 and w2, respectively.
* NOTE: These are the PSP filling rules. Not sure if the 3DS uses the same ones...
**/
bool IsRightSideOrFlatBottomEdge(const Common::Vec2<Fix12P4>& vtx,
const Common::Vec2<Fix12P4>& line1,
const Common::Vec2<Fix12P4>& line2);
} // namespace SwRenderer

250
src/video_core/renderer_software/sw_framebuffer.cpp
View File

@ -3,23 +3,46 @@
// Refer to the license.txt file included.
#include <algorithm>
#include "common/assert.h"
#include "common/color.h"
#include "common/common_types.h"
#include "common/logging/log.h"
#include "common/vector_math.h"
#include "core/hw/gpu.h"
#include "core/memory.h"
#include "video_core/pica_state.h"
#include "video_core/pica_types.h"
#include "video_core/regs_framebuffer.h"
#include "video_core/renderer_software/sw_framebuffer.h"
#include "video_core/utils.h"
#include "video_core/video_core.h"
namespace Pica::Rasterizer {
namespace SwRenderer {
void DrawPixel(int x, int y, const Common::Vec4<u8>& color) {
const auto& framebuffer = g_state.regs.framebuffer.framebuffer;
using Pica::f16;
using Pica::FramebufferRegs;
namespace {
/// Decode/Encode for shadow map format. It is similar to D24S8 format,
/// but the depth field is in big-endian.
const Common::Vec2<u32> DecodeD24S8Shadow(const u8* bytes) {
return {static_cast<u32>((bytes[0] << 16) | (bytes[1] << 8) | bytes[2]), bytes[3]};
}
void EncodeD24X8Shadow(u32 depth, u8* bytes) {
bytes[2] = depth & 0xFF;
bytes[1] = (depth >> 8) & 0xFF;
bytes[0] = (depth >> 16) & 0xFF;
}
void EncodeX24S8Shadow(u8 stencil, u8* bytes) {
bytes[3] = stencil;
}
} // Anonymous namespace
Framebuffer::Framebuffer(Memory::MemorySystem& memory_, const Pica::FramebufferRegs& regs_)
: memory{memory_}, regs{regs_} {}
Framebuffer::~Framebuffer() = default;
void Framebuffer::DrawPixel(int x, int y, const Common::Vec4<u8>& color) const {
const auto& framebuffer = regs.framebuffer;
const PAddr addr = framebuffer.GetColorBufferPhysicalAddress();
// Similarly to textures, the render framebuffer is laid out from bottom to top, too.
@ -27,33 +50,29 @@ void DrawPixel(int x, int y, const Common::Vec4<u8>& color) {
y = framebuffer.height - y;
const u32 coarse_y = y & ~7;
u32 bytes_per_pixel =
const u32 bytes_per_pixel =
GPU::Regs::BytesPerPixel(GPU::Regs::PixelFormat(framebuffer.color_format.Value()));
u32 dst_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) +
const u32 dst_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) +
coarse_y * framebuffer.width * bytes_per_pixel;
u8* dst_pixel = VideoCore::g_memory->GetPhysicalPointer(addr) + dst_offset;
u8* depth_buffer = memory.GetPhysicalPointer(addr);
u8* dst_pixel = depth_buffer + dst_offset;
switch (framebuffer.color_format) {
case FramebufferRegs::ColorFormat::RGBA8:
Common::Color::EncodeRGBA8(color, dst_pixel);
break;
case FramebufferRegs::ColorFormat::RGB8:
Common::Color::EncodeRGB8(color, dst_pixel);
break;
case FramebufferRegs::ColorFormat::RGB5A1:
Common::Color::EncodeRGB5A1(color, dst_pixel);
break;
case FramebufferRegs::ColorFormat::RGB565:
Common::Color::EncodeRGB565(color, dst_pixel);
break;
case FramebufferRegs::ColorFormat::RGBA4:
Common::Color::EncodeRGBA4(color, dst_pixel);
break;
default:
LOG_CRITICAL(Render_Software, "Unknown framebuffer color format {:x}",
static_cast<u32>(framebuffer.color_format.Value()));
@ -61,35 +80,31 @@ void DrawPixel(int x, int y, const Common::Vec4<u8>& color) {
}
}
const Common::Vec4<u8> GetPixel(int x, int y) {
const auto& framebuffer = g_state.regs.framebuffer.framebuffer;
const Common::Vec4<u8> Framebuffer::GetPixel(int x, int y) const {
const auto& framebuffer = regs.framebuffer;
const PAddr addr = framebuffer.GetColorBufferPhysicalAddress();
y = framebuffer.height - y;
const u32 coarse_y = y & ~7;
u32 bytes_per_pixel =
const u32 bytes_per_pixel =
GPU::Regs::BytesPerPixel(GPU::Regs::PixelFormat(framebuffer.color_format.Value()));
u32 src_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) +
const u32 src_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) +
coarse_y * framebuffer.width * bytes_per_pixel;
u8* src_pixel = VideoCore::g_memory->GetPhysicalPointer(addr) + src_offset;
const u8* color_buffer = memory.GetPhysicalPointer(addr);
const u8* src_pixel = color_buffer + src_offset;
switch (framebuffer.color_format) {
case FramebufferRegs::ColorFormat::RGBA8:
return Common::Color::DecodeRGBA8(src_pixel);
case FramebufferRegs::ColorFormat::RGB8:
return Common::Color::DecodeRGB8(src_pixel);
case FramebufferRegs::ColorFormat::RGB5A1:
return Common::Color::DecodeRGB5A1(src_pixel);
case FramebufferRegs::ColorFormat::RGB565:
return Common::Color::DecodeRGB565(src_pixel);
case FramebufferRegs::ColorFormat::RGBA4:
return Common::Color::DecodeRGBA4(src_pixel);
default:
LOG_CRITICAL(Render_Software, "Unknown framebuffer color format {:x}",
static_cast<u32>(framebuffer.color_format.Value()));
@ -99,19 +114,19 @@ const Common::Vec4<u8> GetPixel(int x, int y) {
return {0, 0, 0, 0};
}
u32 GetDepth(int x, int y) {
const auto& framebuffer = g_state.regs.framebuffer.framebuffer;
u32 Framebuffer::GetDepth(int x, int y) const {
const auto& framebuffer = regs.framebuffer;
const PAddr addr = framebuffer.GetDepthBufferPhysicalAddress();
u8* depth_buffer = VideoCore::g_memory->GetPhysicalPointer(addr);
y = framebuffer.height - y;
const u32 coarse_y = y & ~7;
u32 bytes_per_pixel = FramebufferRegs::BytesPerDepthPixel(framebuffer.depth_format);
u32 stride = framebuffer.width * bytes_per_pixel;
const u32 bytes_per_pixel = FramebufferRegs::BytesPerDepthPixel(framebuffer.depth_format);
const u32 stride = framebuffer.width * bytes_per_pixel;
u32 src_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) + coarse_y * stride;
u8* src_pixel = depth_buffer + src_offset;
const u32 src_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) + coarse_y * stride;
const u8* depth_buffer = memory.GetPhysicalPointer(addr);
const u8* src_pixel = depth_buffer + src_offset;
switch (framebuffer.depth_format) {
case FramebufferRegs::DepthFormat::D16:
@ -128,24 +143,23 @@ u32 GetDepth(int x, int y) {
}
}
u8 GetStencil(int x, int y) {
const auto& framebuffer = g_state.regs.framebuffer.framebuffer;
u8 Framebuffer::GetStencil(int x, int y) const {
const auto& framebuffer = regs.framebuffer;
const PAddr addr = framebuffer.GetDepthBufferPhysicalAddress();
u8* depth_buffer = VideoCore::g_memory->GetPhysicalPointer(addr);
y = framebuffer.height - y;
const u32 coarse_y = y & ~7;
u32 bytes_per_pixel = Pica::FramebufferRegs::BytesPerDepthPixel(framebuffer.depth_format);
u32 stride = framebuffer.width * bytes_per_pixel;
const u32 bytes_per_pixel = Pica::FramebufferRegs::BytesPerDepthPixel(framebuffer.depth_format);
const u32 stride = framebuffer.width * bytes_per_pixel;
u32 src_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) + coarse_y * stride;
u8* src_pixel = depth_buffer + src_offset;
const u32 src_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) + coarse_y * stride;
const u8* depth_buffer = memory.GetPhysicalPointer(addr);
const u8* src_pixel = depth_buffer + src_offset;
switch (framebuffer.depth_format) {
case FramebufferRegs::DepthFormat::D24S8:
return Common::Color::DecodeD24S8(src_pixel).y;
default:
LOG_WARNING(
HW_GPU,
@ -155,33 +169,30 @@ u8 GetStencil(int x, int y) {
}
}
void SetDepth(int x, int y, u32 value) {
const auto& framebuffer = g_state.regs.framebuffer.framebuffer;
void Framebuffer::SetDepth(int x, int y, u32 value) const {
const auto& framebuffer = regs.framebuffer;
const PAddr addr = framebuffer.GetDepthBufferPhysicalAddress();
u8* depth_buffer = VideoCore::g_memory->GetPhysicalPointer(addr);
y = framebuffer.height - y;
const u32 coarse_y = y & ~7;
u32 bytes_per_pixel = FramebufferRegs::BytesPerDepthPixel(framebuffer.depth_format);
u32 stride = framebuffer.width * bytes_per_pixel;
const u32 bytes_per_pixel = FramebufferRegs::BytesPerDepthPixel(framebuffer.depth_format);
const u32 stride = framebuffer.width * bytes_per_pixel;
u32 dst_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) + coarse_y * stride;
const u32 dst_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) + coarse_y * stride;
u8* depth_buffer = memory.GetPhysicalPointer(addr);
u8* dst_pixel = depth_buffer + dst_offset;
switch (framebuffer.depth_format) {
case FramebufferRegs::DepthFormat::D16:
Common::Color::EncodeD16(value, dst_pixel);
break;
case FramebufferRegs::DepthFormat::D24:
Common::Color::EncodeD24(value, dst_pixel);
break;
case FramebufferRegs::DepthFormat::D24S8:
Common::Color::EncodeD24X8(value, dst_pixel);
break;
default:
LOG_CRITICAL(HW_GPU, "Unimplemented depth format {}",
static_cast<u32>(framebuffer.depth_format.Value()));
@ -190,18 +201,18 @@ void SetDepth(int x, int y, u32 value) {
}
}
void SetStencil(int x, int y, u8 value) {
const auto& framebuffer = g_state.regs.framebuffer.framebuffer;
void Framebuffer::SetStencil(int x, int y, u8 value) const {
const auto& framebuffer = regs.framebuffer;
const PAddr addr = framebuffer.GetDepthBufferPhysicalAddress();
u8* depth_buffer = VideoCore::g_memory->GetPhysicalPointer(addr);
y = framebuffer.height - y;
const u32 coarse_y = y & ~7;
u32 bytes_per_pixel = Pica::FramebufferRegs::BytesPerDepthPixel(framebuffer.depth_format);
u32 stride = framebuffer.width * bytes_per_pixel;
const u32 bytes_per_pixel = Pica::FramebufferRegs::BytesPerDepthPixel(framebuffer.depth_format);
const u32 stride = framebuffer.width * bytes_per_pixel;
u32 dst_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) + coarse_y * stride;
const u32 dst_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) + coarse_y * stride;
u8* depth_buffer = memory.GetPhysicalPointer(addr);
u8* dst_pixel = depth_buffer + dst_offset;
switch (framebuffer.depth_format) {
@ -209,11 +220,9 @@ void SetStencil(int x, int y, u8 value) {
case Pica::FramebufferRegs::DepthFormat::D24:
// Nothing to do
break;
case Pica::FramebufferRegs::DepthFormat::D24S8:
Common::Color::EncodeX24S8(value, dst_pixel);
break;
default:
LOG_CRITICAL(HW_GPU, "Unimplemented depth format {}",
static_cast<u32>(framebuffer.depth_format.Value()));
@ -222,36 +231,65 @@ void SetStencil(int x, int y, u8 value) {
}
}
void Framebuffer::DrawShadowMapPixel(int x, int y, u32 depth, u8 stencil) const {
const auto& framebuffer = regs.framebuffer;
const auto& shadow = regs.shadow;
const PAddr addr = framebuffer.GetColorBufferPhysicalAddress();
y = framebuffer.height - y;
const u32 coarse_y = y & ~7;
u32 bytes_per_pixel = 4;
u32 dst_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) +
coarse_y * framebuffer.width * bytes_per_pixel;
u8* shadow_buffer = memory.GetPhysicalPointer(addr);
u8* dst_pixel = shadow_buffer + dst_offset;
const auto ref = DecodeD24S8Shadow(dst_pixel);
const u32 ref_z = ref.x;
const u32 ref_s = ref.y;
if (depth >= ref_z) {
return;
}
if (stencil == 0) {
EncodeD24X8Shadow(depth, dst_pixel);
} else {
const f16 constant = f16::FromRaw(shadow.constant);
const f16 linear = f16::FromRaw(shadow.linear);
const f16 x_ = f16::FromFloat32(static_cast<float>(depth) / ref_z);
const f16 stencil_new = f16::FromFloat32(stencil) / (constant + linear * x_);
stencil = static_cast<u8>(std::clamp(stencil_new.ToFloat32(), 0.0f, 255.0f));
if (stencil < ref_s) {
EncodeX24S8Shadow(stencil, dst_pixel);
}
}
}
u8 PerformStencilAction(FramebufferRegs::StencilAction action, u8 old_stencil, u8 ref) {
switch (action) {
case FramebufferRegs::StencilAction::Keep:
return old_stencil;
case FramebufferRegs::StencilAction::Zero:
return 0;
case FramebufferRegs::StencilAction::Replace:
return ref;
case FramebufferRegs::StencilAction::Increment:
// Saturated increment
return std::min<u8>(old_stencil, 254) + 1;
case FramebufferRegs::StencilAction::Decrement:
// Saturated decrement
return std::max<u8>(old_stencil, 1) - 1;
case FramebufferRegs::StencilAction::Invert:
return ~old_stencil;
case FramebufferRegs::StencilAction::IncrementWrap:
return old_stencil + 1;
case FramebufferRegs::StencilAction::DecrementWrap:
return old_stencil - 1;
default:
LOG_CRITICAL(HW_GPU, "Unknown stencil action {:x}", (int)action);
LOG_CRITICAL(HW_GPU, "Unknown stencil action {:x}", static_cast<int>(action));
UNIMPLEMENTED();
return 0;
}
@ -262,24 +300,21 @@ Common::Vec4<u8> EvaluateBlendEquation(const Common::Vec4<u8>& src,
const Common::Vec4<u8>& dest,
const Common::Vec4<u8>& destfactor,
FramebufferRegs::BlendEquation equation) {
Common::Vec4<int> result;
Common::Vec4i result;
auto src_result = (src * srcfactor).Cast<int>();
auto dst_result = (dest * destfactor).Cast<int>();
const auto src_result = (src * srcfactor).Cast<s32>();
const auto dst_result = (dest * destfactor).Cast<s32>();
switch (equation) {
case FramebufferRegs::BlendEquation::Add:
result = (src_result + dst_result) / 255;
break;
case FramebufferRegs::BlendEquation::Subtract:
result = (src_result - dst_result) / 255;
break;
case FramebufferRegs::BlendEquation::ReverseSubtract:
result = (dst_result - src_result) / 255;
break;
// TODO: How do these two actually work? OpenGL doesn't include the blend factors in the
// min/max computations, but is this what the 3DS actually does?
case FramebufferRegs::BlendEquation::Min:
@ -288,14 +323,12 @@ Common::Vec4<u8> EvaluateBlendEquation(const Common::Vec4<u8>& src,
result.b() = std::min(src.b(), dest.b());
result.a() = std::min(src.a(), dest.a());
break;
case FramebufferRegs::BlendEquation::Max:
result.r() = std::max(src.r(), dest.r());
result.g() = std::max(src.g(), dest.g());
result.b() = std::max(src.b(), dest.b());
result.a() = std::max(src.a(), dest.a());
break;
default:
LOG_CRITICAL(HW_GPU, "Unknown RGB blend equation 0x{:x}", equation);
UNIMPLEMENTED();
@ -309,103 +342,38 @@ u8 LogicOp(u8 src, u8 dest, FramebufferRegs::LogicOp op) {
switch (op) {
case FramebufferRegs::LogicOp::Clear:
return 0;
case FramebufferRegs::LogicOp::And:
return src & dest;
case FramebufferRegs::LogicOp::AndReverse:
return src & ~dest;
case FramebufferRegs::LogicOp::Copy:
return src;
case FramebufferRegs::LogicOp::Set:
return 255;
case FramebufferRegs::LogicOp::CopyInverted:
return ~src;
case FramebufferRegs::LogicOp::NoOp:
return dest;
case FramebufferRegs::LogicOp::Invert:
return ~dest;
case FramebufferRegs::LogicOp::Nand:
return ~(src & dest);
case FramebufferRegs::LogicOp::Or:
return src | dest;
case FramebufferRegs::LogicOp::Nor:
return ~(src | dest);
case FramebufferRegs::LogicOp::Xor:
return src ^ dest;
case FramebufferRegs::LogicOp::Equiv:
return ~(src ^ dest);
case FramebufferRegs::LogicOp::AndInverted:
return ~src & dest;
case FramebufferRegs::LogicOp::OrReverse:
return src | ~dest;
case FramebufferRegs::LogicOp::OrInverted:
return ~src | dest;
}
UNREACHABLE();
};
// Decode/Encode for shadow map format. It is similar to D24S8 format, but the depth field is in
// big-endian
static const Common::Vec2<u32> DecodeD24S8Shadow(const u8* bytes) {
return {static_cast<u32>((bytes[0] << 16) | (bytes[1] << 8) | bytes[2]), bytes[3]};
}
static void EncodeD24X8Shadow(u32 depth, u8* bytes) {
bytes[2] = depth & 0xFF;
bytes[1] = (depth >> 8) & 0xFF;
bytes[0] = (depth >> 16) & 0xFF;
}
static void EncodeX24S8Shadow(u8 stencil, u8* bytes) {
bytes[3] = stencil;
}
void DrawShadowMapPixel(int x, int y, u32 depth, u8 stencil) {
const auto& framebuffer = g_state.regs.framebuffer.framebuffer;
const auto& shadow = g_state.regs.framebuffer.shadow;
const PAddr addr = framebuffer.GetColorBufferPhysicalAddress();
y = framebuffer.height - y;
const u32 coarse_y = y & ~7;
u32 bytes_per_pixel = 4;
u32 dst_offset = VideoCore::GetMortonOffset(x, y, bytes_per_pixel) +
coarse_y * framebuffer.width * bytes_per_pixel;
u8* dst_pixel = VideoCore::g_memory->GetPhysicalPointer(addr) + dst_offset;
auto ref = DecodeD24S8Shadow(dst_pixel);
u32 ref_z = ref.x;
u32 ref_s = ref.y;
if (depth < ref_z) {
if (stencil == 0) {
EncodeD24X8Shadow(depth, dst_pixel);
} else {
float16 constant = float16::FromRaw(shadow.constant);
float16 linear = float16::FromRaw(shadow.linear);
float16 x_ = float16::FromFloat32(static_cast<float>(depth) / ref_z);
float16 stencil_new = float16::FromFloat32(stencil) / (constant + linear * x_);
stencil = static_cast<u8>(std::clamp(stencil_new.ToFloat32(), 0.0f, 255.0f));
if (stencil < ref_s)
EncodeX24S8Shadow(stencil, dst_pixel);
}
}
}
} // namespace Pica::Rasterizer
} // namespace SwRenderer

57
src/video_core/renderer_software/sw_framebuffer.h
View File

@ -8,24 +8,55 @@
#include "common/vector_math.h"
#include "video_core/regs_framebuffer.h"
namespace Pica::Rasterizer {
namespace Memory {
class MemorySystem;
}
void DrawPixel(int x, int y, const Common::Vec4<u8>& color);
const Common::Vec4<u8> GetPixel(int x, int y);
u32 GetDepth(int x, int y);
u8 GetStencil(int x, int y);
void SetDepth(int x, int y, u32 value);
void SetStencil(int x, int y, u8 value);
u8 PerformStencilAction(FramebufferRegs::StencilAction action, u8 old_stencil, u8 ref);
namespace Pica {
struct FramebufferRegs;
}
namespace SwRenderer {
class Framebuffer {
public:
explicit Framebuffer(Memory::MemorySystem& memory, const Pica::FramebufferRegs& framebuffer);
~Framebuffer();
/// Draws a pixel at the specified coordinates.
void DrawPixel(int x, int y, const Common::Vec4<u8>& color) const;
/// Returns the current color at the specified coordinates.
[[nodiscard]] const Common::Vec4<u8> GetPixel(int x, int y) const;
/// Returns the depth value at the specified coordinates.
[[nodiscard]] u32 GetDepth(int x, int y) const;
/// Returns the stencil value at the specified coordinates.
[[nodiscard]] u8 GetStencil(int x, int y) const;
/// Stores the provided depth value at the specified coordinates.
void SetDepth(int x, int y, u32 value) const;
/// Stores the provided stencil value at the specified coordinates.
void SetStencil(int x, int y, u8 value) const;
/// Draws a pixel to the shadow buffer.
void DrawShadowMapPixel(int x, int y, u32 depth, u8 stencil) const;
private:
Memory::MemorySystem& memory;
const Pica::FramebufferRegs& regs;
};
u8 PerformStencilAction(Pica::FramebufferRegs::StencilAction action, u8 old_stencil, u8 ref);
Common::Vec4<u8> EvaluateBlendEquation(const Common::Vec4<u8>& src,
const Common::Vec4<u8>& srcfactor,
const Common::Vec4<u8>& dest,
const Common::Vec4<u8>& destfactor,
FramebufferRegs::BlendEquation equation);
Pica::FramebufferRegs::BlendEquation equation);
u8 LogicOp(u8 src, u8 dest, FramebufferRegs::LogicOp op);
u8 LogicOp(u8 src, u8 dest, Pica::FramebufferRegs::LogicOp op);
void DrawShadowMapPixel(int x, int y, u32 depth, u8 stencil);
} // namespace Pica::Rasterizer
} // namespace SwRenderer

141
src/video_core/renderer_software/sw_lighting.cpp
View File

@ -5,7 +5,10 @@
#include <algorithm>
#include "video_core/renderer_software/sw_lighting.h"
namespace Pica {
namespace SwRenderer {
using Pica::f16;
using Pica::LightingRegs;
static float LookupLightingLut(const Pica::State::Lighting& lighting, std::size_t lut_index,
u8 index, float delta) {
@ -14,18 +17,18 @@ static float LookupLightingLut(const Pica::State::Lighting& lighting, std::size_
const auto& lut = lighting.luts[lut_index][index];
float lut_value = lut.ToFloat();
float lut_diff = lut.DiffToFloat();
const float lut_value = lut.ToFloat();
const float lut_diff = lut.DiffToFloat();
return lut_value + lut_diff * delta;
}
std::tuple<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
std::pair<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
const Pica::LightingRegs& lighting, const Pica::State::Lighting& lighting_state,
const Common::Quaternion<float>& normquat, const Common::Vec3<float>& view,
const Common::Vec4<u8> (&texture_color)[4]) {
const Common::Quaternion<f32>& normquat, const Common::Vec3f& view,
std::span<const Common::Vec4<u8>, 4> texture_color) {
Common::Vec4<float> shadow;
Common::Vec4f shadow;
if (lighting.config0.enable_shadow) {
shadow = texture_color[lighting.config0.shadow_selector].Cast<float>() / 255.0f;
if (lighting.config0.shadow_invert) {
@ -35,16 +38,16 @@ std::tuple<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
shadow = Common::MakeVec(1.0f, 1.0f, 1.0f, 1.0f);
}
Common::Vec3<float> surface_normal{};
Common::Vec3<float> surface_tangent{};
Common::Vec3f surface_normal{};
Common::Vec3f surface_tangent{};
if (lighting.config0.bump_mode != LightingRegs::LightingBumpMode::None) {
Common::Vec3<float> perturbation =
Common::Vec3f perturbation =
texture_color[lighting.config0.bump_selector].xyz().Cast<float>() / 127.5f -
Common::MakeVec(1.0f, 1.0f, 1.0f);
if (lighting.config0.bump_mode == LightingRegs::LightingBumpMode::NormalMap) {
if (!lighting.config0.disable_bump_renorm) {
const float z_square = 1 - perturbation.xy().Length2();
const f32 z_square = 1 - perturbation.xy().Length2();
perturbation.z = std::sqrt(std::max(z_square, 0.0f));
}
surface_normal = perturbation;
@ -65,66 +68,64 @@ std::tuple<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
auto normal = Common::QuaternionRotate(normquat, surface_normal);
auto tangent = Common::QuaternionRotate(normquat, surface_tangent);
Common::Vec4<float> diffuse_sum = {0.0f, 0.0f, 0.0f, 1.0f};
Common::Vec4<float> specular_sum = {0.0f, 0.0f, 0.0f, 1.0f};
Common::Vec4f diffuse_sum = {0.0f, 0.0f, 0.0f, 1.0f};
Common::Vec4f specular_sum = {0.0f, 0.0f, 0.0f, 1.0f};
for (unsigned light_index = 0; light_index <= lighting.max_light_index; ++light_index) {
unsigned num = lighting.light_enable.GetNum(light_index);
for (u32 light_index = 0; light_index <= lighting.max_light_index; ++light_index) {
u32 num = lighting.light_enable.GetNum(light_index);
const auto& light_config = lighting.light[num];
Common::Vec3<float> refl_value = {};
Common::Vec3<float> position = {float16::FromRaw(light_config.x).ToFloat32(),
float16::FromRaw(light_config.y).ToFloat32(),
float16::FromRaw(light_config.z).ToFloat32()};
Common::Vec3<float> light_vector;
const Common::Vec3f position = {f16::FromRaw(light_config.x).ToFloat32(),
f16::FromRaw(light_config.y).ToFloat32(),
f16::FromRaw(light_config.z).ToFloat32()};
Common::Vec3f refl_value{};
Common::Vec3f light_vector{};
if (light_config.config.directional)
if (light_config.config.directional) {
light_vector = position;
else
} else {
light_vector = position + view;
}
[[maybe_unused]] float length = light_vector.Normalize();
[[maybe_unused]] const f32 length = light_vector.Normalize();
Common::Vec3<float> norm_view = view.Normalized();
Common::Vec3<float> half_vector = norm_view + light_vector;
Common::Vec3f norm_view = view.Normalized();
Common::Vec3f half_vector = norm_view + light_vector;
float dist_atten = 1.0f;
f32 dist_atten = 1.0f;
if (!lighting.IsDistAttenDisabled(num)) {
float scale = Pica::float20::FromRaw(light_config.dist_atten_scale).ToFloat32();
float bias = Pica::float20::FromRaw(light_config.dist_atten_bias).ToFloat32();
std::size_t lut =
const f32 scale = Pica::f20::FromRaw(light_config.dist_atten_scale).ToFloat32();
const f32 bias = Pica::f20::FromRaw(light_config.dist_atten_bias).ToFloat32();
const std::size_t lut =
static_cast<std::size_t>(LightingRegs::LightingSampler::DistanceAttenuation) + num;
float sample_loc = std::clamp(scale * length + bias, 0.0f, 1.0f);
const f32 sample_loc = std::clamp(scale * length + bias, 0.0f, 1.0f);
u8 lutindex =
const u8 lutindex =
static_cast<u8>(std::clamp(std::floor(sample_loc * 256.0f), 0.0f, 255.0f));
float delta = sample_loc * 256 - lutindex;
const f32 delta = sample_loc * 256 - lutindex;
dist_atten = LookupLightingLut(lighting_state, lut, lutindex, delta);
}
auto GetLutValue = [&](LightingRegs::LightingLutInput input, bool abs,
auto get_lut_value = [&](LightingRegs::LightingLutInput input, bool abs,
LightingRegs::LightingScale scale_enum,
LightingRegs::LightingSampler sampler) {
float result = 0.0f;
f32 result = 0.0f;
switch (input) {
case LightingRegs::LightingLutInput::NH:
result = Common::Dot(normal, half_vector.Normalized());
break;
case LightingRegs::LightingLutInput::VH:
result = Common::Dot(norm_view, half_vector.Normalized());
break;
case LightingRegs::LightingLutInput::NV:
result = Common::Dot(normal, norm_view);
break;
case LightingRegs::LightingLutInput::LN:
result = Common::Dot(light_vector, normal);
break;
case LightingRegs::LightingLutInput::SP: {
Common::Vec3<s32> spot_dir{light_config.spot_x.Value(), light_config.spot_y.Value(),
light_config.spot_z.Value()};
@ -133,8 +134,8 @@ std::tuple<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
}
case LightingRegs::LightingLutInput::CP:
if (lighting.config0.config == LightingRegs::LightingConfig::Config7) {
const Common::Vec3<float> norm_half_vector = half_vector.Normalized();
const Common::Vec3<float> half_vector_proj =
const Common::Vec3f norm_half_vector = half_vector.Normalized();
const Common::Vec3f half_vector_proj =
norm_half_vector - normal * Common::Dot(normal, norm_half_vector);
result = Common::Dot(half_vector_proj, tangent);
} else {
@ -148,57 +149,59 @@ std::tuple<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
}
u8 index;
float delta;
f32 delta;
if (abs) {
if (light_config.config.two_sided_diffuse)
if (light_config.config.two_sided_diffuse) {
result = std::abs(result);
else
} else {
result = std::max(result, 0.0f);
}
float flr = std::floor(result * 256.0f);
const f32 flr = std::floor(result * 256.0f);
index = static_cast<u8>(std::clamp(flr, 0.0f, 255.0f));
delta = result * 256 - index;
} else {
float flr = std::floor(result * 128.0f);
s8 signed_index = static_cast<s8>(std::clamp(flr, -128.0f, 127.0f));
const f32 flr = std::floor(result * 128.0f);
const s8 signed_index = static_cast<s8>(std::clamp(flr, -128.0f, 127.0f));
delta = result * 128.0f - signed_index;
index = static_cast<u8>(signed_index);
}
float scale = lighting.lut_scale.GetScale(scale_enum);
const f32 scale = lighting.lut_scale.GetScale(scale_enum);
return scale * LookupLightingLut(lighting_state, static_cast<std::size_t>(sampler),
index, delta);
};
// If enabled, compute spot light attenuation value
float spot_atten = 1.0f;
f32 spot_atten = 1.0f;
if (!lighting.IsSpotAttenDisabled(num) &&
LightingRegs::IsLightingSamplerSupported(
lighting.config0.config, LightingRegs::LightingSampler::SpotlightAttenuation)) {
auto lut = LightingRegs::SpotlightAttenuationSampler(num);
spot_atten = GetLutValue(lighting.lut_input.sp, lighting.abs_lut_input.disable_sp == 0,
spot_atten =
get_lut_value(lighting.lut_input.sp, lighting.abs_lut_input.disable_sp == 0,
lighting.lut_scale.sp, lut);
}
// Specular 0 component
float d0_lut_value = 1.0f;
f32 d0_lut_value = 1.0f;
if (lighting.config1.disable_lut_d0 == 0 &&
LightingRegs::IsLightingSamplerSupported(
lighting.config0.config, LightingRegs::LightingSampler::Distribution0)) {
d0_lut_value =
GetLutValue(lighting.lut_input.d0, lighting.abs_lut_input.disable_d0 == 0,
get_lut_value(lighting.lut_input.d0, lighting.abs_lut_input.disable_d0 == 0,
lighting.lut_scale.d0, LightingRegs::LightingSampler::Distribution0);
}
Common::Vec3<float> specular_0 = d0_lut_value * light_config.specular_0.ToVec3f();
Common::Vec3f specular_0 = d0_lut_value * light_config.specular_0.ToVec3f();
// If enabled, lookup ReflectRed value, otherwise, 1.0 is used
if (lighting.config1.disable_lut_rr == 0 &&
LightingRegs::IsLightingSamplerSupported(lighting.config0.config,
LightingRegs::LightingSampler::ReflectRed)) {
refl_value.x =
GetLutValue(lighting.lut_input.rr, lighting.abs_lut_input.disable_rr == 0,
get_lut_value(lighting.lut_input.rr, lighting.abs_lut_input.disable_rr == 0,
lighting.lut_scale.rr, LightingRegs::LightingSampler::ReflectRed);
} else {
refl_value.x = 1.0f;
@ -209,7 +212,7 @@ std::tuple<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
LightingRegs::IsLightingSamplerSupported(lighting.config0.config,
LightingRegs::LightingSampler::ReflectGreen)) {
refl_value.y =
GetLutValue(lighting.lut_input.rg, lighting.abs_lut_input.disable_rg == 0,
get_lut_value(lighting.lut_input.rg, lighting.abs_lut_input.disable_rg == 0,
lighting.lut_scale.rg, LightingRegs::LightingSampler::ReflectGreen);
} else {
refl_value.y = refl_value.x;
@ -220,24 +223,23 @@ std::tuple<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
LightingRegs::IsLightingSamplerSupported(lighting.config0.config,
LightingRegs::LightingSampler::ReflectBlue)) {
refl_value.z =
GetLutValue(lighting.lut_input.rb, lighting.abs_lut_input.disable_rb == 0,
get_lut_value(lighting.lut_input.rb, lighting.abs_lut_input.disable_rb == 0,
lighting.lut_scale.rb, LightingRegs::LightingSampler::ReflectBlue);
} else {
refl_value.z = refl_value.x;
}
// Specular 1 component
float d1_lut_value = 1.0f;
f32 d1_lut_value = 1.0f;
if (lighting.config1.disable_lut_d1 == 0 &&
LightingRegs::IsLightingSamplerSupported(
lighting.config0.config, LightingRegs::LightingSampler::Distribution1)) {
d1_lut_value =
GetLutValue(lighting.lut_input.d1, lighting.abs_lut_input.disable_d1 == 0,
get_lut_value(lighting.lut_input.d1, lighting.abs_lut_input.disable_d1 == 0,
lighting.lut_scale.d1, LightingRegs::LightingSampler::Distribution1);
}
Common::Vec3<float> specular_1 =
d1_lut_value * refl_value * light_config.specular_1.ToVec3f();
Common::Vec3f specular_1 = d1_lut_value * refl_value * light_config.specular_1.ToVec3f();
// Fresnel
// Note: only the last entry in the light slots applies the Fresnel factor
@ -245,8 +247,8 @@ std::tuple<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
LightingRegs::IsLightingSamplerSupported(lighting.config0.config,
LightingRegs::LightingSampler::Fresnel)) {
float lut_value =
GetLutValue(lighting.lut_input.fr, lighting.abs_lut_input.disable_fr == 0,
const f32 lut_value =
get_lut_value(lighting.lut_input.fr, lighting.abs_lut_input.disable_fr == 0,
lighting.lut_scale.fr, LightingRegs::LightingSampler::Fresnel);
// Enabled for diffuse lighting alpha component
@ -261,18 +263,19 @@ std::tuple<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
}
auto dot_product = Common::Dot(light_vector, normal);
if (light_config.config.two_sided_diffuse)
if (light_config.config.two_sided_diffuse) {
dot_product = std::abs(dot_product);
else
} else {
dot_product = std::max(dot_product, 0.0f);
}
float clamp_highlights = 1.0f;
f32 clamp_highlights = 1.0f;
if (lighting.config0.clamp_highlights) {
clamp_highlights = dot_product == 0.0f ? 0.0f : 1.0f;
}
if (light_config.config.geometric_factor_0 || light_config.config.geometric_factor_1) {
float geo_factor = half_vector.Length2();
f32 geo_factor = half_vector.Length2();
geo_factor = geo_factor == 0.0f ? 0.0f : std::min(dot_product / geo_factor, 1.0f);
if (light_config.config.geometric_factor_0) {
specular_0 *= geo_factor;
@ -315,17 +318,17 @@ std::tuple<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
diffuse_sum += Common::MakeVec(lighting.global_ambient.ToVec3f(), 0.0f);
auto diffuse = Common::MakeVec<float>(std::clamp(diffuse_sum.x, 0.0f, 1.0f) * 255,
const auto diffuse = Common::MakeVec(std::clamp(diffuse_sum.x, 0.0f, 1.0f) * 255,
std::clamp(diffuse_sum.y, 0.0f, 1.0f) * 255,
std::clamp(diffuse_sum.z, 0.0f, 1.0f) * 255,
std::clamp(diffuse_sum.w, 0.0f, 1.0f) * 255)
.Cast<u8>();
auto specular = Common::MakeVec<float>(std::clamp(specular_sum.x, 0.0f, 1.0f) * 255,
const auto specular = Common::MakeVec(std::clamp(specular_sum.x, 0.0f, 1.0f) * 255,
std::clamp(specular_sum.y, 0.0f, 1.0f) * 255,
std::clamp(specular_sum.z, 0.0f, 1.0f) * 255,
std::clamp(specular_sum.w, 0.0f, 1.0f) * 255)
.Cast<u8>();
return std::make_tuple(diffuse, specular);
return std::make_pair(diffuse, specular);
}
} // namespace Pica
} // namespace SwRenderer

14
src/video_core/renderer_software/sw_lighting.h
View File

@ -4,16 +4,18 @@
#pragma once
#include <tuple>
#include <span>
#include <utility>
#include "common/quaternion.h"
#include "common/vector_math.h"
#include "video_core/pica_state.h"
namespace Pica {
namespace SwRenderer {
std::tuple<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
std::pair<Common::Vec4<u8>, Common::Vec4<u8>> ComputeFragmentsColors(
const Pica::LightingRegs& lighting, const Pica::State::Lighting& lighting_state,
const Common::Quaternion<float>& normquat, const Common::Vec3<float>& view,
const Common::Vec4<u8> (&texture_color)[4]);
const Common::Quaternion<f32>& normquat, const Common::Vec3f& view,
std::span<const Common::Vec4<u8>, 4> texture_color);
} // namespace Pica
} // namespace SwRenderer

60
src/video_core/renderer_software/sw_proctex.cpp
View File

@ -4,17 +4,18 @@
#include <array>
#include <cmath>
#include "common/math_util.h"
#include "video_core/renderer_software/sw_proctex.h"
namespace Pica::Rasterizer {
namespace SwRenderer {
using ProcTexClamp = TexturingRegs::ProcTexClamp;
using ProcTexShift = TexturingRegs::ProcTexShift;
using ProcTexCombiner = TexturingRegs::ProcTexCombiner;
using ProcTexFilter = TexturingRegs::ProcTexFilter;
namespace {
using ProcTexClamp = Pica::TexturingRegs::ProcTexClamp;
using ProcTexShift = Pica::TexturingRegs::ProcTexShift;
using ProcTexCombiner = Pica::TexturingRegs::ProcTexCombiner;
using ProcTexFilter = Pica::TexturingRegs::ProcTexFilter;
using Pica::f16;
static float LookupLUT(const std::array<State::ProcTex::ValueEntry, 128>& lut, float coord) {
float LookupLUT(const std::array<Pica::State::ProcTex::ValueEntry, 128>& lut, float coord) {
// For NoiseLUT/ColorMap/AlphaMap, coord=0.0 is lut[0], coord=127.0/128.0 is lut[127] and
// coord=1.0 is lut[127]+lut_diff[127]. For other indices, the result is interpolated using
// value entries and difference entries.
@ -26,13 +27,13 @@ static float LookupLUT(const std::array<State::ProcTex::ValueEntry, 128>& lut, f
// These function are used to generate random noise for procedural texture. Their results are
// verified against real hardware, but it's not known if the algorithm is the same as hardware.
static unsigned int NoiseRand1D(unsigned int v) {
unsigned int NoiseRand1D(unsigned int v) {
static constexpr std::array<unsigned int, 16> table{
{0, 4, 10, 8, 4, 9, 7, 12, 5, 15, 13, 14, 11, 15, 2, 11}};
return ((v % 9 + 2) * 3 & 0xF) ^ table[(v / 9) & 0xF];
}
static float NoiseRand2D(unsigned int x, unsigned int y) {
float NoiseRand2D(unsigned int x, unsigned int y) {
static constexpr std::array<unsigned int, 16> table{
{10, 2, 15, 8, 0, 7, 4, 5, 5, 13, 2, 6, 13, 9, 3, 14}};
unsigned int u2 = NoiseRand1D(x);
@ -45,11 +46,12 @@ static float NoiseRand2D(unsigned int x, unsigned int y) {
return -1.0f + v2 * 2.0f / 15.0f;
}
static float NoiseCoef(float u, float v, const TexturingRegs& regs, const State::ProcTex& state) {
const float freq_u = float16::FromRaw(regs.proctex_noise_frequency.u).ToFloat32();
const float freq_v = float16::FromRaw(regs.proctex_noise_frequency.v).ToFloat32();
const float phase_u = float16::FromRaw(regs.proctex_noise_u.phase).ToFloat32();
const float phase_v = float16::FromRaw(regs.proctex_noise_v.phase).ToFloat32();
float NoiseCoef(float u, float v, const Pica::TexturingRegs& regs,
const Pica::State::ProcTex& state) {
const float freq_u = f16::FromRaw(regs.proctex_noise_frequency.u).ToFloat32();
const float freq_v = f16::FromRaw(regs.proctex_noise_frequency.v).ToFloat32();
const float phase_u = f16::FromRaw(regs.proctex_noise_u.phase).ToFloat32();
const float phase_v = f16::FromRaw(regs.proctex_noise_v.phase).ToFloat32();
const float x = 9 * freq_u * std::abs(u + phase_u);
const float y = 9 * freq_v * std::abs(v + phase_v);
const int x_int = static_cast<int>(x);
@ -66,7 +68,7 @@ static float NoiseCoef(float u, float v, const TexturingRegs& regs, const State:
return Common::BilinearInterp(g0, g1, g2, g3, x_noise, y_noise);
}
static float GetShiftOffset(float v, ProcTexShift mode, ProcTexClamp clamp_mode) {
float GetShiftOffset(float v, ProcTexShift mode, ProcTexClamp clamp_mode) {
const float offset = (clamp_mode == ProcTexClamp::MirroredRepeat) ? 1 : 0.5f;
switch (mode) {
case ProcTexShift::None:
@ -81,7 +83,7 @@ static float GetShiftOffset(float v, ProcTexShift mode, ProcTexClamp clamp_mode)
}
};
static void ClampCoord(float& coord, ProcTexClamp mode) {
void ClampCoord(float& coord, ProcTexClamp mode) {
switch (mode) {
case ProcTexClamp::ToZero:
if (coord > 1.0f)
@ -112,8 +114,8 @@ static void ClampCoord(float& coord, ProcTexClamp mode) {
}
}
static float CombineAndMap(float u, float v, ProcTexCombiner combiner,
const std::array<State::ProcTex::ValueEntry, 128>& map_table) {
float CombineAndMap(float u, float v, ProcTexCombiner combiner,
const std::array<Pica::State::ProcTex::ValueEntry, 128>& map_table) {
float f;
switch (combiner) {
case ProcTexCombiner::U:
@ -122,28 +124,28 @@ static float CombineAndMap(float u, float v, ProcTexCombiner combiner,
case ProcTexCombiner::U2:
f = u * u;
break;
case TexturingRegs::ProcTexCombiner::V:
case ProcTexCombiner::V:
f = v;
break;
case TexturingRegs::ProcTexCombiner::V2:
case ProcTexCombiner::V2:
f = v * v;
break;
case TexturingRegs::ProcTexCombiner::Add:
case ProcTexCombiner::Add:
f = (u + v) * 0.5f;
break;
case TexturingRegs::ProcTexCombiner::Add2:
case ProcTexCombiner::Add2:
f = (u * u + v * v) * 0.5f;
break;
case TexturingRegs::ProcTexCombiner::SqrtAdd2:
case ProcTexCombiner::SqrtAdd2:
f = std::min(std::sqrt(u * u + v * v), 1.0f);
break;
case TexturingRegs::ProcTexCombiner::Min:
case ProcTexCombiner::Min:
f = std::min(u, v);
break;
case TexturingRegs::ProcTexCombiner::Max:
case ProcTexCombiner::Max:
f = std::max(u, v);
break;
case TexturingRegs::ProcTexCombiner::RMax:
case ProcTexCombiner::RMax:
f = std::min(((u + v) * 0.5f + std::sqrt(u * u + v * v)) * 0.5f, 1.0f);
break;
default:
@ -153,8 +155,10 @@ static float CombineAndMap(float u, float v, ProcTexCombiner combiner,
}
return LookupLUT(map_table, f);
}
} // Anonymous namespace
Common::Vec4<u8> ProcTex(float u, float v, const TexturingRegs& regs, const State::ProcTex& state) {
Common::Vec4<u8> ProcTex(float u, float v, const Pica::TexturingRegs& regs,
const Pica::State::ProcTex& state) {
u = std::abs(u);
v = std::abs(v);
@ -218,4 +222,4 @@ Common::Vec4<u8> ProcTex(float u, float v, const TexturingRegs& regs, const Stat
}
}
} // namespace Pica::Rasterizer
} // namespace SwRenderer

7
src/video_core/renderer_software/sw_proctex.h
View File

@ -8,9 +8,10 @@
#include "common/vector_math.h"
#include "video_core/pica_state.h"
namespace Pica::Rasterizer {
namespace SwRenderer {
/// Generates procedural texture color for the given coordinates
Common::Vec4<u8> ProcTex(float u, float v, const TexturingRegs& regs, const State::ProcTex& state);
Common::Vec4<u8> ProcTex(float u, float v, const Pica::TexturingRegs& regs,
const Pica::State::ProcTex& state);
} // namespace Pica::Rasterizer
} // namespace SwRenderer

930
src/video_core/renderer_software/sw_rasterizer.cpp
View File

@ -2,15 +2,937 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "video_core/renderer_software/sw_clipper.h"
#include <boost/container/static_vector.hpp>
#include "common/logging/log.h"
#include "common/microprofile.h"
#include "common/quaternion.h"
#include "common/vector_math.h"
#include "core/memory.h"
#include "video_core/pica_state.h"
#include "video_core/pica_types.h"
#include "video_core/renderer_software/sw_framebuffer.h"
#include "video_core/renderer_software/sw_lighting.h"
#include "video_core/renderer_software/sw_proctex.h"
#include "video_core/renderer_software/sw_rasterizer.h"
#include "video_core/renderer_software/sw_texturing.h"
#include "video_core/shader/shader.h"
#include "video_core/texture/texture_decode.h"
namespace VideoCore {
namespace SwRenderer {
using Pica::f24;
using Pica::FramebufferRegs;
using Pica::RasterizerRegs;
using Pica::TexturingRegs;
using Pica::Texture::LookupTexture;
using Pica::Texture::TextureInfo;
struct Vertex : Pica::Shader::OutputVertex {
Vertex(const OutputVertex& v) : OutputVertex(v) {}
/// Attributes used to store intermediate results position after perspective divide.
Common::Vec3<f24> screenpos;
/**
* Linear interpolation
* factor: 0=this, 1=vtx
* Note: This function cannot be called after perspective divide.
**/
void Lerp(f24 factor, const Vertex& vtx) {
pos = pos * factor + vtx.pos * (f24::One() - factor);
quat = quat * factor + vtx.quat * (f24::One() - factor);
color = color * factor + vtx.color * (f24::One() - factor);
tc0 = tc0 * factor + vtx.tc0 * (f24::One() - factor);
tc1 = tc1 * factor + vtx.tc1 * (f24::One() - factor);
tc0_w = tc0_w * factor + vtx.tc0_w * (f24::One() - factor);
view = view * factor + vtx.view * (f24::One() - factor);
tc2 = tc2 * factor + vtx.tc2 * (f24::One() - factor);
}
/**
* Linear interpolation
* factor: 0=v0, 1=v1
* Note: This function cannot be called after perspective divide.
**/
static Vertex Lerp(f24 factor, const Vertex& v0, const Vertex& v1) {
Vertex ret = v0;
ret.Lerp(factor, v1);
return ret;
}
};
namespace {
MICROPROFILE_DEFINE(GPU_Rasterization, "GPU", "Rasterization", MP_RGB(50, 50, 240));
struct ClippingEdge {
public:
constexpr ClippingEdge(Common::Vec4<f24> coeffs,
Common::Vec4<f24> bias = Common::Vec4<f24>(f24::Zero(), f24::Zero(),
f24::Zero(), f24::Zero()))
: pos(f24::Zero()), coeffs(coeffs), bias(bias) {}
bool IsInside(const Vertex& vertex) const {
return Common::Dot(vertex.pos + bias, coeffs) >= f24::Zero();
}
bool IsOutSide(const Vertex& vertex) const {
return !IsInside(vertex);
}
Vertex GetIntersection(const Vertex& v0, const Vertex& v1) const {
const f24 dp = Common::Dot(v0.pos + bias, coeffs);
const f24 dp_prev = Common::Dot(v1.pos + bias, coeffs);
const f24 factor = dp_prev / (dp_prev - dp);
return Vertex::Lerp(factor, v0, v1);
}
private:
[[maybe_unused]] f24 pos;
Common::Vec4<f24> coeffs;
Common::Vec4<f24> bias;
};
} // Anonymous namespace
RasterizerSoftware::RasterizerSoftware(Memory::MemorySystem& memory_)
: memory{memory_}, state{Pica::g_state}, regs{state.regs}, fb{memory, regs.framebuffer} {}
void RasterizerSoftware::AddTriangle(const Pica::Shader::OutputVertex& v0,
const Pica::Shader::OutputVertex& v1,
const Pica::Shader::OutputVertex& v2) {
Pica::Clipper::ProcessTriangle(v0, v1, v2);
/**
* Clipping a planar n-gon against a plane will remove at least 1 vertex and introduces 2 at
* the new edge (or less in degenerate cases). As such, we can say that each clipping plane
* introduces at most 1 new vertex to the polygon. Since we start with a triangle and have a
* fixed 6 clipping planes, the maximum number of vertices of the clipped polygon is 3 + 6 = 9.
**/
static constexpr std::size_t MAX_VERTICES = 9;
boost::container::static_vector<Vertex, MAX_VERTICES> buffer_a = {v0, v1, v2};
boost::container::static_vector<Vertex, MAX_VERTICES> buffer_b;
FlipQuaternionIfOpposite(buffer_a[1].quat, buffer_a[0].quat);
FlipQuaternionIfOpposite(buffer_a[2].quat, buffer_a[0].quat);
auto* output_list = &buffer_a;
auto* input_list = &buffer_b;
// NOTE: We clip against a w=epsilon plane to guarantee that the output has a positive w value.
// TODO: Not sure if this is a valid approach. Also should probably instead use the smallest
// epsilon possible within f24 accuracy.
static constexpr f24 EPSILON = f24::FromFloat32(0.00001f);
static constexpr f24 f0 = f24::Zero();
static constexpr f24 f1 = f24::One();
static constexpr std::array<ClippingEdge, 7> clipping_edges = {{
{Common::MakeVec(-f1, f0, f0, f1)}, // x = +w
{Common::MakeVec(f1, f0, f0, f1)}, // x = -w
{Common::MakeVec(f0, -f1, f0, f1)}, // y = +w
{Common::MakeVec(f0, f1, f0, f1)}, // y = -w
{Common::MakeVec(f0, f0, -f1, f0)}, // z = 0
{Common::MakeVec(f0, f0, f1, f1)}, // z = -w
{Common::MakeVec(f0, f0, f0, f1), Common::Vec4<f24>(f0, f0, f0, EPSILON)}, // w = EPSILON
}};
// Simple implementation of the Sutherland-Hodgman clipping algorithm.
// TODO: Make this less inefficient (currently lots of useless buffering overhead happens here)
const auto clip = [&](const ClippingEdge& edge) {
std::swap(input_list, output_list);
output_list->clear();
const Vertex* reference_vertex = &input_list->back();
for (const auto& vertex : *input_list) {
// NOTE: This algorithm changes vertex order in some cases!
if (edge.IsInside(vertex)) {
if (edge.IsOutSide(*reference_vertex)) {
output_list->push_back(edge.GetIntersection(vertex, *reference_vertex));
}
output_list->push_back(vertex);
} else if (edge.IsInside(*reference_vertex)) {
output_list->push_back(edge.GetIntersection(vertex, *reference_vertex));
}
reference_vertex = &vertex;
}
};
for (const ClippingEdge& edge : clipping_edges) {
clip(edge);
if (output_list->size() < 3) {
return;
}
}
} // namespace VideoCore
if (state.regs.rasterizer.clip_enable) {
const ClippingEdge custom_edge{state.regs.rasterizer.GetClipCoef()};
clip(custom_edge);
if (output_list->size() < 3) {
return;
}
}
MakeScreenCoords((*output_list)[0]);
MakeScreenCoords((*output_list)[1]);
for (std::size_t i = 0; i < output_list->size() - 2; i++) {
Vertex& vtx0 = (*output_list)[0];
Vertex& vtx1 = (*output_list)[i + 1];
Vertex& vtx2 = (*output_list)[i + 2];
MakeScreenCoords(vtx2);
LOG_TRACE(
Render_Software,
"Triangle {}/{} at position ({:.3}, {:.3}, {:.3}, {:.3f}), "
"({:.3}, {:.3}, {:.3}, {:.3}), ({:.3}, {:.3}, {:.3}, {:.3}) and "
"screen position ({:.2}, {:.2}, {:.2}), ({:.2}, {:.2}, {:.2}), ({:.2}, {:.2}, {:.2})",
i + 1, output_list->size() - 2, vtx0.pos.x.ToFloat32(), vtx0.pos.y.ToFloat32(),
vtx0.pos.z.ToFloat32(), vtx0.pos.w.ToFloat32(), vtx1.pos.x.ToFloat32(),
vtx1.pos.y.ToFloat32(), vtx1.pos.z.ToFloat32(), vtx1.pos.w.ToFloat32(),
vtx2.pos.x.ToFloat32(), vtx2.pos.y.ToFloat32(), vtx2.pos.z.ToFloat32(),
vtx2.pos.w.ToFloat32(), vtx0.screenpos.x.ToFloat32(), vtx0.screenpos.y.ToFloat32(),
vtx0.screenpos.z.ToFloat32(), vtx1.screenpos.x.ToFloat32(),
vtx1.screenpos.y.ToFloat32(), vtx1.screenpos.z.ToFloat32(),
vtx2.screenpos.x.ToFloat32(), vtx2.screenpos.y.ToFloat32(),
vtx2.screenpos.z.ToFloat32());
ProcessTriangle(vtx0, vtx1, vtx2);
}
}
void RasterizerSoftware::MakeScreenCoords(Vertex& vtx) {
Viewport viewport{};
viewport.halfsize_x = f24::FromRaw(regs.rasterizer.viewport_size_x);
viewport.halfsize_y = f24::FromRaw(regs.rasterizer.viewport_size_y);
viewport.offset_x = f24::FromFloat32(static_cast<f32>(regs.rasterizer.viewport_corner.x));
viewport.offset_y = f24::FromFloat32(static_cast<f32>(regs.rasterizer.viewport_corner.y));
f24 inv_w = f24::One() / vtx.pos.w;
vtx.pos.w = inv_w;
vtx.quat *= inv_w;
vtx.color *= inv_w;
vtx.tc0 *= inv_w;
vtx.tc1 *= inv_w;
vtx.tc0_w *= inv_w;
vtx.view *= inv_w;
vtx.tc2 *= inv_w;
vtx.screenpos[0] = (vtx.pos.x * inv_w + f24::One()) * viewport.halfsize_x + viewport.offset_x;
vtx.screenpos[1] = (vtx.pos.y * inv_w + f24::One()) * viewport.halfsize_y + viewport.offset_y;
vtx.screenpos[2] = vtx.pos.z * inv_w;
}
void RasterizerSoftware::ProcessTriangle(const Vertex& v0, const Vertex& v1, const Vertex& v2,
bool reversed) {
MICROPROFILE_SCOPE(GPU_Rasterization);
// Vertex positions in rasterizer coordinates
static auto screen_to_rasterizer_coords = [](const Common::Vec3<f24>& vec) {
return Common::Vec3{Fix12P4::FromFloat24(vec.x), Fix12P4::FromFloat24(vec.y),
Fix12P4::FromFloat24(vec.z)};
};
const std::array<Common::Vec3<Fix12P4>, 3> vtxpos = {
screen_to_rasterizer_coords(v0.screenpos),
screen_to_rasterizer_coords(v1.screenpos),
screen_to_rasterizer_coords(v2.screenpos),
};
if (regs.rasterizer.cull_mode == RasterizerRegs::CullMode::KeepAll) {
// Make sure we always end up with a triangle wound counter-clockwise
if (!reversed && SignedArea(vtxpos[0].xy(), vtxpos[1].xy(), vtxpos[2].xy()) <= 0) {
ProcessTriangle(v0, v2, v1, true);
return;
}
} else {
if (!reversed && regs.rasterizer.cull_mode == RasterizerRegs::CullMode::KeepClockWise) {
// Reverse vertex order and use the CCW code path.
ProcessTriangle(v0, v2, v1, true);
return;
}
// Cull away triangles which are wound clockwise.
if (SignedArea(vtxpos[0].xy(), vtxpos[1].xy(), vtxpos[2].xy()) <= 0) {
return;
}
}
u16 min_x = std::min({vtxpos[0].x, vtxpos[1].x, vtxpos[2].x});
u16 min_y = std::min({vtxpos[0].y, vtxpos[1].y, vtxpos[2].y});
u16 max_x = std::max({vtxpos[0].x, vtxpos[1].x, vtxpos[2].x});
u16 max_y = std::max({vtxpos[0].y, vtxpos[1].y, vtxpos[2].y});
// Convert the scissor box coordinates to 12.4 fixed point
const u16 scissor_x1 = static_cast<u16>(regs.rasterizer.scissor_test.x1 << 4);
const u16 scissor_y1 = static_cast<u16>(regs.rasterizer.scissor_test.y1 << 4);
// x2,y2 have +1 added to cover the entire sub-pixel area
const u16 scissor_x2 = static_cast<u16>((regs.rasterizer.scissor_test.x2 + 1) << 4);
const u16 scissor_y2 = static_cast<u16>((regs.rasterizer.scissor_test.y2 + 1) << 4);
if (regs.rasterizer.scissor_test.mode == RasterizerRegs::ScissorMode::Include) {
// Calculate the new bounds
min_x = std::max(min_x, scissor_x1);
min_y = std::max(min_y, scissor_y1);
max_x = std::min(max_x, scissor_x2);
max_y = std::min(max_y, scissor_y2);
}
min_x &= Fix12P4::IntMask();
min_y &= Fix12P4::IntMask();
max_x = ((max_x + Fix12P4::FracMask()) & Fix12P4::IntMask());
max_y = ((max_y + Fix12P4::FracMask()) & Fix12P4::IntMask());
const int bias0 =
IsRightSideOrFlatBottomEdge(vtxpos[0].xy(), vtxpos[1].xy(), vtxpos[2].xy()) ? -1 : 0;
const int bias1 =
IsRightSideOrFlatBottomEdge(vtxpos[1].xy(), vtxpos[2].xy(), vtxpos[0].xy()) ? -1 : 0;
const int bias2 =
IsRightSideOrFlatBottomEdge(vtxpos[2].xy(), vtxpos[0].xy(), vtxpos[1].xy()) ? -1 : 0;
const auto w_inverse = Common::MakeVec(v0.pos.w, v1.pos.w, v2.pos.w);
auto textures = regs.texturing.GetTextures();
const auto tev_stages = regs.texturing.GetTevStages();
const bool stencil_action_enable =
regs.framebuffer.output_merger.stencil_test.enable &&
regs.framebuffer.framebuffer.depth_format == FramebufferRegs::DepthFormat::D24S8;
const auto stencil_test = regs.framebuffer.output_merger.stencil_test;
// Enter rasterization loop, starting at the center of the topleft bounding box corner.
// TODO: Not sure if looping through x first might be faster
for (u16 y = min_y + 8; y < max_y; y += 0x10) {
for (u16 x = min_x + 8; x < max_x; x += 0x10) {
// Do not process the pixel if it's inside the scissor box and the scissor mode is set
// to Exclude.
if (regs.rasterizer.scissor_test.mode == RasterizerRegs::ScissorMode::Exclude) {
if (x >= scissor_x1 && x < scissor_x2 && y >= scissor_y1 && y < scissor_y2) {
continue;
}
}
// Calculate the barycentric coordinates w0, w1 and w2
const s32 w0 = bias0 + SignedArea(vtxpos[1].xy(), vtxpos[2].xy(), {x, y});
const s32 w1 = bias1 + SignedArea(vtxpos[2].xy(), vtxpos[0].xy(), {x, y});
const s32 w2 = bias2 + SignedArea(vtxpos[0].xy(), vtxpos[1].xy(), {x, y});
const s32 wsum = w0 + w1 + w2;
// If current pixel is not covered by the current primitive
if (w0 < 0 || w1 < 0 || w2 < 0) {
continue;
}
const auto baricentric_coordinates = Common::MakeVec(
f24::FromFloat32(static_cast<f32>(w0)), f24::FromFloat32(static_cast<f32>(w1)),
f24::FromFloat32(static_cast<f32>(w2)));
const f24 interpolated_w_inverse =
f24::One() / Common::Dot(w_inverse, baricentric_coordinates);
// interpolated_z = z / w
const float interpolated_z_over_w =
(v0.screenpos[2].ToFloat32() * w0 + v1.screenpos[2].ToFloat32() * w1 +
v2.screenpos[2].ToFloat32() * w2) /
wsum;
// Not fully accurate. About 3 bits in precision are missing.
// Z-Buffer (z / w * scale + offset)
const float depth_scale =
f24::FromRaw(regs.rasterizer.viewport_depth_range).ToFloat32();
const float depth_offset =
f24::FromRaw(regs.rasterizer.viewport_depth_near_plane).ToFloat32();
float depth = interpolated_z_over_w * depth_scale + depth_offset;
// Potentially switch to W-Buffer
if (regs.rasterizer.depthmap_enable ==
Pica::RasterizerRegs::DepthBuffering::WBuffering) {
// W-Buffer (z * scale + w * offset = (z / w * scale + offset) * w)
depth *= interpolated_w_inverse.ToFloat32() * wsum;
}
// Clamp the result
depth = std::clamp(depth, 0.0f, 1.0f);
/**
* Perspective correct attribute interpolation:
* Attribute values cannot be calculated by simple linear interpolation since
* they are not linear in screen space. For example, when interpolating a
* texture coordinate across two vertices, something simple like
* u = (u0*w0 + u1*w1)/(w0+w1)
* will not work. However, the attribute value divided by the
* clipspace w-coordinate (u/w) and and the inverse w-coordinate (1/w) are linear
* in screenspace. Hence, we can linearly interpolate these two independently and
* calculate the interpolated attribute by dividing the results.
* I.e.
* u_over_w = ((u0/v0.pos.w)*w0 + (u1/v1.pos.w)*w1)/(w0+w1)
* one_over_w = (( 1/v0.pos.w)*w0 + ( 1/v1.pos.w)*w1)/(w0+w1)
* u = u_over_w / one_over_w
*
* The generalization to three vertices is straightforward in baricentric coordinates.
**/
const auto get_interpolated_attribute = [&](f24 attr0, f24 attr1, f24 attr2) {
auto attr_over_w = Common::MakeVec(attr0, attr1, attr2);
f24 interpolated_attr_over_w = Common::Dot(attr_over_w, baricentric_coordinates);
return interpolated_attr_over_w * interpolated_w_inverse;
};
const Common::Vec4<u8> primary_color{
static_cast<u8>(
round(get_interpolated_attribute(v0.color.r(), v1.color.r(), v2.color.r())
.ToFloat32() *
255)),
static_cast<u8>(
round(get_interpolated_attribute(v0.color.g(), v1.color.g(), v2.color.g())
.ToFloat32() *
255)),
static_cast<u8>(
round(get_interpolated_attribute(v0.color.b(), v1.color.b(), v2.color.b())
.ToFloat32() *
255)),
static_cast<u8>(
round(get_interpolated_attribute(v0.color.a(), v1.color.a(), v2.color.a())
.ToFloat32() *
255)),
};
std::array<Common::Vec2<f24>, 3> uv;
uv[0].u() = get_interpolated_attribute(v0.tc0.u(), v1.tc0.u(), v2.tc0.u());
uv[0].v() = get_interpolated_attribute(v0.tc0.v(), v1.tc0.v(), v2.tc0.v());
uv[1].u() = get_interpolated_attribute(v0.tc1.u(), v1.tc1.u(), v2.tc1.u());
uv[1].v() = get_interpolated_attribute(v0.tc1.v(), v1.tc1.v(), v2.tc1.v());
uv[2].u() = get_interpolated_attribute(v0.tc2.u(), v1.tc2.u(), v2.tc2.u());
uv[2].v() = get_interpolated_attribute(v0.tc2.v(), v1.tc2.v(), v2.tc2.v());
// Sample bound texture units.
const f24 tc0_w = get_interpolated_attribute(v0.tc0_w, v1.tc0_w, v2.tc0_w);
const auto texture_color = TextureColor(uv, textures, tc0_w);
Common::Vec4<u8> primary_fragment_color{0, 0, 0, 0};
Common::Vec4<u8> secondary_fragment_color{0, 0, 0, 0};
if (!regs.lighting.disable) {
const auto normquat =
Common::Quaternion<f32>{
{get_interpolated_attribute(v0.quat.x, v1.quat.x, v2.quat.x).ToFloat32(),
get_interpolated_attribute(v0.quat.y, v1.quat.y, v2.quat.y).ToFloat32(),
get_interpolated_attribute(v0.quat.z, v1.quat.z, v2.quat.z).ToFloat32()},
get_interpolated_attribute(v0.quat.w, v1.quat.w, v2.quat.w).ToFloat32(),
}
.Normalized();
const Common::Vec3f view{
get_interpolated_attribute(v0.view.x, v1.view.x, v2.view.x).ToFloat32(),
get_interpolated_attribute(v0.view.y, v1.view.y, v2.view.y).ToFloat32(),
get_interpolated_attribute(v0.view.z, v1.view.z, v2.view.z).ToFloat32(),
};
std::tie(primary_fragment_color, secondary_fragment_color) = ComputeFragmentsColors(
regs.lighting, state.lighting, normquat, view, texture_color);
}
// Write the TEV stages.
Common::Vec4<u8> combiner_output =
WriteTevConfig(texture_color, tev_stages, primary_color, primary_fragment_color,
secondary_fragment_color);
const auto& output_merger = regs.framebuffer.output_merger;
if (output_merger.fragment_operation_mode ==
FramebufferRegs::FragmentOperationMode::Shadow) {
u32 depth_int = static_cast<u32>(depth * 0xFFFFFF);
// Use green color as the shadow intensity
u8 stencil = combiner_output.y;
fb.DrawShadowMapPixel(x >> 4, y >> 4, depth_int, stencil);
// Skip the normal output merger pipeline if it is in shadow mode
continue;
}
// Does alpha testing happen before or after stencil?
if (!DoAlphaTest(combiner_output.a())) {
continue;
}
WriteFog(combiner_output, depth);
if (!DoDepthStencilTest(x, y, depth, stencil_action_enable)) {
continue;
}
const auto result = PixelColor(x, y, combiner_output);
if (regs.framebuffer.framebuffer.allow_color_write != 0) {
fb.DrawPixel(x >> 4, y >> 4, result);
}
}
}
}
std::array<Common::Vec4<u8>, 4> RasterizerSoftware::TextureColor(
std::span<const Common::Vec2<f24>, 3> uv,
std::span<const Pica::TexturingRegs::FullTextureConfig, 3> textures, f24 tc0_w) const {
std::array<Common::Vec4<u8>, 4> texture_color{};
for (u32 i = 0; i < 3; ++i) {
const auto& texture = textures[i];
if (!texture.enabled) [[unlikely]] {
continue;
}
if (texture.config.address == 0) [[unlikely]] {
texture_color[i] = {0, 0, 0, 255};
continue;
}
const s32 coordinate_i = (i == 2 && regs.texturing.main_config.texture2_use_coord1) ? 1 : i;
f24 u = uv[coordinate_i].u();
f24 v = uv[coordinate_i].v();
// Only unit 0 respects the texturing type (according to 3DBrew)
PAddr texture_address = texture.config.GetPhysicalAddress();
f24 shadow_z;
if (i == 0) {
switch (texture.config.type) {
case TexturingRegs::TextureConfig::Texture2D:
break;
case TexturingRegs::TextureConfig::ShadowCube:
case TexturingRegs::TextureConfig::TextureCube: {
std::tie(u, v, shadow_z, texture_address) =
ConvertCubeCoord(u, v, tc0_w, regs.texturing);
break;
}
case TexturingRegs::TextureConfig::Projection2D: {
u /= tc0_w;
v /= tc0_w;
break;
}
case TexturingRegs::TextureConfig::Shadow2D: {
if (!regs.texturing.shadow.orthographic) {
u /= tc0_w;
v /= tc0_w;
}
shadow_z = f24::FromFloat32(std::abs(tc0_w.ToFloat32()));
break;
}
case TexturingRegs::TextureConfig::Disabled:
continue; // skip this unit and continue to the next unit
default:
LOG_ERROR(HW_GPU, "Unhandled texture type {:x}", (int)texture.config.type);
UNIMPLEMENTED();
break;
}
}
const f24 width = f24::FromFloat32(static_cast<f32>(texture.config.width));
const f24 height = f24::FromFloat32(static_cast<f32>(texture.config.height));
s32 s = static_cast<s32>((u * width).ToFloat32());
s32 t = static_cast<s32>((v * height).ToFloat32());
bool use_border_s = false;
bool use_border_t = false;
if (texture.config.wrap_s == TexturingRegs::TextureConfig::ClampToBorder) {
use_border_s = s < 0 || s >= static_cast<s32>(texture.config.width);
} else if (texture.config.wrap_s == TexturingRegs::TextureConfig::ClampToBorder2) {
use_border_s = s >= static_cast<s32>(texture.config.width);
}
if (texture.config.wrap_t == TexturingRegs::TextureConfig::ClampToBorder) {
use_border_t = t < 0 || t >= static_cast<s32>(texture.config.height);
} else if (texture.config.wrap_t == TexturingRegs::TextureConfig::ClampToBorder2) {
use_border_t = t >= static_cast<s32>(texture.config.height);
}
if (use_border_s || use_border_t) {
const auto border_color = texture.config.border_color;
texture_color[i] = Common::MakeVec(border_color.r.Value(), border_color.g.Value(),
border_color.b.Value(), border_color.a.Value())
.Cast<u8>();
} else {
// Textures are laid out from bottom to top, hence we invert the t coordinate.
// NOTE: This may not be the right place for the inversion.
// TODO: Check if this applies to ETC textures, too.
s = GetWrappedTexCoord(texture.config.wrap_s, s, texture.config.width);
t = texture.config.height - 1 -
GetWrappedTexCoord(texture.config.wrap_t, t, texture.config.height);
const u8* texture_data = memory.GetPhysicalPointer(texture_address);
const auto info = TextureInfo::FromPicaRegister(texture.config, texture.format);
// TODO: Apply the min and mag filters to the texture
texture_color[i] = LookupTexture(texture_data, s, t, info);
}
if (i == 0 && (texture.config.type == TexturingRegs::TextureConfig::Shadow2D ||
texture.config.type == TexturingRegs::TextureConfig::ShadowCube)) {
s32 z_int = static_cast<s32>(std::min(shadow_z.ToFloat32(), 1.0f) * 0xFFFFFF);
z_int -= regs.texturing.shadow.bias << 1;
const auto& color = texture_color[i];
const s32 z_ref = (color.w << 16) | (color.z << 8) | color.y;
u8 density;
if (z_ref >= z_int) {
density = color.x;
} else {
density = 0;
}
texture_color[i] = {density, density, density, density};
}
}
// Sample procedural texture
if (regs.texturing.main_config.texture3_enable) {
const auto& proctex_uv = uv[regs.texturing.main_config.texture3_coordinates];
texture_color[3] = ProcTex(proctex_uv.u().ToFloat32(), proctex_uv.v().ToFloat32(),
regs.texturing, state.proctex);
}
return texture_color;
}
Common::Vec4<u8> RasterizerSoftware::PixelColor(u16 x, u16 y,
Common::Vec4<u8>& combiner_output) const {
const auto dest = fb.GetPixel(x >> 4, y >> 4);
Common::Vec4<u8> blend_output = combiner_output;
const auto& output_merger = regs.framebuffer.output_merger;
if (output_merger.alphablend_enable) {
const auto params = output_merger.alpha_blending;
const auto lookup_factor = [&](u32 channel, FramebufferRegs::BlendFactor factor) -> u8 {
DEBUG_ASSERT(channel < 4);
const Common::Vec4<u8> blend_const =
Common::MakeVec(
output_merger.blend_const.r.Value(), output_merger.blend_const.g.Value(),
output_merger.blend_const.b.Value(), output_merger.blend_const.a.Value())
.Cast<u8>();
switch (factor) {
case FramebufferRegs::BlendFactor::Zero:
return 0;
case FramebufferRegs::BlendFactor::One:
return 255;
case FramebufferRegs::BlendFactor::SourceColor:
return combiner_output[channel];
case FramebufferRegs::BlendFactor::OneMinusSourceColor:
return 255 - combiner_output[channel];
case FramebufferRegs::BlendFactor::DestColor:
return dest[channel];
case FramebufferRegs::BlendFactor::OneMinusDestColor:
return 255 - dest[channel];
case FramebufferRegs::BlendFactor::SourceAlpha:
return combiner_output.a();
case FramebufferRegs::BlendFactor::OneMinusSourceAlpha:
return 255 - combiner_output.a();
case FramebufferRegs::BlendFactor::DestAlpha:
return dest.a();
case FramebufferRegs::BlendFactor::OneMinusDestAlpha:
return 255 - dest.a();
case FramebufferRegs::BlendFactor::ConstantColor:
return blend_const[channel];
case FramebufferRegs::BlendFactor::OneMinusConstantColor:
return 255 - blend_const[channel];
case FramebufferRegs::BlendFactor::ConstantAlpha:
return blend_const.a();
case FramebufferRegs::BlendFactor::OneMinusConstantAlpha:
return 255 - blend_const.a();
case FramebufferRegs::BlendFactor::SourceAlphaSaturate:
// Returns 1.0 for the alpha channel
if (channel == 3) {
return 255;
}
return std::min(combiner_output.a(), static_cast<u8>(255 - dest.a()));
default:
LOG_CRITICAL(HW_GPU, "Unknown blend factor {:x}", factor);
UNIMPLEMENTED();
break;
}
return combiner_output[channel];
};
const auto srcfactor = Common::MakeVec(
lookup_factor(0, params.factor_source_rgb), lookup_factor(1, params.factor_source_rgb),
lookup_factor(2, params.factor_source_rgb), lookup_factor(3, params.factor_source_a));
const auto dstfactor = Common::MakeVec(
lookup_factor(0, params.factor_dest_rgb), lookup_factor(1, params.factor_dest_rgb),
lookup_factor(2, params.factor_dest_rgb), lookup_factor(3, params.factor_dest_a));
blend_output = EvaluateBlendEquation(combiner_output, srcfactor, dest, dstfactor,
params.blend_equation_rgb);
blend_output.a() = EvaluateBlendEquation(combiner_output, srcfactor, dest, dstfactor,
params.blend_equation_a)
.a();
} else {
blend_output =
Common::MakeVec(LogicOp(combiner_output.r(), dest.r(), output_merger.logic_op),
LogicOp(combiner_output.g(), dest.g(), output_merger.logic_op),
LogicOp(combiner_output.b(), dest.b(), output_merger.logic_op),
LogicOp(combiner_output.a(), dest.a(), output_merger.logic_op));
}
const Common::Vec4<u8> result = {
output_merger.red_enable ? blend_output.r() : dest.r(),
output_merger.green_enable ? blend_output.g() : dest.g(),
output_merger.blue_enable ? blend_output.b() : dest.b(),
output_merger.alpha_enable ? blend_output.a() : dest.a(),
};
return result;
}
Common::Vec4<u8> RasterizerSoftware::WriteTevConfig(
std::span<const Common::Vec4<u8>, 4> texture_color,
std::span<const Pica::TexturingRegs::TevStageConfig, 6> tev_stages,
Common::Vec4<u8> primary_color, Common::Vec4<u8> primary_fragment_color,
Common::Vec4<u8> secondary_fragment_color) const {
/**
* Texture environment - consists of 6 stages of color and alpha combining.
* Color combiners take three input color values from some source (e.g. interpolated
* vertex color, texture color, previous stage, etc), perform some very simple
* operations on each of them (e.g. inversion) and then calculate the output color
* with some basic arithmetic. Alpha combiners can be configured separately but work
* analogously.
**/
Common::Vec4<u8> combiner_output;
Common::Vec4<u8> combiner_buffer = {0, 0, 0, 0};
Common::Vec4<u8> next_combiner_buffer =
Common::MakeVec(regs.texturing.tev_combiner_buffer_color.r.Value(),
regs.texturing.tev_combiner_buffer_color.g.Value(),
regs.texturing.tev_combiner_buffer_color.b.Value(),
regs.texturing.tev_combiner_buffer_color.a.Value())
.Cast<u8>();
for (u32 tev_stage_index = 0; tev_stage_index < tev_stages.size(); ++tev_stage_index) {
const auto& tev_stage = tev_stages[tev_stage_index];
using Source = TexturingRegs::TevStageConfig::Source;
auto get_source = [&](Source source) -> Common::Vec4<u8> {
switch (source) {
case Source::PrimaryColor:
return primary_color;
case Source::PrimaryFragmentColor:
return primary_fragment_color;
case Source::SecondaryFragmentColor:
return secondary_fragment_color;
case Source::Texture0:
return texture_color[0];
case Source::Texture1:
return texture_color[1];
case Source::Texture2:
return texture_color[2];
case Source::Texture3:
return texture_color[3];
case Source::PreviousBuffer:
return combiner_buffer;
case Source::Constant:
return Common::MakeVec(tev_stage.const_r.Value(), tev_stage.const_g.Value(),
tev_stage.const_b.Value(), tev_stage.const_a.Value())
.Cast<u8>();
case Source::Previous:
return combiner_output;
default:
LOG_ERROR(HW_GPU, "Unknown color combiner source {}", (int)source);
UNIMPLEMENTED();
return {0, 0, 0, 0};
}
};
/**
* Color combiner
* NOTE: Not sure if the alpha combiner might use the color output of the previous
* stage as input. Hence, we currently don't directly write the result to
* combiner_output.rgb(), but instead store it in a temporary variable until
* alpha combining has been done.
**/
const std::array<Common::Vec3<u8>, 3> color_result = {
GetColorModifier(tev_stage.color_modifier1, get_source(tev_stage.color_source1)),
GetColorModifier(tev_stage.color_modifier2, get_source(tev_stage.color_source2)),
GetColorModifier(tev_stage.color_modifier3, get_source(tev_stage.color_source3)),
};
const Common::Vec3<u8> color_output = ColorCombine(tev_stage.color_op, color_result);
u8 alpha_output;
if (tev_stage.color_op == TexturingRegs::TevStageConfig::Operation::Dot3_RGBA) {
// result of Dot3_RGBA operation is also placed to the alpha component
alpha_output = color_output.x;
} else {
// alpha combiner
const std::array<u8, 3> alpha_result = {{
GetAlphaModifier(tev_stage.alpha_modifier1, get_source(tev_stage.alpha_source1)),
GetAlphaModifier(tev_stage.alpha_modifier2, get_source(tev_stage.alpha_source2)),
GetAlphaModifier(tev_stage.alpha_modifier3, get_source(tev_stage.alpha_source3)),
}};
alpha_output = AlphaCombine(tev_stage.alpha_op, alpha_result);
}
combiner_output[0] = std::min(255U, color_output.r() * tev_stage.GetColorMultiplier());
combiner_output[1] = std::min(255U, color_output.g() * tev_stage.GetColorMultiplier());
combiner_output[2] = std::min(255U, color_output.b() * tev_stage.GetColorMultiplier());
combiner_output[3] = std::min(255U, alpha_output * tev_stage.GetAlphaMultiplier());
combiner_buffer = next_combiner_buffer;
if (regs.texturing.tev_combiner_buffer_input.TevStageUpdatesCombinerBufferColor(
tev_stage_index)) {
next_combiner_buffer.r() = combiner_output.r();
next_combiner_buffer.g() = combiner_output.g();
next_combiner_buffer.b() = combiner_output.b();
}
if (regs.texturing.tev_combiner_buffer_input.TevStageUpdatesCombinerBufferAlpha(
tev_stage_index)) {
next_combiner_buffer.a() = combiner_output.a();
}
}
return combiner_output;
}
void RasterizerSoftware::WriteFog(Common::Vec4<u8>& combiner_output, float depth) const {
/**
* Apply fog combiner. Not fully accurate. We'd have to know what data type is used to
* store the depth etc. Using float for now until we know more about Pica datatypes.
**/
if (regs.texturing.fog_mode == TexturingRegs::FogMode::Fog) {
const Common::Vec3<u8> fog_color =
Common::MakeVec(regs.texturing.fog_color.r.Value(), regs.texturing.fog_color.g.Value(),
regs.texturing.fog_color.b.Value())
.Cast<u8>();
float fog_index;
if (regs.texturing.fog_flip) {
fog_index = (1.0f - depth) * 128.0f;
} else {
fog_index = depth * 128.0f;
}
// Generate clamped fog factor from LUT for given fog index
const f32 fog_i = std::clamp(floorf(fog_index), 0.0f, 127.0f);
const f32 fog_f = fog_index - fog_i;
const auto& fog_lut_entry = state.fog.lut[static_cast<u32>(fog_i)];
f32 fog_factor = fog_lut_entry.ToFloat() + fog_lut_entry.DiffToFloat() * fog_f;
fog_factor = std::clamp(fog_factor, 0.0f, 1.0f);
for (u32 i = 0; i < 3; i++) {
combiner_output[i] = static_cast<u8>(fog_factor * combiner_output[i] +
(1.0f - fog_factor) * fog_color[i]);
}
}
}
bool RasterizerSoftware::DoAlphaTest(u8 alpha) const {
const auto& output_merger = regs.framebuffer.output_merger;
if (!output_merger.alpha_test.enable) {
return true;
}
switch (output_merger.alpha_test.func) {
case FramebufferRegs::CompareFunc::Never:
return false;
case FramebufferRegs::CompareFunc::Always:
return true;
case FramebufferRegs::CompareFunc::Equal:
return alpha == output_merger.alpha_test.ref;
case FramebufferRegs::CompareFunc::NotEqual:
return alpha != output_merger.alpha_test.ref;
case FramebufferRegs::CompareFunc::LessThan:
return alpha < output_merger.alpha_test.ref;
case FramebufferRegs::CompareFunc::LessThanOrEqual:
return alpha <= output_merger.alpha_test.ref;
case FramebufferRegs::CompareFunc::GreaterThan:
return alpha > output_merger.alpha_test.ref;
case FramebufferRegs::CompareFunc::GreaterThanOrEqual:
return alpha >= output_merger.alpha_test.ref;
}
}
bool RasterizerSoftware::DoDepthStencilTest(u16 x, u16 y, float depth,
bool stencil_action_enable) const {
const auto& framebuffer = regs.framebuffer.framebuffer;
const auto stencil_test = regs.framebuffer.output_merger.stencil_test;
u8 old_stencil = 0;
const auto update_stencil = [&](Pica::FramebufferRegs::StencilAction action) {
const u8 new_stencil =
PerformStencilAction(action, old_stencil, stencil_test.reference_value);
if (framebuffer.allow_depth_stencil_write != 0) {
const u8 stencil =
(new_stencil & stencil_test.write_mask) | (old_stencil & ~stencil_test.write_mask);
fb.SetStencil(x >> 4, y >> 4, stencil);
}
};
if (stencil_action_enable) {
old_stencil = fb.GetStencil(x >> 4, y >> 4);
const u8 dest = old_stencil & stencil_test.input_mask;
const u8 ref = stencil_test.reference_value & stencil_test.input_mask;
bool pass = false;
switch (stencil_test.func) {
case FramebufferRegs::CompareFunc::Never:
pass = false;
break;
case FramebufferRegs::CompareFunc::Always:
pass = true;
break;
case FramebufferRegs::CompareFunc::Equal:
pass = (ref == dest);
break;
case FramebufferRegs::CompareFunc::NotEqual:
pass = (ref != dest);
break;
case FramebufferRegs::CompareFunc::LessThan:
pass = (ref < dest);
break;
case FramebufferRegs::CompareFunc::LessThanOrEqual:
pass = (ref <= dest);
break;
case FramebufferRegs::CompareFunc::GreaterThan:
pass = (ref > dest);
break;
case FramebufferRegs::CompareFunc::GreaterThanOrEqual:
pass = (ref >= dest);
break;
}
if (!pass) {
update_stencil(stencil_test.action_stencil_fail);
return false;
}
}
const u32 num_bits = FramebufferRegs::DepthBitsPerPixel(framebuffer.depth_format);
const u32 z = static_cast<u32>(depth * ((1 << num_bits) - 1));
const auto& output_merger = regs.framebuffer.output_merger;
if (output_merger.depth_test_enable) {
const u32 ref_z = fb.GetDepth(x >> 4, y >> 4);
bool pass = false;
switch (output_merger.depth_test_func) {
case FramebufferRegs::CompareFunc::Never:
pass = false;
break;
case FramebufferRegs::CompareFunc::Always:
pass = true;
break;
case FramebufferRegs::CompareFunc::Equal:
pass = z == ref_z;
break;
case FramebufferRegs::CompareFunc::NotEqual:
pass = z != ref_z;
break;
case FramebufferRegs::CompareFunc::LessThan:
pass = z < ref_z;
break;
case FramebufferRegs::CompareFunc::LessThanOrEqual:
pass = z <= ref_z;
break;
case FramebufferRegs::CompareFunc::GreaterThan:
pass = z > ref_z;
break;
case FramebufferRegs::CompareFunc::GreaterThanOrEqual:
pass = z >= ref_z;
break;
}
if (!pass) {
if (stencil_action_enable) {
update_stencil(stencil_test.action_depth_fail);
}
return false;
}
}
if (framebuffer.allow_depth_stencil_write != 0 && output_merger.depth_write_enable) {
fb.SetDepth(x >> 4, y >> 4, z);
}
// The stencil depth_pass action is executed even if depth testing is disabled
if (stencil_action_enable) {
update_stencil(stencil_test.action_depth_pass);
}
return true;
}
} // namespace SwRenderer

62
src/video_core/renderer_software/sw_rasterizer.h
View File

@ -4,16 +4,30 @@
#pragma once
#include "common/common_types.h"
#include <span>
#include "video_core/rasterizer_interface.h"
#include "video_core/regs_texturing.h"
#include "video_core/renderer_software/sw_clipper.h"
#include "video_core/renderer_software/sw_framebuffer.h"
namespace Pica::Shader {
struct OutputVertex;
} // namespace Pica::Shader
}
namespace VideoCore {
namespace Pica {
struct State;
struct Regs;
} // namespace Pica
namespace SwRenderer {
struct Vertex;
class RasterizerSoftware : public VideoCore::RasterizerInterface {
public:
explicit RasterizerSoftware(Memory::MemorySystem& memory);
class RasterizerSoftware : public RasterizerInterface {
void AddTriangle(const Pica::Shader::OutputVertex& v0, const Pica::Shader::OutputVertex& v1,
const Pica::Shader::OutputVertex& v2) override;
void DrawTriangles() override {}
@ -23,6 +37,44 @@ class RasterizerSoftware : public RasterizerInterface {
void InvalidateRegion(PAddr addr, u32 size) override {}
void FlushAndInvalidateRegion(PAddr addr, u32 size) override {}
void ClearAll(bool flush) override {}
private:
/// Computes the screen coordinates of the provided vertex.
void MakeScreenCoords(Vertex& vtx);
/// Processes the triangle defined by the provided vertices.
void ProcessTriangle(const Vertex& v0, const Vertex& v1, const Vertex& v2,
bool reversed = false);
/// Returns the texture color of the currently processed pixel.
std::array<Common::Vec4<u8>, 4> TextureColor(
std::span<const Common::Vec2<f24>, 3> uv,
std::span<const Pica::TexturingRegs::FullTextureConfig, 3> textures, f24 tc0_w) const;
/// Returns the final pixel color with blending or logic ops applied.
Common::Vec4<u8> PixelColor(u16 x, u16 y, Common::Vec4<u8>& combiner_output) const;
/// Emulates the TEV configuration and returns the combiner output.
Common::Vec4<u8> WriteTevConfig(
std::span<const Common::Vec4<u8>, 4> texture_color,
std::span<const Pica::TexturingRegs::TevStageConfig, 6> tev_stages,
Common::Vec4<u8> primary_color, Common::Vec4<u8> primary_fragment_color,
Common::Vec4<u8> secondary_fragment_color) const;
/// Blends fog to the combiner output if enabled.
void WriteFog(Common::Vec4<u8>& combiner_output, float depth) const;
/// Performs the alpha test. Returns false if the test failed.
bool DoAlphaTest(u8 alpha) const;
/// Performs the depth stencil test. Returns false if the test failed.
bool DoDepthStencilTest(u16 x, u16 y, float depth, bool stencil_action_enable) const;
private:
Memory::MemorySystem& memory;
Pica::State& state;
const Pica::Regs& regs;
Framebuffer fb;
};
} // namespace VideoCore
} // namespace SwRenderer

109
src/video_core/renderer_software/sw_texturing.cpp
View File

@ -9,41 +9,40 @@
#include "video_core/regs_texturing.h"
#include "video_core/renderer_software/sw_texturing.h"
namespace Pica::Rasterizer {
namespace SwRenderer {
using TevStageConfig = TexturingRegs::TevStageConfig;
using TevStageConfig = Pica::TexturingRegs::TevStageConfig;
int GetWrappedTexCoord(Pica::TexturingRegs::TextureConfig::WrapMode mode, s32 val, u32 size) {
using TextureConfig = Pica::TexturingRegs::TextureConfig;
int GetWrappedTexCoord(TexturingRegs::TextureConfig::WrapMode mode, int val, unsigned size) {
switch (mode) {
case TexturingRegs::TextureConfig::ClampToEdge2:
case TextureConfig::ClampToEdge2:
// For negative coordinate, ClampToEdge2 behaves the same as Repeat
if (val < 0) {
return static_cast<int>(static_cast<unsigned>(val) % size);
return static_cast<s32>(static_cast<u32>(val) % size);
}
// [[fallthrough]]
case TexturingRegs::TextureConfig::ClampToEdge:
[[fallthrough]];
case TextureConfig::ClampToEdge:
val = std::max(val, 0);
val = std::min(val, static_cast<int>(size) - 1);
val = std::min(val, static_cast<s32>(size) - 1);
return val;
case TexturingRegs::TextureConfig::ClampToBorder:
case TextureConfig::ClampToBorder:
return val;
case TexturingRegs::TextureConfig::ClampToBorder2:
case TextureConfig::ClampToBorder2:
// For ClampToBorder2, the case of positive coordinate beyond the texture size is already
// handled outside. Here we only handle the negative coordinate in the same way as Repeat.
case TexturingRegs::TextureConfig::Repeat2:
case TexturingRegs::TextureConfig::Repeat3:
case TexturingRegs::TextureConfig::Repeat:
return static_cast<int>(static_cast<unsigned>(val) % size);
case TexturingRegs::TextureConfig::MirroredRepeat: {
unsigned int coord = (static_cast<unsigned>(val) % (2 * size));
if (coord >= size)
case TextureConfig::Repeat2:
case TextureConfig::Repeat3:
case TextureConfig::Repeat:
return static_cast<s32>(static_cast<u32>(val) % size);
case TextureConfig::MirroredRepeat: {
u32 coord = (static_cast<u32>(val) % (2 * size));
if (coord >= size) {
coord = 2 * size - 1 - coord;
return static_cast<int>(coord);
}
return static_cast<s32>(coord);
}
default:
LOG_ERROR(HW_GPU, "Unknown texture coordinate wrapping mode {:x}", (int)mode);
UNIMPLEMENTED();
@ -58,35 +57,25 @@ Common::Vec3<u8> GetColorModifier(TevStageConfig::ColorModifier factor,
switch (factor) {
case ColorModifier::SourceColor:
return values.rgb();
case ColorModifier::OneMinusSourceColor:
return (Common::Vec3<u8>(255, 255, 255) - values.rgb()).Cast<u8>();
case ColorModifier::SourceAlpha:
return values.aaa();
case ColorModifier::OneMinusSourceAlpha:
return (Common::Vec3<u8>(255, 255, 255) - values.aaa()).Cast<u8>();
case ColorModifier::SourceRed:
return values.rrr();
case ColorModifier::OneMinusSourceRed:
return (Common::Vec3<u8>(255, 255, 255) - values.rrr()).Cast<u8>();
case ColorModifier::SourceGreen:
return values.ggg();
case ColorModifier::OneMinusSourceGreen:
return (Common::Vec3<u8>(255, 255, 255) - values.ggg()).Cast<u8>();
case ColorModifier::SourceBlue:
return values.bbb();
case ColorModifier::OneMinusSourceBlue:
return (Common::Vec3<u8>(255, 255, 255) - values.bbb()).Cast<u8>();
}
UNREACHABLE();
};
@ -96,42 +85,33 @@ u8 GetAlphaModifier(TevStageConfig::AlphaModifier factor, const Common::Vec4<u8>
switch (factor) {
case AlphaModifier::SourceAlpha:
return values.a();
case AlphaModifier::OneMinusSourceAlpha:
return 255 - values.a();
case AlphaModifier::SourceRed:
return values.r();
case AlphaModifier::OneMinusSourceRed:
return 255 - values.r();
case AlphaModifier::SourceGreen:
return values.g();
case AlphaModifier::OneMinusSourceGreen:
return 255 - values.g();
case AlphaModifier::SourceBlue:
return values.b();
case AlphaModifier::OneMinusSourceBlue:
return 255 - values.b();
}
UNREACHABLE();
};
Common::Vec3<u8> ColorCombine(TevStageConfig::Operation op, const Common::Vec3<u8> input[3]) {
Common::Vec3<u8> ColorCombine(TevStageConfig::Operation op,
std::span<const Common::Vec3<u8>, 3> input) {
using Operation = TevStageConfig::Operation;
switch (op) {
case Operation::Replace:
return input[0];
case Operation::Modulate:
return ((input[0] * input[1]) / 255).Cast<u8>();
case Operation::Add: {
auto result = input[0] + input[1];
result.r() = std::min(255, result.r());
@ -139,46 +119,41 @@ Common::Vec3<u8> ColorCombine(TevStageConfig::Operation op, const Common::Vec3<u
result.b() = std::min(255, result.b());
return result.Cast<u8>();
}
case Operation::AddSigned: {
// TODO(bunnei): Verify that the color conversion from (float) 0.5f to
// (byte) 128 is correct
auto result =
input[0].Cast<int>() + input[1].Cast<int>() - Common::MakeVec<int>(128, 128, 128);
result.r() = std::clamp<int>(result.r(), 0, 255);
result.g() = std::clamp<int>(result.g(), 0, 255);
result.b() = std::clamp<int>(result.b(), 0, 255);
Common::Vec3i result =
input[0].Cast<s32>() + input[1].Cast<s32>() - Common::MakeVec<s32>(128, 128, 128);
result.r() = std::clamp<s32>(result.r(), 0, 255);
result.g() = std::clamp<s32>(result.g(), 0, 255);
result.b() = std::clamp<s32>(result.b(), 0, 255);
return result.Cast<u8>();
}
case Operation::Lerp:
return ((input[0] * input[2] +
input[1] * (Common::MakeVec<u8>(255, 255, 255) - input[2]).Cast<u8>()) /
255)
.Cast<u8>();
case Operation::Subtract: {
auto result = input[0].Cast<int>() - input[1].Cast<int>();
auto result = input[0].Cast<s32>() - input[1].Cast<s32>();
result.r() = std::max(0, result.r());
result.g() = std::max(0, result.g());
result.b() = std::max(0, result.b());
return result.Cast<u8>();
}
case Operation::MultiplyThenAdd: {
auto result = (input[0] * input[1] + 255 * input[2].Cast<int>()) / 255;
auto result = (input[0] * input[1] + 255 * input[2].Cast<s32>()) / 255;
result.r() = std::min(255, result.r());
result.g() = std::min(255, result.g());
result.b() = std::min(255, result.b());
return result.Cast<u8>();
}
case Operation::AddThenMultiply: {
auto result = input[0] + input[1];
result.r() = std::min(255, result.r());
result.g() = std::min(255, result.g());
result.b() = std::min(255, result.b());
result = (result * input[2].Cast<int>()) / 255;
result = (result * input[2].Cast<s32>()) / 255;
return result.Cast<u8>();
}
case Operation::Dot3_RGB:
@ -187,11 +162,11 @@ Common::Vec3<u8> ColorCombine(TevStageConfig::Operation op, const Common::Vec3<u
// indicate that the per-component computation can't have a higher precision than 1/256,
// while dot3_rgb((0x80,g0,b0), (0x7F,g1,b1)) and dot3_rgb((0x80,g0,b0), (0x80,g1,b1)) give
// different results.
int result = ((input[0].r() * 2 - 255) * (input[1].r() * 2 - 255) + 128) / 256 +
s32 result = ((input[0].r() * 2 - 255) * (input[1].r() * 2 - 255) + 128) / 256 +
((input[0].g() * 2 - 255) * (input[1].g() * 2 - 255) + 128) / 256 +
((input[0].b() * 2 - 255) * (input[1].b() * 2 - 255) + 128) / 256;
result = std::max(0, std::min(255, result));
return {(u8)result, (u8)result, (u8)result};
result = std::clamp(result, 0, 255);
return Common::Vec3{result, result, result}.Cast<u8>();
}
default:
LOG_ERROR(HW_GPU, "Unknown color combiner operation {}", (int)op);
@ -205,31 +180,23 @@ u8 AlphaCombine(TevStageConfig::Operation op, const std::array<u8, 3>& input) {
using Operation = TevStageConfig::Operation;
case Operation::Replace:
return input[0];
case Operation::Modulate:
return input[0] * input[1] / 255;
case Operation::Add:
return std::min(255, input[0] + input[1]);
case Operation::AddSigned: {
// TODO(bunnei): Verify that the color conversion from (float) 0.5f to (byte) 128 is correct
auto result = static_cast<int>(input[0]) + static_cast<int>(input[1]) - 128;
return static_cast<u8>(std::clamp<int>(result, 0, 255));
auto result = static_cast<s32>(input[0]) + static_cast<s32>(input[1]) - 128;
return static_cast<u8>(std::clamp<s32>(result, 0, 255));
}
case Operation::Lerp:
return (input[0] * input[2] + input[1] * (255 - input[2])) / 255;
case Operation::Subtract:
return std::max(0, (int)input[0] - (int)input[1]);
return std::max(0, static_cast<s32>(input[0]) - static_cast<s32>(input[1]));
case Operation::MultiplyThenAdd:
return std::min(255, (input[0] * input[1] + 255 * input[2]) / 255);
case Operation::AddThenMultiply:
return (std::min(255, (input[0] + input[1])) * input[2]) / 255;
default:
LOG_ERROR(HW_GPU, "Unknown alpha combiner operation {}", (int)op);
UNIMPLEMENTED();
@ -237,4 +204,4 @@ u8 AlphaCombine(TevStageConfig::Operation op, const std::array<u8, 3>& input) {
}
};
} // namespace Pica::Rasterizer
} // namespace SwRenderer

18
src/video_core/renderer_software/sw_texturing.h
View File

@ -4,23 +4,25 @@
#pragma once
#include <span>
#include "common/common_types.h"
#include "common/vector_math.h"
#include "video_core/regs_texturing.h"
namespace Pica::Rasterizer {
namespace SwRenderer {
int GetWrappedTexCoord(TexturingRegs::TextureConfig::WrapMode mode, int val, unsigned size);
int GetWrappedTexCoord(Pica::TexturingRegs::TextureConfig::WrapMode mode, s32 val, u32 size);
Common::Vec3<u8> GetColorModifier(TexturingRegs::TevStageConfig::ColorModifier factor,
Common::Vec3<u8> GetColorModifier(Pica::TexturingRegs::TevStageConfig::ColorModifier factor,
const Common::Vec4<u8>& values);
u8 GetAlphaModifier(TexturingRegs::TevStageConfig::AlphaModifier factor,
u8 GetAlphaModifier(Pica::TexturingRegs::TevStageConfig::AlphaModifier factor,
const Common::Vec4<u8>& values);
Common::Vec3<u8> ColorCombine(TexturingRegs::TevStageConfig::Operation op,
const Common::Vec3<u8> input[3]);
Common::Vec3<u8> ColorCombine(Pica::TexturingRegs::TevStageConfig::Operation op,
std::span<const Common::Vec3<u8>, 3> input);
u8 AlphaCombine(TexturingRegs::TevStageConfig::Operation op, const std::array<u8, 3>& input);
u8 AlphaCombine(Pica::TexturingRegs::TevStageConfig::Operation op, const std::array<u8, 3>& input);
} // namespace Pica::Rasterizer
} // namespace SwRenderer

20
src/video_core/shader/debug_data.h
View File

@ -54,12 +54,12 @@ struct DebugData<true> {
LOOP_INT_IN = 0x800,
};
Common::Vec4<float24> src1;
Common::Vec4<float24> src2;
Common::Vec4<float24> src3;
Common::Vec4<f24> src1;
Common::Vec4<f24> src2;
Common::Vec4<f24> src3;
Common::Vec4<float24> dest_in;
Common::Vec4<float24> dest_out;
Common::Vec4<f24> dest_in;
Common::Vec4<f24> dest_out;
s32 address_registers[2];
bool conditional_code[2];
@ -89,7 +89,7 @@ template <DebugDataRecord::Type type, typename ValueType>
inline void SetField(DebugDataRecord& record, ValueType value);
template <>
inline void SetField<DebugDataRecord::SRC1>(DebugDataRecord& record, float24* value) {
inline void SetField<DebugDataRecord::SRC1>(DebugDataRecord& record, f24* value) {
record.src1.x = value[0];
record.src1.y = value[1];
record.src1.z = value[2];
@ -97,7 +97,7 @@ inline void SetField<DebugDataRecord::SRC1>(DebugDataRecord& record, float24* va
}
template <>
inline void SetField<DebugDataRecord::SRC2>(DebugDataRecord& record, float24* value) {
inline void SetField<DebugDataRecord::SRC2>(DebugDataRecord& record, f24* value) {
record.src2.x = value[0];
record.src2.y = value[1];
record.src2.z = value[2];
@ -105,7 +105,7 @@ inline void SetField<DebugDataRecord::SRC2>(DebugDataRecord& record, float24* va
}
template <>
inline void SetField<DebugDataRecord::SRC3>(DebugDataRecord& record, float24* value) {
inline void SetField<DebugDataRecord::SRC3>(DebugDataRecord& record, f24* value) {
record.src3.x = value[0];
record.src3.y = value[1];
record.src3.z = value[2];
@ -113,7 +113,7 @@ inline void SetField<DebugDataRecord::SRC3>(DebugDataRecord& record, float24* va
}
template <>
inline void SetField<DebugDataRecord::DEST_IN>(DebugDataRecord& record, float24* value) {
inline void SetField<DebugDataRecord::DEST_IN>(DebugDataRecord& record, f24* value) {
record.dest_in.x = value[0];
record.dest_in.y = value[1];
record.dest_in.z = value[2];
@ -121,7 +121,7 @@ inline void SetField<DebugDataRecord::DEST_IN>(DebugDataRecord& record, float24*
}
template <>
inline void SetField<DebugDataRecord::DEST_OUT>(DebugDataRecord& record, float24* value) {
inline void SetField<DebugDataRecord::DEST_OUT>(DebugDataRecord& record, f24* value) {
record.dest_out.x = value[0];
record.dest_out.y = value[1];
record.dest_out.z = value[2];

12
src/video_core/shader/shader.cpp
View File

@ -5,10 +5,10 @@
#include <cmath>
#include <cstring>
#include "common/arch.h"
#include "common/assert.h"
#include "common/bit_set.h"
#include "common/logging/log.h"
#include "common/microprofile.h"
#include "video_core/pica_state.h"
#include "video_core/regs_rasterizer.h"
#include "video_core/regs_shader.h"
#include "video_core/shader/shader.h"
@ -41,11 +41,11 @@ OutputVertex OutputVertex::FromAttributeBuffer(const RasterizerRegs& regs,
// Allow us to overflow OutputVertex to avoid branches, since
// RasterizerRegs::VSOutputAttributes::INVALID would write to slot 31, which
// would be out of bounds otherwise.
std::array<float24, 32> vertex_slots_overflow;
std::array<f24, 32> vertex_slots_overflow;
};
// Assert that OutputVertex has enough space for 24 semantic registers
static_assert(sizeof(std::array<float24, 24>) == sizeof(ret),
static_assert(sizeof(std::array<f24, 24>) == sizeof(ret),
"Struct and array have different sizes.");
unsigned int num_attributes = regs.vs_output_total & 7;
@ -61,7 +61,7 @@ OutputVertex OutputVertex::FromAttributeBuffer(const RasterizerRegs& regs,
// interpolation
for (unsigned i = 0; i < 4; ++i) {
float c = std::fabs(ret.color[i].ToFloat32());
ret.color[i] = float24::FromFloat32(c < 1.0f ? c : 1.0f);
ret.color[i] = f24::FromFloat32(c < 1.0f ? c : 1.0f);
}
LOG_TRACE(HW_GPU,
@ -86,7 +86,7 @@ void UnitState::LoadInput(const ShaderRegs& config, const AttributeBuffer& input
}
}
static void CopyRegistersToOutput(std::span<Common::Vec4<float24>, 16> regs, u32 mask,
static void CopyRegistersToOutput(std::span<Common::Vec4<f24>, 16> regs, u32 mask,
AttributeBuffer& buffer) {
int output_i = 0;
for (int reg : Common::BitSet<u32>(mask)) {
@ -108,7 +108,7 @@ GSEmitter::~GSEmitter() {
delete handlers;
}
void GSEmitter::Emit(std::span<Common::Vec4<float24>, 16> output_regs) {
void GSEmitter::Emit(std::span<Common::Vec4<f24>, 16> output_regs) {
ASSERT(vertex_id < 3);
// TODO: This should be merged with UnitState::WriteOutput somehow
CopyRegistersToOutput(output_regs, output_mask, buffer[vertex_id]);

41
src/video_core/shader/shader.h
View File

@ -12,7 +12,6 @@
#include <boost/serialization/access.hpp>
#include <boost/serialization/array.hpp>
#include <boost/serialization/base_object.hpp>
#include "common/assert.h"
#include "common/common_funcs.h"
#include "common/common_types.h"
#include "common/hash.h"
@ -29,7 +28,7 @@ using ProgramCode = std::array<u32, MAX_PROGRAM_CODE_LENGTH>;
using SwizzleData = std::array<u32, MAX_SWIZZLE_DATA_LENGTH>;
struct AttributeBuffer {
alignas(16) Common::Vec4<float24> attr[16];
alignas(16) Common::Vec4<f24> attr[16];
private:
friend class boost::serialization::access;
@ -46,16 +45,16 @@ using VertexHandler = std::function<void(const AttributeBuffer&)>;
using WindingSetter = std::function<void()>;
struct OutputVertex {
Common::Vec4<float24> pos;
Common::Vec4<float24> quat;
Common::Vec4<float24> color;
Common::Vec2<float24> tc0;
Common::Vec2<float24> tc1;
float24 tc0_w;
Common::Vec4<f24> pos;
Common::Vec4<f24> quat;
Common::Vec4<f24> color;
Common::Vec2<f24> tc0;
Common::Vec2<f24> tc1;
f24 tc0_w;
INSERT_PADDING_WORDS(1);
Common::Vec3<float24> view;
Common::Vec3<f24> view;
INSERT_PADDING_WORDS(1);
Common::Vec2<float24> tc2;
Common::Vec2<f24> tc2;
static void ValidateSemantics(const RasterizerRegs& regs);
static OutputVertex FromAttributeBuffer(const RasterizerRegs& regs,
@ -76,7 +75,7 @@ private:
friend class boost::serialization::access;
};
#define ASSERT_POS(var, pos) \
static_assert(offsetof(OutputVertex, var) == pos * sizeof(float24), "Semantic at wrong " \
static_assert(offsetof(OutputVertex, var) == pos * sizeof(f24), "Semantic at wrong " \
"offset.")
ASSERT_POS(pos, RasterizerRegs::VSOutputAttributes::POSITION_X);
ASSERT_POS(quat, RasterizerRegs::VSOutputAttributes::QUATERNION_X);
@ -109,7 +108,7 @@ struct GSEmitter {
GSEmitter();
~GSEmitter();
void Emit(std::span<Common::Vec4<float24>, 16> output_regs);
void Emit(std::span<Common::Vec4<f24>, 16> output_regs);
private:
friend class boost::serialization::access;
@ -136,9 +135,9 @@ struct UnitState {
struct Registers {
// The registers are accessed by the shader JIT using SSE instructions, and are therefore
// required to be 16-byte aligned.
alignas(16) std::array<Common::Vec4<float24>, 16> input;
alignas(16) std::array<Common::Vec4<float24>, 16> temporary;
alignas(16) std::array<Common::Vec4<float24>, 16> output;
alignas(16) std::array<Common::Vec4<f24>, 16> input;
alignas(16) std::array<Common::Vec4<f24>, 16> temporary;
alignas(16) std::array<Common::Vec4<f24>, 16> output;
private:
friend class boost::serialization::access;
@ -160,18 +159,16 @@ struct UnitState {
GSEmitter* emitter_ptr;
static std::size_t InputOffset(int register_index) {
return offsetof(UnitState, registers.input) +
register_index * sizeof(Common::Vec4<float24>);
return offsetof(UnitState, registers.input) + register_index * sizeof(Common::Vec4<f24>);
}
static std::size_t OutputOffset(int register_index) {
return offsetof(UnitState, registers.output) +
register_index * sizeof(Common::Vec4<float24>);
return offsetof(UnitState, registers.output) + register_index * sizeof(Common::Vec4<f24>);
}
static std::size_t TemporaryOffset(int register_index) {
return offsetof(UnitState, registers.temporary) +
register_index * sizeof(Common::Vec4<float24>);
register_index * sizeof(Common::Vec4<f24>);
}
/**
@ -219,13 +216,13 @@ private:
struct Uniforms {
// The float uniforms are accessed by the shader JIT using SSE instructions, and are
// therefore required to be 16-byte aligned.
alignas(16) std::array<Common::Vec4<float24>, 96> f;
alignas(16) std::array<Common::Vec4<f24>, 96> f;
std::array<bool, 16> b;
std::array<Common::Vec4<u8>, 4> i;
static std::size_t GetFloatUniformOffset(unsigned index) {
return offsetof(Uniforms, f) + index * sizeof(Common::Vec4<float24>);
return offsetof(Uniforms, f) + index * sizeof(Common::Vec4<f24>);
}
static std::size_t GetBoolUniformOffset(unsigned index) {

53
src/video_core/shader/shader_interpreter.cpp
View File

@ -80,7 +80,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
const auto& program_code = setup.program_code;
// Placeholder for invalid inputs
static float24 dummy_vec4_float24[4];
static f24 dummy_vec4_float24[4];
unsigned iteration = 0;
bool exit_loop = false;
@ -111,7 +111,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
debug_data.max_offset = std::max<u32>(debug_data.max_offset, 1 + program_counter);
auto LookupSourceRegister = [&](const SourceRegister& source_reg) -> const float24* {
auto LookupSourceRegister = [&](const SourceRegister& source_reg) -> const f24* {
switch (source_reg.GetRegisterType()) {
case RegisterType::Input:
return &state.registers.input[source_reg.GetIndex()].x;
@ -137,15 +137,15 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
? 0
: state.address_registers[instr.common.address_register_index - 1];
const float24* src1_ = LookupSourceRegister(instr.common.GetSrc1(is_inverted) +
const f24* src1_ = LookupSourceRegister(instr.common.GetSrc1(is_inverted) +
(is_inverted ? 0 : address_offset));
const float24* src2_ = LookupSourceRegister(instr.common.GetSrc2(is_inverted) +
const f24* src2_ = LookupSourceRegister(instr.common.GetSrc2(is_inverted) +
(is_inverted ? address_offset : 0));
const bool negate_src1 = ((bool)swizzle.negate_src1 != false);
const bool negate_src2 = ((bool)swizzle.negate_src2 != false);
float24 src1[4] = {
f24 src1[4] = {
src1_[(int)swizzle.src1_selector_0.Value()],
src1_[(int)swizzle.src1_selector_1.Value()],
src1_[(int)swizzle.src1_selector_2.Value()],
@ -157,7 +157,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
src1[2] = -src1[2];
src1[3] = -src1[3];
}
float24 src2[4] = {
f24 src2[4] = {
src2_[(int)swizzle.src2_selector_0.Value()],
src2_[(int)swizzle.src2_selector_1.Value()],
src2_[(int)swizzle.src2_selector_2.Value()],
@ -170,8 +170,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
src2[3] = -src2[3];
}
float24* dest =
(instr.common.dest.Value() < 0x10)
f24* dest = (instr.common.dest.Value() < 0x10)
? &state.registers.output[instr.common.dest.Value().GetIndex()][0]
: (instr.common.dest.Value() < 0x20)
? &state.registers.temporary[instr.common.dest.Value().GetIndex()][0]
@ -216,7 +215,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
if (!swizzle.DestComponentEnabled(i))
continue;
dest[i] = float24::FromFloat32(std::floor(src1[i].ToFloat32()));
dest[i] = f24::FromFloat32(std::floor(src1[i].ToFloat32()));
}
Record<DebugDataRecord::DEST_OUT>(debug_data, iteration, dest);
break;
@ -263,11 +262,10 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
OpCode::Id opcode = instr.opcode.Value().EffectiveOpCode();
if (opcode == OpCode::Id::DPH || opcode == OpCode::Id::DPHI)
src1[3] = float24::FromFloat32(1.0f);
src1[3] = f24::One();
int num_components = (opcode == OpCode::Id::DP3) ? 3 : 4;
float24 dot = std::inner_product(src1, src1 + num_components, src2,
float24::FromFloat32(0.f));
f24 dot = std::inner_product(src1, src1 + num_components, src2, f24::Zero());
for (int i = 0; i < 4; ++i) {
if (!swizzle.DestComponentEnabled(i))
@ -283,7 +281,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
case OpCode::Id::RCP: {
Record<DebugDataRecord::SRC1>(debug_data, iteration, src1);
Record<DebugDataRecord::DEST_IN>(debug_data, iteration, dest);
float24 rcp_res = float24::FromFloat32(1.0f / src1[0].ToFloat32());
f24 rcp_res = f24::FromFloat32(1.0f / src1[0].ToFloat32());
for (int i = 0; i < 4; ++i) {
if (!swizzle.DestComponentEnabled(i))
continue;
@ -298,7 +296,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
case OpCode::Id::RSQ: {
Record<DebugDataRecord::SRC1>(debug_data, iteration, src1);
Record<DebugDataRecord::DEST_IN>(debug_data, iteration, dest);
float24 rsq_res = float24::FromFloat32(1.0f / std::sqrt(src1[0].ToFloat32()));
f24 rsq_res = f24::FromFloat32(1.0f / std::sqrt(src1[0].ToFloat32()));
for (int i = 0; i < 4; ++i) {
if (!swizzle.DestComponentEnabled(i))
continue;
@ -345,8 +343,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
if (!swizzle.DestComponentEnabled(i))
continue;
dest[i] = (src1[i] >= src2[i]) ? float24::FromFloat32(1.0f)
: float24::FromFloat32(0.0f);
dest[i] = (src1[i] >= src2[i]) ? f24::One() : f24::Zero();
}
Record<DebugDataRecord::DEST_OUT>(debug_data, iteration, dest);
break;
@ -360,8 +357,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
if (!swizzle.DestComponentEnabled(i))
continue;
dest[i] = (src1[i] < src2[i]) ? float24::FromFloat32(1.0f)
: float24::FromFloat32(0.0f);
dest[i] = (src1[i] < src2[i]) ? f24::One() : f24::Zero();
}
Record<DebugDataRecord::DEST_OUT>(debug_data, iteration, dest);
break;
@ -413,7 +409,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
Record<DebugDataRecord::DEST_IN>(debug_data, iteration, dest);
// EX2 only takes first component exp2 and writes it to all dest components
float24 ex2_res = float24::FromFloat32(std::exp2(src1[0].ToFloat32()));
f24 ex2_res = f24::FromFloat32(std::exp2(src1[0].ToFloat32()));
for (int i = 0; i < 4; ++i) {
if (!swizzle.DestComponentEnabled(i))
continue;
@ -430,7 +426,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
Record<DebugDataRecord::DEST_IN>(debug_data, iteration, dest);
// LG2 only takes the first component log2 and writes it to all dest components
float24 lg2_res = float24::FromFloat32(std::log2(src1[0].ToFloat32()));
f24 lg2_res = f24::FromFloat32(std::log2(src1[0].ToFloat32()));
for (int i = 0; i < 4; ++i) {
if (!swizzle.DestComponentEnabled(i))
continue;
@ -466,17 +462,17 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
? 0
: state.address_registers[instr.mad.address_register_index - 1];
const float24* src1_ = LookupSourceRegister(instr.mad.GetSrc1(is_inverted));
const float24* src2_ = LookupSourceRegister(instr.mad.GetSrc2(is_inverted) +
const f24* src1_ = LookupSourceRegister(instr.mad.GetSrc1(is_inverted));
const f24* src2_ = LookupSourceRegister(instr.mad.GetSrc2(is_inverted) +
(!is_inverted * address_offset));
const float24* src3_ = LookupSourceRegister(instr.mad.GetSrc3(is_inverted) +
const f24* src3_ = LookupSourceRegister(instr.mad.GetSrc3(is_inverted) +
(is_inverted * address_offset));
const bool negate_src1 = ((bool)mad_swizzle.negate_src1 != false);
const bool negate_src2 = ((bool)mad_swizzle.negate_src2 != false);
const bool negate_src3 = ((bool)mad_swizzle.negate_src3 != false);
float24 src1[4] = {
f24 src1[4] = {
src1_[(int)mad_swizzle.src1_selector_0.Value()],
src1_[(int)mad_swizzle.src1_selector_1.Value()],
src1_[(int)mad_swizzle.src1_selector_2.Value()],
@ -488,7 +484,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
src1[2] = -src1[2];
src1[3] = -src1[3];
}
float24 src2[4] = {
f24 src2[4] = {
src2_[(int)mad_swizzle.src2_selector_0.Value()],
src2_[(int)mad_swizzle.src2_selector_1.Value()],
src2_[(int)mad_swizzle.src2_selector_2.Value()],
@ -500,7 +496,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
src2[2] = -src2[2];
src2[3] = -src2[3];
}
float24 src3[4] = {
f24 src3[4] = {
src3_[(int)mad_swizzle.src3_selector_0.Value()],
src3_[(int)mad_swizzle.src3_selector_1.Value()],
src3_[(int)mad_swizzle.src3_selector_2.Value()],
@ -513,8 +509,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
src3[3] = -src3[3];
}
float24* dest =
(instr.mad.dest.Value() < 0x10)
f24* dest = (instr.mad.dest.Value() < 0x10)
? &state.registers.output[instr.mad.dest.Value().GetIndex()][0]
: (instr.mad.dest.Value() < 0x20)
? &state.registers.temporary[instr.mad.dest.Value().GetIndex()][0]
@ -687,7 +682,7 @@ DebugData<true> InterpreterEngine::ProduceDebugInfo(const ShaderSetup& setup,
DebugData<true> debug_data;
// Setup input register table
state.registers.input.fill(Common::Vec4<float24>::AssignToAll(float24::Zero()));
state.registers.input.fill(Common::Vec4<f24>::AssignToAll(f24::Zero()));
state.LoadInput(config, input);
RunInterpreter(setup, state, debug_data, setup.engine_data.entry_point);
return debug_data;

1
src/video_core/shader/shader_jit_x64.cpp
View File

@ -5,6 +5,7 @@
#include "common/arch.h"
#if CITRA_ARCH(x86_64)
#include "common/assert.h"
#include "common/microprofile.h"
#include "video_core/shader/shader.h"
#include "video_core/shader/shader_jit_x64.h"

2
src/video_core/shader/shader_jit_x64_compiler.cpp
View File

@ -813,7 +813,7 @@ void JitShader::Compile_JMP(Instruction instr) {
}
}
static void Emit(GSEmitter* emitter, Common::Vec4<float24> (*output)[16]) {
static void Emit(GSEmitter* emitter, Common::Vec4<f24> (*output)[16]) {
emitter->Emit(*output);
}

11
src/video_core/vertex_loader.cpp
View File

@ -98,7 +98,7 @@ void VertexLoader::LoadVertex(u32 base_address, int index, int vertex,
const s8* srcdata = reinterpret_cast<const s8*>(
VideoCore::g_memory->GetPhysicalPointer(source_addr));
for (unsigned int comp = 0; comp < vertex_attribute_elements[i]; ++comp) {
input.attr[i][comp] = float24::FromFloat32(srcdata[comp]);
input.attr[i][comp] = f24::FromFloat32(srcdata[comp]);
}
break;
}
@ -106,7 +106,7 @@ void VertexLoader::LoadVertex(u32 base_address, int index, int vertex,
const u8* srcdata = reinterpret_cast<const u8*>(
VideoCore::g_memory->GetPhysicalPointer(source_addr));
for (unsigned int comp = 0; comp < vertex_attribute_elements[i]; ++comp) {
input.attr[i][comp] = float24::FromFloat32(srcdata[comp]);
input.attr[i][comp] = f24::FromFloat32(srcdata[comp]);
}
break;
}
@ -114,7 +114,7 @@ void VertexLoader::LoadVertex(u32 base_address, int index, int vertex,
const s16* srcdata = reinterpret_cast<const s16*>(
VideoCore::g_memory->GetPhysicalPointer(source_addr));
for (unsigned int comp = 0; comp < vertex_attribute_elements[i]; ++comp) {
input.attr[i][comp] = float24::FromFloat32(srcdata[comp]);
input.attr[i][comp] = f24::FromFloat32(srcdata[comp]);
}
break;
}
@ -122,7 +122,7 @@ void VertexLoader::LoadVertex(u32 base_address, int index, int vertex,
const float* srcdata = reinterpret_cast<const float*>(
VideoCore::g_memory->GetPhysicalPointer(source_addr));
for (unsigned int comp = 0; comp < vertex_attribute_elements[i]; ++comp) {
input.attr[i][comp] = float24::FromFloat32(srcdata[comp]);
input.attr[i][comp] = f24::FromFloat32(srcdata[comp]);
}
break;
}
@ -132,8 +132,7 @@ void VertexLoader::LoadVertex(u32 base_address, int index, int vertex,
// is *not* carried over from the default attribute settings even if they're
// enabled for this attribute.
for (unsigned int comp = vertex_attribute_elements[i]; comp < 4; ++comp) {
input.attr[i][comp] =
comp == 3 ? float24::FromFloat32(1.0f) : float24::FromFloat32(0.0f);
input.attr[i][comp] = comp == 3 ? f24::One() : f24::Zero();
}
LOG_TRACE(HW_GPU,

2
src/video_core/video_core.cpp
View File

@ -40,7 +40,7 @@ void Init(Frontend::EmuWindow& emu_window, Frontend::EmuWindow* secondary_window
switch (graphics_api) {
case Settings::GraphicsAPI::Software:
g_renderer = std::make_unique<VideoCore::RendererSoftware>(system, emu_window);
g_renderer = std::make_unique<SwRenderer::RendererSoftware>(system, emu_window);
break;
case Settings::GraphicsAPI::OpenGL:
g_renderer = std::make_unique<OpenGL::RendererOpenGL>(system, emu_window, secondary_window);