ppsspp/GPU/Software/SoftGpu.h

// 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 : uint32_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;


	void Execute_BlockTransferStart(u32 op, u32 diff);
	void Execute_Prim(u32 op, u32 diff);
	int RunVertexCount(u32 count, u32 vertexSize);
	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,
};