Texture caching stuff pt1

include/renderer.hpp

@@ -68,6 +68,7 @@ class Renderer {
 	virtual void displayTransfer(u32 inputAddr, u32 outputAddr, u32 inputSize, u32 outputSize, u32 flags) = 0;  // Perform display transfer
 	virtual void textureCopy(u32 inputAddr, u32 outputAddr, u32 totalBytes, u32 inputSize, u32 outputSize, u32 flags) = 0;
 	virtual void drawVertices(PICA::PrimType primType, std::span<const PICA::Vertex> vertices) = 0;  // Draw the given vertices
+	virtual void invalidateRegion(u32 start, u32 size) {}
 
 	virtual void screenshot(const std::string& name) = 0;
 	// Some frontends and platforms may require that we delete our GL or misc context and obtain a new one for things like exclusive fullscreen

include/renderer_gl/renderer_gl.hpp

@@ -172,6 +172,7 @@ class RendererGL final : public Renderer {
 	void textureCopy(u32 inputAddr, u32 outputAddr, u32 totalBytes, u32 inputSize, u32 outputSize, u32 flags) override;
 	void drawVertices(PICA::PrimType primType, std::span<const PICA::Vertex> vertices) override;  // Draw the given vertices
 	void deinitGraphicsContext() override;
+	void invalidateRegion(u32 start, u32 size) override;
 
 	virtual bool supportsShaderReload() override { return true; }
 	virtual std::string getUbershader() override;

include/renderer_gl/surface_cache.hpp

@@ -104,4 +104,19 @@ public:
     const SurfaceType& operator[](size_t i) const {
         return buffer[i];
     }
+
+	void invalidateRegion(u32 start, u32 size) {
+		if (size == 0) {
+			return;
+		}
+
+		boost::icl::right_open_interval<u32> interval(start, start + size);
+
+		for (auto& e : buffer) {
+			if (e.valid && boost::icl::intersects(e.range, interval)) {
+				e.valid = false;
+				e.free();
+			}
+		}
+	}
 };

src/core/PICA/gpu.cpp

@@ -440,6 +440,8 @@ void GPU::fireDMA(u32 dest, u32 source, u32 size) {
 		// Valid, optimized FCRAM->VRAM DMA. TODO: Is VRAM->VRAM DMA allowed?
 		u8* fcram = mem.getFCRAM();
 		std::memcpy(&vram[dest - vramStart], &fcram[source - fcramStart], size);
+
+		renderer->invalidateRegion(dest - vramStart + PhysicalAddrs::VRAM, size);
 	} else {
 		printf("Non-trivially optimizable GPU DMA. Falling back to byte-by-byte transfer\n");
 

src/core/renderer_gl/renderer_gl.cpp

@@ -792,6 +792,27 @@ void RendererGL::textureCopy(u32 inputAddr, u32 outputAddr, u32 totalBytes, u32
 			shutUpCounter++;
 			printf("RendererGL::TextureCopy failed to locate src framebuffer!\n");
 		}
+
+		invalidateRegion(outputAddr, copySize);
+		u8* inputPointer = gpu.getPointerPhys<u8>(inputAddr);
+		u8* outputPointer = gpu.getPointerPhys<u8>(outputAddr);
+
+		u32 counter = 0;
+		u32 line = 0;
+
+		while (counter < copySize) {
+			const u32 bytes = inputWidth;
+			std::memcpy(outputPointer, inputPointer, bytes);
+			counter += bytes;
+			line += bytes;
+
+			inputPointer += inputWidth + inputGap;
+			if (line >= outputWidth) {
+				outputPointer += outputWidth + outputGap;
+				line = 0;
+			}
+		}
+
 		return;
 	}
 
@@ -1267,3 +1288,5 @@ void RendererGL::setupGLES() {
 		glLogicOp = [](GLenum) {};
 	}
 }
+
+void RendererGL::invalidateRegion(u32 start, u32 size) { textureCache.invalidateRegion(start, size); }

src/core/services/gsp_gpu.cpp

@@ -276,6 +276,9 @@ void GPUService::flushDataCache(u32 messagePointer) {
 	u32 processHandle = handle = mem.read32(messagePointer + 16);
 	log("GSP::GPU::FlushDataCache(address = %08X, size = %X, process = %X)\n", address, size, processHandle);
 
+	printf("Flush data cache\n");
+	gpu.getRenderer()->invalidateRegion(address, size);
+
 	mem.write32(messagePointer, IPC::responseHeader(0x8, 1, 0));
 	mem.write32(messagePointer + 4, Result::Success);
 }
@@ -286,6 +289,7 @@ void GPUService::invalidateDataCache(u32 messagePointer) {
 	u32 processHandle = handle = mem.read32(messagePointer + 16);
 	log("GSP::GPU::InvalidateDataCache(address = %08X, size = %X, process = %X)\n", address, size, processHandle);
 
+	printf("Invalidate data cache\n");
 	mem.write32(messagePointer, IPC::responseHeader(0x9, 1, 0));
 	mem.write32(messagePointer + 4, Result::Success);
 }
@@ -296,6 +300,7 @@ void GPUService::storeDataCache(u32 messagePointer) {
 	u32 processHandle = handle = mem.read32(messagePointer + 16);
 	log("GSP::GPU::StoreDataCache(address = %08X, size = %X, process = %X)\n", address, size, processHandle);
 
+	printf("Store data cache\n");
 	mem.write32(messagePointer, IPC::responseHeader(0x1F, 1, 0));
 	mem.write32(messagePointer + 4, Result::Success);
 }
@@ -453,7 +458,11 @@ void GPUService::triggerDMARequest(u32* cmd) {
 	requestInterrupt(GPUInterrupt::DMA);
 }
 
-void GPUService::flushCacheRegions(u32* cmd) { log("GSP::GPU::FlushCacheRegions (Stubbed)\n"); }
+void GPUService::flushCacheRegions(u32* cmd) {
+	printf("FlushCacheRegions\n");
+
+	log("GSP::GPU::FlushCacheRegions (Stubbed)\n");
+}
 
 void GPUService::setBufferSwapImpl(u32 screenId, const FramebufferInfo& info) {
 	using namespace PICA::ExternalRegs;