Mirror-bot/AnyPS5
1
0 Fork 0
mirror of https://github.com/boykopovar/AnyPS5.git synced 2026-10-27 00:28:14 +00:00
Code Issues Projects Releases Activity
Files
53212b18ac1c7562bddb73c352f1663fc348a5c0
AnyPS5/core/shader/recompiler/CacheKey.hpp
T
Mouad-Scriptz-0andClaude Fable 5.1 53212b18ac feat(agc): remap a viewport depth range the device cannot express into the vertex shader 
Without VK_EXT_depth_range_unrestricted a viewport depth range outside
[0, 1] threw. Minecraft (PPSA17221) draws its world with scale 1 and
offset 0 in negative-one-to-one clip space, so its depth is the raw z/w
clamped by PA_SC_VPORT_ZMIN/ZMAX. On such a device the vertex shader now
scales clip z so z/w is the console's depth, the pipeline clamps depth at
the console's bounds, and two clip distances restore the near and far
planes that depth clamping removes. Mode, scale and offset travel as
pipeline specialization constants from the draw's vertex stage info, in
both the per-draw and the registration-module path; mesh and tessellation
draws with such a range still throw.

The console's depth clamp bounds are clipped to [0, 1]: exact for a
normalized depth target or none, and reported once for a tested or
written float depth target, where a depth below 0 is stored as 0
(Minecraft clamps its float depth target to [-1, 1]). The shader
validator accepts the remap's two extra clip distances next to the one
a program may already export.

Co-Authored-By: Claude Fable 5.1 <[email protected]>
2026-10-18 14:27:48 +13:00

276 lines
12 KiB
C++
Raw Blame History

