preserve-emulation/ppsspp
1
0 Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2026-10-14 15:00:30 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
763bcde73e73b3f0b2cb0ee0466ffbd2bcdbcf5a
ppsspp/GPU/Software/SoftGpu.h
T
Henrik RydgårdandClaude Opus 5.5 9cbce22773 SoftGPU: Draw clear mode, stencil and color test spans in vector lanes 
DrawSpanVector now covers everything but logic ops and the signed blend factors. Stencil tests pick
the SFail, ZFail or ZPass op per lane, and lanes that only get a new stencil keep their old color.
Pixels are read and written in the framebuffer's own format, converting the whole span at once, and
a span with all four pixels drawn is stored in one go.

Only drawn pixels are written: spans are aligned in screen coordinates, so with a draw offset one can
reach into a tile another thread is drawing.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-09 10:34:39 +02:00

286 lines
9.3 KiB
C++
Raw Blame History

// Copyright (c) 2012- PPSSPP Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0 or later versions.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
#pragma once
#include <cstdint>
#include "GPU/GPUCommon.h"
#include "GPU/Common/DepthSwizzle.h"
#include "Common/GPU/thin3d.h"
struct FormatBuffer {
FormatBuffer() { data = nullptr; }
union {
u8 *data;
u16 *as16;
u32 *as32;
};
inline void Set16(int x, int y, int stride, u16 v) const {
as16[x + y * stride] = v;
}
inline void Set32(int x, int y, int stride, u32 v) const {
as32[x + y * stride] = v;
}
inline u16 Get16(int x, int y, int stride) const {
return as16[x + y * stride];
}
inline u32 Get32(int x, int y, int stride) const {
return as32[x + y * stride];
}
inline u16 *Get16Ptr(int x, int y, int stride) const {
return &as16[x + y * stride];
}
inline u32 *Get32Ptr(int x, int y, int stride) const {
return &as32[x + y * stride];
}
};
// The depth buffer, stored in VRAM as the GE stores it (GPU/Common/DepthSwizzle.h).
struct DepthBuffer {
// VRAM's start, and the buffer's offset in it.
u8 *vram = nullptr;
uint32_t base = 0;
DepthLayout layout;
// sceGeEdramSetAddrTranslation's value, which with the color format picks the layout.
uint32_t translation = 0x400;
inline u16 *Get16Ptr(int x, int y, int stride) const {
return (u16 *)(vram + layout.Stored(base + (uint32_t)(x + y * stride) * 2));
}
inline u16 Get16(int x, int y, int stride) const {
return *Get16Ptr(x, y, stride);
}
inline void Set16(int x, int y, int stride, u16 v) const {
*Get16Ptr(x, y, stride) = v;
}
// Whether the four depths from x in row y are stored together: unless they cross the end of a 16-pixel run.
inline bool Contiguous4(int x, int y, int stride) const {
return ((base + (uint32_t)(x + y * stride) * 2) & 31) <= 24;
}
};
enum class SoftDirty : uint64_t {
NONE = 0,
PIXEL_BASIC = 1ULL << 0,
PIXEL_STENCIL = 1ULL << 1,
PIXEL_ALPHA = 1ULL << 2,
PIXEL_DITHER = 1ULL << 3,
PIXEL_WRITEMASK = 1ULL << 4,
PIXEL_CACHED = 1ULL << 5,
PIXEL_ALL = 0b111111ULL << 0,
SAMPLER_BASIC = 1ULL << 6,
SAMPLER_TEXLIST = 1ULL << 7,
SAMPLER_CLUT = 1ULL << 8,
SAMPLER_ALL = 0b111ULL << 6,
RAST_BASIC = 1ULL << 9,
RAST_TEX = 1ULL << 10,
RAST_OFFSET = 1ULL << 11,
RAST_ALL = 0b111ULL << 9,
LIGHT_BASIC = 1ULL << 12,
LIGHT_MATERIAL = 1ULL << 13,
LIGHT_0 = 1ULL << 14,
LIGHT_1 = 1ULL << 15,
LIGHT_2 = 1ULL << 16,
LIGHT_3 = 1ULL << 17,
LIGHT_ALL = 0b111111ULL << 12,
TRANSFORM_BASIC = 1ULL << 18,
TRANSFORM_MATRIX = 1ULL << 19,
TRANSFORM_VIEWPORT = 1ULL << 20,
TRANSFORM_FOG = 1ULL << 21,
TRANSFORM_ALL = 0b1111ULL << 18,
BINNER_RANGE = 1ULL << 22,
BINNER_OVERLAP = 1ULL << 23,
};
static inline SoftDirty operator |(const SoftDirty &lhs, const SoftDirty &rhs) {
return SoftDirty((uint64_t)lhs | (uint64_t)rhs);
}
static inline SoftDirty &operator |=(SoftDirty &lhs, const SoftDirty &rhs) {
lhs = lhs | rhs;
return lhs;
}
static inline bool operator &(const SoftDirty &lhs, const SoftDirty &rhs) {
return ((uint64_t)lhs & (uint64_t)rhs) != 0;
}
static inline SoftDirty &operator &=(SoftDirty &lhs, const SoftDirty &rhs) {
lhs = SoftDirty((uint64_t)lhs & (uint64_t)rhs);
return lhs;
}
static inline SoftDirty operator ~(const SoftDirty &v) {
return SoftDirty(~(uint64_t)v);
}
class PresentationCommon;
class SoftwareDrawEngine;
enum class SoftGPUVRAMDirty : uint8_t {
CLEAR = 0,
DIRTY = 1,
REALLY_DIRTY = 2,
};
ENUM_CLASS_BITOPS(SoftGPUVRAMDirty);
class SoftGPU : public GPUCommon {
public:
SoftGPU(GraphicsContext *gfxCtx, Draw::DrawContext *draw);
~SoftGPU();
u32 CheckGPUFeatures() const override { return 0; }
void ExecuteOp(u32 op, u32 diff) override;
void FinishDeferred() override;
void FlushPendingDrawing() override;
int ListSync(int listid, int mode) override;
u32 DrawSync(int mode) override;
void UpdateCmdInfo() override {}
void SetDisplayFramebuffer(u32 framebuf, u32 stride, GEBufferFormat format) override;
uint32_t SetAddrTranslation(uint32_t value) override;
bool CopyBlockTransfer(u32 srcBasePtr, u32 srcStride, int srcX, int srcY, u32 dstBasePtr, u32 dstStride, int dstX, int dstY, int width, int height, int bpp) override;
void DoState(PointerWrap &p) override;
void SetCurFramebufferDirty(bool dirty) override {}
void PrepareCopyDisplayToOutput(const DisplayLayoutConfig &config) override;
void CopyDisplayToOutput(const DisplayLayoutConfig &config) override;
void GetStats(StringWriter &w) override;
std::vector<const VirtualFramebuffer *> GetFramebufferList() const override { return std::vector<const VirtualFramebuffer *>(); }
void InvalidateCache(u32 addr, int size, GPUInvalidationType type) override;
void PerformWriteFormattedFromMemory(u32 addr, int size, int width, GEBufferFormat format) override;
bool PerformMemoryCopy(u32 dest, u32 src, int size, GPUCopyFlag flags = GPUCopyFlag::NONE) override;
bool PerformMemorySet(u32 dest, u8 v, int size) override;
bool PerformReadbackToMemory(u32 dest, int size) override;
bool PerformWriteColorFromMemory(u32 dest, int size) override;
bool PerformWriteStencilFromMemory(u32 dest, int size, WriteStencil flags) override;
void DeviceLost() override;
void DeviceRestore(Draw::DrawContext *draw) override;
void NotifyRenderResized(const DisplayLayoutConfig &config) override;
void NotifyDisplayResized() override;
void CheckDisplayResized() override;
void CheckConfigChanged(const DisplayLayoutConfig &config) override;
void GetReportingInfo(std::string &primaryInfo, std::string &fullInfo) const override {
primaryInfo = "Software";
fullInfo = "Software";
}
bool FramebufferDirty() override;
bool FramebufferReallyDirty() override;
bool GetCurrentFramebuffer(GPUDebugBuffer &buffer, GPUDebugFramebufferType type, int maxRes = -1) override;
bool GetOutputFramebuffer(GPUDebugBuffer &buffer) override;
bool GetCurrentDepthbuffer(GPUDebugBuffer &buffer) override;
bool GetCurrentStencilbuffer(GPUDebugBuffer &buffer) override;
bool GetCurrentTexture(GPUDebugBuffer &buffer, int level, bool *isFramebuffer) override;
bool GetCurrentClut(GPUDebugBuffer &buffer) override;
bool DescribeCodePtr(const u8 *ptr, std::string &name) override;
void Execute_BlockTransferStart(u32 op, u32 diff);
void Execute_Prim(u32 op, u32 diff);
void Execute_Bezier(u32 op, u32 diff);
void Execute_Spline(u32 op, u32 diff);
void Execute_LoadClut(u32 op, u32 diff);
void Execute_FramebufPtr(u32 op, u32 diff);
void Execute_FramebufFormat(u32 op, u32 diff);
void Execute_ZbufPtr(u32 op, u32 diff);
void UpdateDepthBuffer();
void Execute_TexFlush(u32 op, u32 diff);
void Execute_VertexType(u32 op, u32 diff);
// Overridden to change flushing behavior.
void Execute_Call(u32 op, u32 diff);
void Execute_WorldMtxNum(u32 op, u32 diff);
void Execute_ViewMtxNum(u32 op, u32 diff);
void Execute_ProjMtxNum(u32 op, u32 diff);
void Execute_TgenMtxNum(u32 op, u32 diff);
void Execute_BoneMtxNum(u32 op, u32 diff);
void Execute_WorldMtxData(u32 op, u32 diff);
void Execute_ViewMtxData(u32 op, u32 diff);
void Execute_ProjMtxData(u32 op, u32 diff);
void Execute_TgenMtxData(u32 op, u32 diff);
void Execute_BoneMtxData(u32 op, u32 diff);
bool GetMatrix24(GEMatrixType type, u32_le *result, u32 cmdbits) override;
void ResetMatrices() override;
void Execute_ImmVertexAlphaPrim(u32 op, u32 diff);
typedef void (SoftGPU::*CmdFunc)(u32 op, u32 diff);
void BeginHostFrame(const DisplayLayoutConfig &config) override;
bool PresentedThisFrame() const override;
protected:
void FastRunLoop(DisplayList &list) override;
void CopyToCurrentFboFromDisplayRam(const DisplayLayoutConfig &config, int srcwidth, int srcheight);
void ConvertTextureDescFrom16(Draw::TextureDesc &desc, int srcwidth, int srcheight, const uint16_t *overrideData = nullptr);
bool DarkStalkersStretchActive() const;
void GetDarkStalkersDisplay(GPUDebugBuffer &buffer);
void BuildReportingInfo() override {}
private:
void MarkDirty(uint32_t addr, uint32_t stride, uint32_t height, GEBufferFormat fmt, SoftGPUVRAMDirty value);
void MarkDirty(uint32_t addr, uint32_t bytes, SoftGPUVRAMDirty value);
bool ClearDirty(uint32_t addr, uint32_t stride, uint32_t height, GEBufferFormat fmt, SoftGPUVRAMDirty value);
bool ClearDirty(uint32_t addr, uint32_t bytes, SoftGPUVRAMDirty value);
uint8_t vramDirty_[2048];
uint32_t lastDirtyAddr_ = 0;
uint32_t lastDirtySize_ = 0;
SoftGPUVRAMDirty lastDirtyValue_ = SoftGPUVRAMDirty::CLEAR;
u32 displayFramebuf_;
u32 displayStride_;
GEBufferFormat displayFormat_;
SoftDirty dirtyFlags_ = SoftDirty(-1);
PresentationCommon *presentation_ = nullptr;
SoftwareDrawEngine *drawEngine_ = nullptr;
Draw::Texture *fbTex = nullptr;
std::vector<u32> fbTexBuffer_;
};
// TODO: These shouldn't be global.
extern uint8_t clut[1024];
extern FormatBuffer fb;
extern DepthBuffer depthbuf;
// Type for the DarkStalkers stretch replacement.
enum class DSStretch {
Off = 0,
Normal,
Wide,
};
Reference in new issue View Git Blame Copy Permalink