mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-14 21:37:52 -07:00
0cced44142
Per https://en.cppreference.com/w/cpp/preprocessor/replace#.23_and_.23.23_operators the `##` behavior is a nonstandard extension; this extension seems to be supported by all compilers we care about, but IntelliSense in visual studio doesn't correctly handle it, resulting in false errors in the IDE (but not when compiling). Per https://en.cppreference.com/w/cpp/preprocessor/replace#Function-like_macros C++20 introduced a workaround, where `__VA_OPT__(, )` generates a comma if and only if `__VA_ARGS__` is non-empty. This PR replaces all occurrences, with the exception of Externals, DSPSpy (which is not likely to be edited in MSVC and does not target C++20 currently), and JitArm64_Integer.cpp (which uses `Function(__VA_ARGS__)`, and thus does not ever need a comma).
135 lines
3.6 KiB
C++
135 lines
3.6 KiB
C++
// Copyright 2008 Dolphin Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#pragma once
|
|
|
|
#include <algorithm>
|
|
|
|
#include "Common/BitUtils.h"
|
|
#include "Common/CommonTypes.h"
|
|
|
|
#include "VideoCommon/BPMemory.h"
|
|
|
|
// These are accurate (disregarding AA modes).
|
|
constexpr u32 EFB_WIDTH = 640;
|
|
constexpr u32 EFB_HEIGHT = 528;
|
|
|
|
// Max XFB width is 720. You can only copy out 640 wide areas of efb to XFB
|
|
// so you need multiple copies to do the full width.
|
|
// The VI can do horizontal scaling (TODO: emulate).
|
|
constexpr u32 MAX_XFB_WIDTH = 720;
|
|
|
|
// Although EFB height is 528, 576-line XFB's can be created either with
|
|
// vertical scaling by the EFB copy operation or copying to multiple XFB's
|
|
// that are next to each other in memory (TODO: handle that situation).
|
|
constexpr u32 MAX_XFB_HEIGHT = 576;
|
|
|
|
#define PRIM_LOG(t, ...) DEBUG_LOG_FMT(VIDEO, t __VA_OPT__(, ) __VA_ARGS__)
|
|
|
|
// warning: mapping buffer should be disabled to use this
|
|
// #define LOG_VTX() DEBUG_LOG_FMT(VIDEO, "vtx: {} {} {}, ",
|
|
// ((float*)g_vertex_manager_write_ptr)[-3],
|
|
// ((float*)g_vertex_manager_write_ptr)[-2],
|
|
// ((float*)g_vertex_manager_write_ptr)[-1]);
|
|
|
|
#define LOG_VTX()
|
|
|
|
enum class APIType
|
|
{
|
|
OpenGL,
|
|
D3D,
|
|
Vulkan,
|
|
Metal,
|
|
Nothing
|
|
};
|
|
|
|
inline u32 RGBA8ToRGBA6ToRGBA8(u32 src)
|
|
{
|
|
u32 color = src;
|
|
color &= 0xFCFCFCFC;
|
|
color |= (color >> 6) & 0x03030303;
|
|
return color;
|
|
}
|
|
|
|
inline u32 RGBA8ToRGB565ToRGBA8(u32 src)
|
|
{
|
|
u32 color = (src & 0xF8FCF8);
|
|
color |= (color >> 5) & 0x070007;
|
|
color |= (color >> 6) & 0x000300;
|
|
color |= 0xFF000000;
|
|
return color;
|
|
}
|
|
|
|
inline u32 Z24ToZ16ToZ24(u32 src)
|
|
{
|
|
return (src & 0xFFFF00) | (src >> 16);
|
|
}
|
|
|
|
inline u32 CompressZ16(u32 z24depth, DepthFormat format)
|
|
{
|
|
// Flipper offers a number of choices for 16bit Z formats that adjust
|
|
// where the bulk of the precision lies.
|
|
|
|
if (format == DepthFormat::ZLINEAR)
|
|
{
|
|
// This is just a linear depth buffer with 16 bits of precision
|
|
return z24depth >> 8;
|
|
}
|
|
|
|
// ZNEAR/ZMID/ZFAR are custom floating point formats with 2/3/4 bits of exponent
|
|
// The exponent is simply the number of leading ones that have been removed
|
|
// The first zero bit is skipped and not stored. The mantissa contains the next 14/13/12 bits
|
|
// If exponent is at the MAX (3, 7, or 12) then the next bit might still be a one, and can't
|
|
// be skipped, so the mantissa simply contains the next 14/13/12 bits
|
|
|
|
u32 leading_ones = Common::CountLeadingZeros((~z24depth) << 8);
|
|
bool next_bit_is_one = false; // AKA: Did we clamp leading_ones?
|
|
u32 exp_bits;
|
|
|
|
switch (format)
|
|
{
|
|
case DepthFormat::ZNEAR:
|
|
exp_bits = 2;
|
|
if (leading_ones >= 3u)
|
|
{
|
|
leading_ones = 3u;
|
|
next_bit_is_one = true;
|
|
}
|
|
break;
|
|
case DepthFormat::ZMID:
|
|
exp_bits = 3;
|
|
if (leading_ones >= 7u)
|
|
{
|
|
leading_ones = 7u;
|
|
next_bit_is_one = true;
|
|
}
|
|
break;
|
|
case DepthFormat::ZFAR:
|
|
exp_bits = 4;
|
|
if (leading_ones >= 12u)
|
|
{
|
|
// The hardware implementation only uses values 0 to 12 in the exponent
|
|
leading_ones = 12u;
|
|
next_bit_is_one = true;
|
|
}
|
|
break;
|
|
default:
|
|
return z24depth >> 8;
|
|
}
|
|
|
|
u32 mantissa_bits = 16 - exp_bits;
|
|
|
|
// Calculate which bits we need to extract from z24depth for our mantissa
|
|
u32 top = std::max<u32>(24 - leading_ones, mantissa_bits);
|
|
if (!next_bit_is_one)
|
|
{
|
|
top -= 1; // We know the next bit is zero, so we don't need to include it.
|
|
}
|
|
u32 bottom = top - mantissa_bits;
|
|
|
|
u32 exponent = leading_ones << mantissa_bits; // Upper bits contain exponent
|
|
u32 mantissa = Common::ExtractBits(z24depth, bottom, top - 1);
|
|
|
|
return exponent | mantissa;
|
|
}
|