hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity

early-access version 3497

Browse Source
This commit is contained in:
pineappleEA 2023-04-03 21:50:53 +02:00
parent e16291336e
commit 53406e5574
7 changed files with 69 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -1,7 +1,7 @@
yuzu emulator early access yuzu emulator early access
============= =============
This is the source code for early-access 3493. This is the source code for early-access 3497.
## Legal Notice ## Legal Notice

23
src/core/arm/dynarmic/arm_dynarmic_32.cpp
View File

@ -5,7 +5,6 @@
#include <memory> #include <memory>
#include <dynarmic/interface/A32/a32.h> #include <dynarmic/interface/A32/a32.h>
#include <dynarmic/interface/A32/config.h> #include <dynarmic/interface/A32/config.h>
#include <dynarmic/interface/A32/context.h>
#include "common/assert.h" #include "common/assert.h"
#include "common/literals.h" #include "common/literals.h"
#include "common/logging/log.h" #include "common/logging/log.h"
@ -410,21 +409,19 @@ void ARM_Dynarmic_32::SetTPIDR_EL0(u64 value) {
} }
void ARM_Dynarmic_32::SaveContext(ThreadContext32& ctx) { void ARM_Dynarmic_32::SaveContext(ThreadContext32& ctx) {
Dynarmic::A32::Context context; Dynarmic::A32::Jit* j = jit.load();
jit.load()->SaveContext(context); ctx.cpu_registers = j->Regs();
ctx.cpu_registers = context.Regs(); ctx.extension_registers = j->ExtRegs();
ctx.extension_registers = context.ExtRegs(); ctx.cpsr = j->Cpsr();
ctx.cpsr = context.Cpsr(); ctx.fpscr = j->Fpscr();
ctx.fpscr = context.Fpscr();
} }
void ARM_Dynarmic_32::LoadContext(const ThreadContext32& ctx) { void ARM_Dynarmic_32::LoadContext(const ThreadContext32& ctx) {
Dynarmic::A32::Context context; Dynarmic::A32::Jit* j = jit.load();
context.Regs() = ctx.cpu_registers; j->Regs() = ctx.cpu_registers;
context.ExtRegs() = ctx.extension_registers; j->ExtRegs() = ctx.extension_registers;
context.SetCpsr(ctx.cpsr); j->SetCpsr(ctx.cpsr);
context.SetFpscr(ctx.fpscr); j->SetFpscr(ctx.fpscr);
jit.load()->LoadContext(context);
} }
void ARM_Dynarmic_32::SignalInterrupt() { void ARM_Dynarmic_32::SignalInterrupt() {

6
src/core/hle/service/hid/controllers/npad.cpp
View File

@ -70,7 +70,6 @@ Result Controller_NPad::VerifyValidSixAxisSensorHandle(
const Core::HID::SixAxisSensorHandle& device_handle) { const Core::HID::SixAxisSensorHandle& device_handle) {
const auto npad_id = IsNpadIdValid(static_cast<Core::HID::NpadIdType>(device_handle.npad_id)); const auto npad_id = IsNpadIdValid(static_cast<Core::HID::NpadIdType>(device_handle.npad_id));
const bool device_index = device_handle.device_index < Core::HID::DeviceIndex::MaxDeviceIndex; const bool device_index = device_handle.device_index < Core::HID::DeviceIndex::MaxDeviceIndex;
const bool npad_type = device_handle.npad_type < Core::HID::NpadStyleIndex::MaxNpadType;
if (!npad_id) { if (!npad_id) {
return InvalidNpadId; return InvalidNpadId;
@ -78,10 +77,6 @@ Result Controller_NPad::VerifyValidSixAxisSensorHandle(
if (!device_index) { if (!device_index) {
return NpadDeviceIndexOutOfRange; return NpadDeviceIndexOutOfRange;
} }
// This doesn't get validated on nnsdk
if (!npad_type) {
return NpadInvalidHandle;
}
return ResultSuccess; return ResultSuccess;
} }
@ -1131,6 +1126,7 @@ Result Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
WriteEmptyEntry(shared_memory); WriteEmptyEntry(shared_memory);
return ResultSuccess; return ResultSuccess;
} }
Result Controller_NPad::SetGyroscopeZeroDriftMode( Result Controller_NPad::SetGyroscopeZeroDriftMode(
const Core::HID::SixAxisSensorHandle& sixaxis_handle, const Core::HID::SixAxisSensorHandle& sixaxis_handle,
Core::HID::GyroscopeZeroDriftMode drift_mode) { Core::HID::GyroscopeZeroDriftMode drift_mode) {

8
src/video_core/engines/maxwell_3d.h
View File

@ -856,8 +856,8 @@ public:
struct ZetaSize { struct ZetaSize {
enum class DimensionControl : u32 { enum class DimensionControl : u32 {
DepthDefinesArray = 0, DefineArraySize = 0,
ArraySizeOne = 1, ArraySizeIsOne = 1,
}; };
u32 width; u32 width;
@ -1104,8 +1104,8 @@ public:
struct TileMode { struct TileMode {
enum class DimensionControl : u32 { enum class DimensionControl : u32 {
DepthDefinesArray = 0, DefineArraySize = 0,
DepthDefinesDepth = 1, DefineDepthSize = 1,
}; };
union { union {
BitField<0, 4, u32> block_width; BitField<0, 4, u32> block_width;

88
src/video_core/texture_cache/image_info.cpp
View File

@ -14,6 +14,7 @@
namespace VideoCommon { namespace VideoCommon {
using Tegra::Engines::Fermi2D;
using Tegra::Engines::Maxwell3D; using Tegra::Engines::Maxwell3D;
using Tegra::Texture::TextureType; using Tegra::Texture::TextureType;
using Tegra::Texture::TICEntry; using Tegra::Texture::TICEntry;
@ -114,86 +115,89 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
} }
} }
ImageInfo::ImageInfo(const Maxwell3D::Regs& regs, size_t index) noexcept { ImageInfo::ImageInfo(const Maxwell3D::Regs::RenderTargetConfig& ct,
const auto& rt = regs.rt[index]; Tegra::Texture::MsaaMode msaa_mode) noexcept {
format = VideoCore::Surface::PixelFormatFromRenderTargetFormat(rt.format); format = VideoCore::Surface::PixelFormatFromRenderTargetFormat(ct.format);
rescaleable = false; rescaleable = false;
if (rt.tile_mode.is_pitch_linear) { if (ct.tile_mode.is_pitch_linear) {
ASSERT(rt.tile_mode.dim_control == ASSERT(ct.tile_mode.dim_control ==
Maxwell3D::Regs::TileMode::DimensionControl::DepthDefinesArray); Maxwell3D::Regs::TileMode::DimensionControl::DefineArraySize);
type = ImageType::Linear; type = ImageType::Linear;
pitch = rt.width; pitch = ct.width;
size = Extent3D{ size = Extent3D{
.width = pitch / BytesPerBlock(format), .width = pitch / BytesPerBlock(format),
.height = rt.height, .height = ct.height,
.depth = 1, .depth = 1,
}; };
return; return;
} }
size.width = rt.width; size.width = ct.width;
size.height = rt.height; size.height = ct.height;
layer_stride = rt.array_pitch * 4; layer_stride = ct.array_pitch * 4;
maybe_unaligned_layer_stride = layer_stride; maybe_unaligned_layer_stride = layer_stride;
num_samples = NumSamples(regs.anti_alias_samples_mode); num_samples = NumSamples(msaa_mode);
block = Extent3D{ block = Extent3D{
.width = rt.tile_mode.block_width, .width = ct.tile_mode.block_width,
.height = rt.tile_mode.block_height, .height = ct.tile_mode.block_height,
.depth = rt.tile_mode.block_depth, .depth = ct.tile_mode.block_depth,
}; };
if (rt.tile_mode.dim_control == if (ct.tile_mode.dim_control == Maxwell3D::Regs::TileMode::DimensionControl::DefineDepthSize) {
Maxwell3D::Regs::TileMode::DimensionControl::DepthDefinesDepth) {
type = ImageType::e3D; type = ImageType::e3D;
size.depth = rt.depth; size.depth = ct.depth;
} else { } else {
rescaleable = block.depth == 0; rescaleable = block.depth == 0;
rescaleable &= size.height > 256; rescaleable &= size.height > 256;
downscaleable = size.height > 512; downscaleable = size.height > 512;
type = ImageType::e2D; type = ImageType::e2D;
resources.layers = rt.depth; resources.layers = ct.depth;
} }
} }
ImageInfo::ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs) noexcept { ImageInfo::ImageInfo(const Maxwell3D::Regs::Zeta& zt, const Maxwell3D::Regs::ZetaSize& zt_size,
format = VideoCore::Surface::PixelFormatFromDepthFormat(regs.zeta.format); Tegra::Texture::MsaaMode msaa_mode) noexcept {
size.width = regs.zeta_size.width; format = VideoCore::Surface::PixelFormatFromDepthFormat(zt.format);
size.height = regs.zeta_size.height; size.width = zt_size.width;
size.height = zt_size.height;
rescaleable = false; rescaleable = false;
resources.levels = 1; resources.levels = 1;
layer_stride = regs.zeta.array_pitch * 4; layer_stride = zt.array_pitch * 4;
maybe_unaligned_layer_stride = layer_stride; maybe_unaligned_layer_stride = layer_stride;
num_samples = NumSamples(regs.anti_alias_samples_mode); num_samples = NumSamples(msaa_mode);
block = Extent3D{ block = Extent3D{
.width = regs.zeta.tile_mode.block_width, .width = zt.tile_mode.block_width,
.height = regs.zeta.tile_mode.block_height, .height = zt.tile_mode.block_height,
.depth = regs.zeta.tile_mode.block_depth, .depth = zt.tile_mode.block_depth,
}; };
if (regs.zeta.tile_mode.is_pitch_linear) { if (zt.tile_mode.is_pitch_linear) {
ASSERT(regs.zeta.tile_mode.dim_control == ASSERT(zt.tile_mode.dim_control ==
Maxwell3D::Regs::TileMode::DimensionControl::DepthDefinesArray); Maxwell3D::Regs::TileMode::DimensionControl::DefineArraySize);
type = ImageType::Linear; type = ImageType::Linear;
pitch = size.width * BytesPerBlock(format); pitch = size.width * BytesPerBlock(format);
} else if (regs.zeta.tile_mode.dim_control == } else if (zt.tile_mode.dim_control ==
Maxwell3D::Regs::TileMode::DimensionControl::DepthDefinesDepth) { Maxwell3D::Regs::TileMode::DimensionControl::DefineDepthSize) {
ASSERT(regs.zeta.tile_mode.is_pitch_linear == 0); ASSERT(zt_size.dim_control == Maxwell3D::Regs::ZetaSize::DimensionControl::ArraySizeIsOne);
ASSERT(regs.zeta_size.dim_control ==
Maxwell3D::Regs::ZetaSize::DimensionControl::ArraySizeOne);
type = ImageType::e3D; type = ImageType::e3D;
size.depth = regs.zeta_size.depth; size.depth = zt_size.depth;
} else { } else {
ASSERT(regs.zeta_size.dim_control ==
Maxwell3D::Regs::ZetaSize::DimensionControl::DepthDefinesArray);
rescaleable = block.depth == 0; rescaleable = block.depth == 0;
downscaleable = size.height > 512; downscaleable = size.height > 512;
type = ImageType::e2D; type = ImageType::e2D;
resources.layers = regs.zeta_size.depth; switch (zt_size.dim_control) {
case Maxwell3D::Regs::ZetaSize::DimensionControl::DefineArraySize:
resources.layers = zt_size.depth;
break;
case Maxwell3D::Regs::ZetaSize::DimensionControl::ArraySizeIsOne:
resources.layers = 1;
break;
}
} }
} }
ImageInfo::ImageInfo(const Tegra::Engines::Fermi2D::Surface& config) noexcept { ImageInfo::ImageInfo(const Fermi2D::Surface& config) noexcept {
UNIMPLEMENTED_IF_MSG(config.layer != 0, "Surface layer is not zero"); UNIMPLEMENTED_IF_MSG(config.layer != 0, "Surface layer is not zero");
format = VideoCore::Surface::PixelFormatFromRenderTargetFormat(config.format); format = VideoCore::Surface::PixelFormatFromRenderTargetFormat(config.format);
rescaleable = false; rescaleable = false;
if (config.linear == Tegra::Engines::Fermi2D::MemoryLayout::Pitch) { if (config.linear == Fermi2D::MemoryLayout::Pitch) {
type = ImageType::Linear; type = ImageType::Linear;
size = Extent3D{ size = Extent3D{
.width = config.pitch / VideoCore::Surface::BytesPerBlock(format), .width = config.pitch / VideoCore::Surface::BytesPerBlock(format),

7
src/video_core/texture_cache/image_info.h
View File

@ -17,8 +17,11 @@ using VideoCore::Surface::PixelFormat;
struct ImageInfo { struct ImageInfo {
ImageInfo() = default; ImageInfo() = default;
explicit ImageInfo(const TICEntry& config) noexcept; explicit ImageInfo(const TICEntry& config) noexcept;
explicit ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs, size_t index) noexcept; explicit ImageInfo(const Tegra::Engines::Maxwell3D::Regs::RenderTargetConfig& ct,
explicit ImageInfo(const Tegra::Engines::Maxwell3D::Regs& regs) noexcept; Tegra::Texture::MsaaMode msaa_mode) noexcept;
explicit ImageInfo(const Tegra::Engines::Maxwell3D::Regs::Zeta& zt,
const Tegra::Engines::Maxwell3D::Regs::ZetaSize& zt_size,
Tegra::Texture::MsaaMode msaa_mode) noexcept;
explicit ImageInfo(const Tegra::Engines::Fermi2D::Surface& config) noexcept; explicit ImageInfo(const Tegra::Engines::Fermi2D::Surface& config) noexcept;
explicit ImageInfo(const Tegra::DMA::ImageOperand& config) noexcept; explicit ImageInfo(const Tegra::DMA::ImageOperand& config) noexcept;

4
src/video_core/texture_cache/texture_cache.h
View File

@ -1503,7 +1503,7 @@ ImageViewId TextureCache<P>::FindColorBuffer(size_t index, bool is_clear) {
if (rt.format == Tegra::RenderTargetFormat::NONE) { if (rt.format == Tegra::RenderTargetFormat::NONE) {
return ImageViewId{}; return ImageViewId{};
} }
const ImageInfo info(regs, index); const ImageInfo info(regs.rt[index], regs.anti_alias_samples_mode);
return FindRenderTargetView(info, gpu_addr, is_clear); return FindRenderTargetView(info, gpu_addr, is_clear);
} }
@ -1517,7 +1517,7 @@ ImageViewId TextureCache<P>::FindDepthBuffer(bool is_clear) {
if (gpu_addr == 0) { if (gpu_addr == 0) {
return ImageViewId{}; return ImageViewId{};
} }
const ImageInfo info(regs); const ImageInfo info(regs.zeta, regs.zeta_size, regs.anti_alias_samples_mode);
return FindRenderTargetView(info, gpu_addr, is_clear); return FindRenderTargetView(info, gpu_addr, is_clear);
} }