#ifndef CORE_SHADER_RECOMPILER_CACHEKEY_HPP
#define CORE_SHADER_RECOMPILER_CACHEKEY_HPP
#include "Recompiler.hpp"
#include "RdnaDecoder/RdnaDescriptorFormat.hpp"
#include "prx/libc/include/HostThreadLocal.hpp"
#include <cstdlib>
#include <stdexcept>
#include <type_traits>
namespace ShaderRecompiler {
class RecompileCacheKey {
public:
static void Build(const RecompileRequest& request, std::vector<std::uint64_t>& key) {
key.clear();
append(key, RuntimeAbi::Version);
append(key, request.shader.stage);
// The code enters as a hash rather than word by word: the key is built, hashed and compared
// on every dispatch and draw. The cache verifies a match against the code it stored.
// Debug aid: APS5_NO_CODE_HASH_KEY=1 appends every code word, as before.
static const bool hashedCode = std::getenv("APS5_NO_CODE_HASH_KEY") == nullptr;
if (hashedCode) {
append(key, request.shader.code.size());
append(key, HashCode(request.shader.code));
} else {
append(key, request.shader.code);
}
appendInterface(key, request);
}
static void BuildInterface(const RecompileRequest& request, std::vector<std::uint64_t>& key) {
key.clear();
append(key, RuntimeAbi::Version);
append(key, request.shader.stage);
appendInterface(key, request);
}
// A hash over every field Build appends except the code, the target and the probe flag: the
// key of a source memo whose owner fixes the code (a registered shader at an offset) and the
// device itself, and which is bypassed while the probe is active.
static std::uint64_t ContextHash(const RecompileRequest& request) {
struct ContextKeyStorage {};
auto& key = HostThreadLocal<std::vector<std::uint64_t>, ContextKeyStorage>();
key.clear();
append(key, RuntimeAbi::Version);
append(key, request.shader.stage);
append(key, request.context.waveSize);
append(key, request.context.userDataBaseRegister);
append(key, request.context.userData.size());
append(key, request.context.compute);
append(key, request.context.pixel);
append(key, request.context.vertex);
append(key, request.context.floatMode);
appendFallbacks(key, request);
appendMesh(key, request);
appendTessellation(key, request);
std::uint64_t hash = 0xcbf29ce484222325ull;
for (const auto value : key) {
hash ^= value;
hash *= 0x100000001b3ull;
}
return hash;
}
// A 64-bit hash of the code, two dwords per step; collisions are resolved by comparing the code.
static std::uint64_t HashCode(std::span<const std::uint32_t> code) {
std::uint64_t hash = 0x9e3779b97f4a7c15ull ^ (static_cast<std::uint64_t>(code.size()) * 0x100000001b3ull);
const auto mix = [&](std::uint64_t chunk) {
hash = (hash ^ chunk) * 0x9e3779b97f4a7c15ull;
hash ^= hash >> 29u;
};
std::size_t index = 0;
for (; index + 2 <= code.size(); index += 2) mix(code[index] | (static_cast<std::uint64_t>(code[index + 1]) << 32u));
if (index < code.size()) mix(code[index]);
return hash;
}
private:
static void appendInterface(std::vector<std::uint64_t>& key, const RecompileRequest& request) {
append(key, request.context.waveSize);
append(key, request.context.userDataBaseRegister);
append(key, request.context.userData.size());
append(key, request.context.compute);
append(key, request.context.pixel);
append(key, request.context.vertex);
append(key, request.context.floatMode);
appendFallbacks(key, request);
appendMesh(key, request);
appendTessellation(key, request);
append(key, request.target);
append(key, DebugProbeActive());
append(key, RayTracingStrict());
append(key, RayTracingMiss());
}
static void appendFallbacks(std::vector<std::uint64_t>& key, const RecompileRequest& request) {
append(key, request.context.linkedCallFallbacks.size());
for (const auto programCounter : request.context.linkedCallFallbacks) append(key, programCounter);
}
static void appendMesh(std::vector<std::uint64_t>& key, const RecompileRequest& request) {
if (request.shader.stage != ShaderStage::Mesh) return;
const auto* mesh = request.graphics && request.graphics->mesh ? &*request.graphics->mesh : nullptr;
append(key, mesh != nullptr);
if (mesh == nullptr) return;
for (const auto value : {mesh->inputPrimitive, mesh->primitivesPerGroup, mesh->verticesPerGroup, mesh->maxVertices, mesh->maxPrimitives, mesh->threadsPerGroup, mesh->ldsSizeDwords, mesh->provokingVertex, mesh->esgsItemSize, mesh->outputPrimitiveSize}) append(key, value);
}
static void appendTessellation(std::vector<std::uint64_t>& key, const RecompileRequest& request) {
if (request.shader.stage != ShaderStage::Local && request.shader.stage != ShaderStage::TessellationControl && request.shader.stage != ShaderStage::TessellationEvaluation) return;
const auto* tessellation = request.graphics && request.graphics->tessellation ? &*request.graphics->tessellation : nullptr;
append(key, tessellation != nullptr);
if (tessellation == nullptr) return;
for (const auto value : {tessellation->inputControlPoints, tessellation->outputControlPoints, tessellation->domain, tessellation->partitioning, tessellation->outputTopology}) append(key, value);
if (request.shader.stage == ShaderStage::Local) return;
append(key, tessellation->patchesPerGroup);
append(key, tessellation->primitiveGroupSize);
append(key, TessellationInstancePatches(request));
}
template<typename TValue>
static void append(std::vector<std::uint64_t>& key, TValue value) requires (std::is_integral_v<TValue> || std::is_enum_v<TValue>) {
key.push_back(static_cast<std::uint64_t>(value));
}
template<typename TValue, std::size_t TSize>
static void append(std::vector<std::uint64_t>& key, const std::array<TValue, TSize>& values) {
for (const auto value : values) append(key, value);
}
template<typename TValue>
static void append(std::vector<std::uint64_t>& key, std::span<TValue> values) {
append(key, values.size());
for (const auto value : values) append(key, value);
}
template<typename TValue>
static void append(std::vector<std::uint64_t>& key, const std::optional<TValue>& value) {
append(key, value.has_value());
if (value) append(key, *value);
}
static void append(std::vector<std::uint64_t>& key, std::string_view value) {
append(key, value.size());
for (const unsigned char byte : value) append(key, byte);
}
static void append(std::vector<std::uint64_t>& key, const ShaderFloatMode& value) {
append(key, value.floatMode);
append(key, value.dx10Clamp);
append(key, value.ieeeMode);
append(key, value.fp16Overflow);
}
static void append(std::vector<std::uint64_t>& key, const ShaderComputeStageInfo& value) {
append(key, value.numThreads);
append(key, value.ldsSizeDwords);
append(key, value.groupIdEnable);
append(key, value.tgSizeEnable);
append(key, value.threadIdComponentCount);
append(key, value.PartialGroups());
append(key, value.scratchDwords);
}
static void append(std::vector<std::uint64_t>& key, const ShaderPixelStageInfo& value) {
append(key, value.interpolatorCount);
if (value.interpolatorCount > value.interpolatorSettings.size()) throw std::runtime_error("Shader cache: invalid interpolator count");
for (std::uint32_t i = 0; i < value.interpolatorCount; ++i) append(key, value.interpolatorSettings[i]);
append(key, value.wave32);
append(key, value.inputAddr);
append(key, value.hasPerspectiveCenterVgpr);
append(key, value.perspectiveCentroid);
append(key, value.posX);
append(key, value.posY);
append(key, value.posZ);
append(key, value.posW);
append(key, value.frontFace);
append(key, value.frontFaceAllBits);
append(key, value.ancillary);
append(key, value.sampleShading);
append(key, value.noPerspective);
append(key, value.linearCentroid);
append(key, value.pixelKillEnable);
append(key, value.depthExportEnable);
append(key, value.sampleMaskExportEnable);
append(key, value.earlyZ);
append(key, value.executeOnNoop);
append(key, value.conservativeZExport);
append(key, value.orderedPixelShader);
append(key, value.alphaToCoverage);
append(key, value.stencilRefExportEnable);
append(key, value.ditheredAlphaToCoverage);
append(key, value.quadPixelMask);
append(key, value.quadSampleMask);
append(key, value.targetOutputMode);
}
static void append(std::vector<std::uint64_t>& key, const ShaderVertexResourceDestination& value) {
append(key, value.registerStart);
append(key, value.registersNum);
append(key, value.attrId);
append(key, value.fetchIndex);
}
static void append(std::vector<std::uint64_t>& key, const ShaderVertexStageInfo& value) {
append(key, value.fetchAttribReg);
append(key, value.fetchBufferReg);
append(key, value.fetchEmbedded);
append(key, value.paClVsOutCntl);
append(key, value.depthRemapMode);
append(key, value.depthRemapScale);
append(key, value.depthRemapOffset);
if (value.resourcesNum > value.resources.size()) throw std::runtime_error("Shader cache: invalid vertex resource count");
append(key, value.resourcesNum);
for (std::uint32_t i = 0; i < value.resourcesNum; ++i) {
if (!value.fetchEmbedded) append(key, VertexInputNumericClass(static_cast<IrBufferFormat>((value.resources[i].fields[3] >> 12u) & 0x7fu)));
auto destination = value.resourcesDst[i];
if (value.fetchEmbedded) destination.fetchIndex = 0;
append(key, destination);
}
}
static void append(std::vector<std::uint64_t>& key, const MeshTargetLimits& value) {
append(key, value.maxWorkgroupSize);
append(key, value.maxWorkgroupInvocations);
append(key, value.maxSharedMemoryBytes);
append(key, value.maxOutputVertices);
append(key, value.maxOutputPrimitives);
append(key, value.maxOutputComponents);
append(key, value.maxOutputMemoryBytes);
append(key, value.outputPerVertexGranularity);
append(key, value.outputPerPrimitiveGranularity);
}
static void append(std::vector<std::uint64_t>& key, const TessellationTargetLimits& value) {
append(key, value.maxPatchSize);
append(key, value.maxControlPerVertexInputComponents);
append(key, value.maxControlPerVertexOutputComponents);
append(key, value.maxControlPerPatchOutputComponents);
append(key, value.maxControlTotalOutputComponents);
append(key, value.maxEvaluationInputComponents);
append(key, value.maxEvaluationOutputComponents);
}
static void append(std::vector<std::uint64_t>& key, const SpirvTarget& value) {
append(key, value.vulkanVersion);
append(key, value.spirvVersion);
append(key, value.subgroupSize);
append(key, value.bdaAbiVersion);
append(key, value.supportedCapabilities);
append(key, value.supportedExtensions);
append(key, value.fragmentShaderBarycentricEnabled);
append(key, value.maxWorkgroupSize);
append(key, value.maxWorkgroupInvocations);
append(key, value.maxWorkgroupSharedMemoryBytes);
append(key, value.mesh);
append(key, value.tessellation);
append(key, value.nonConstantImageOffsets);
append(key, value.srgbDecodeFormats);
append(key, value.narrowSubgroupClock);
append(key, value.float64DenormPreserve);
append(key, value.depthRangeRemap);
append(key, value.registrationModules);
append(key, value.registrationWordLimit);
append(key, value.vertexSubgroups);
append(key, value.float16DenormPreserve);
append(key, value.spannedWaves);
append(key, value.robustBufferAccess2);
}
};
}
#endif
Reference in new issue View Git Blame Copy Permalink