From 450ce40b012ed65ec494b5f278443aad8030bb49 Mon Sep 17 00:00:00 2001 From: olebeck <31539311+olebeck@users.noreply.github.com> Date: Wed, 2 Jul 2025 02:18:22 +0200 Subject: [PATCH] improve fragment shader performance --- miniwin/src/d3drm/backends/gxm/gxm_memory.h | 2 +- miniwin/src/d3drm/backends/gxm/renderer.cpp | 298 ++++++++++++++---- .../src/d3drm/backends/gxm/shaders/.gitignore | 3 +- .../src/d3drm/backends/gxm/shaders/Makefile | 17 +- .../d3drm/backends/gxm/shaders/color.frag.gxp | Bin 228 -> 228 bytes .../backends/gxm/shaders/main.color.frag.gxp | Bin 0 -> 1304 bytes .../d3drm/backends/gxm/shaders/main.frag.cg | 63 ++-- .../d3drm/backends/gxm/shaders/main.frag.gxp | Bin 1480 -> 0 bytes .../gxm/shaders/main.texture.frag.gxp | Bin 0 -> 1372 bytes miniwin/src/internal/d3drmrenderer_gxm.h | 44 ++- 10 files changed, 316 insertions(+), 111 deletions(-) create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/main.color.frag.gxp delete mode 100644 miniwin/src/d3drm/backends/gxm/shaders/main.frag.gxp create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/main.texture.frag.gxp diff --git a/miniwin/src/d3drm/backends/gxm/gxm_memory.h b/miniwin/src/d3drm/backends/gxm/gxm_memory.h index 28c81336..da0ccc43 100644 --- a/miniwin/src/d3drm/backends/gxm/gxm_memory.h +++ b/miniwin/src/d3drm/backends/gxm/gxm_memory.h @@ -6,7 +6,7 @@ void* patcher_host_alloc(void* user_data, unsigned int size); void patcher_host_free(void* user_data, void* mem); -void* vita_mem_alloc(unsigned int type, size_t size, size_t alignment, int attribs, SceUID* uid); +void* vita_mem_alloc(unsigned int type, size_t size, size_t alignment, int attribs, SceUID* uid, const char* name); void vita_mem_free(SceUID uid); void* vita_mem_vertex_usse_alloc(unsigned int size, SceUID* uid, unsigned int* usse_offset); diff --git a/miniwin/src/d3drm/backends/gxm/renderer.cpp b/miniwin/src/d3drm/backends/gxm/renderer.cpp index 48a47d02..bc1000f4 100644 --- a/miniwin/src/d3drm/backends/gxm/renderer.cpp +++ b/miniwin/src/d3drm/backends/gxm/renderer.cpp @@ -16,6 +16,8 @@ #define INCBIN_PREFIX _inc_ #include "incbin.h" +#include + bool with_razor = false; bool with_razor_hud = false; bool gxm_initialized = false; @@ -28,13 +30,17 @@ bool gxm_initialized = false; #define VITA_GXM_COLOR_FORMAT SCE_GXM_COLOR_FORMAT_A8B8G8R8 #define VITA_GXM_PIXEL_FORMAT SCE_DISPLAY_PIXELFORMAT_A8B8G8R8 +#define SCE_GXM_PRECOMPUTED_ALIGNMENT 16 + INCBIN(main_vert_gxp, "shaders/main.vert.gxp"); -INCBIN(main_frag_gxp, "shaders/main.frag.gxp"); +INCBIN(main_color_frag_gxp, "shaders/main.color.frag.gxp"); +INCBIN(main_texture_frag_gxp, "shaders/main.texture.frag.gxp"); INCBIN(color_frag_gxp, "shaders/color.frag.gxp"); INCBIN(image_frag_gxp, "shaders/image.frag.gxp"); const SceGxmProgram* mainVertexProgramGxp = (const SceGxmProgram*) _inc_main_vert_gxpData; -const SceGxmProgram* mainFragmentProgramGxp = (const SceGxmProgram*) _inc_main_frag_gxpData; +const SceGxmProgram* mainColorFragmentProgramGxp = (const SceGxmProgram*) _inc_main_color_frag_gxpData; +const SceGxmProgram* mainTextureFragmentProgramGxp = (const SceGxmProgram*) _inc_main_texture_frag_gxpData; const SceGxmProgram* colorFragmentProgramGxp = (const SceGxmProgram*) _inc_color_frag_gxpData; const SceGxmProgram* imageFragmentProgramGxp = (const SceGxmProgram*) _inc_image_frag_gxpData; @@ -129,7 +135,7 @@ static void load_razor() } if (with_razor) { - sceRazorGpuCaptureEnableSalvage("ux0:data/gpu_crash.sgx"); + //sceRazorGpuCaptureEnableSalvage("ux0:data/gpu_crash.sgx"); } if (with_razor_hud) { @@ -183,7 +189,8 @@ static bool create_gxm_context() SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE, 4, SCE_GXM_MEMORY_ATTRIB_READ, - &data->vdmRingBufferUid + &data->vdmRingBufferUid, + "vdmRingBuffer" ); data->vertexRingBuffer = vita_mem_alloc( @@ -191,7 +198,8 @@ static bool create_gxm_context() SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE, 4, SCE_GXM_MEMORY_ATTRIB_READ, - &data->vertexRingBufferUid + &data->vertexRingBufferUid, + "vertexRingBuffer" ); data->fragmentRingBuffer = vita_mem_alloc( @@ -199,7 +207,8 @@ static bool create_gxm_context() SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE, 4, SCE_GXM_MEMORY_ATTRIB_READ, - &data->fragmentRingBufferUid + &data->fragmentRingBufferUid, + "fragmentRingBuffer" ); data->fragmentUsseRingBuffer = vita_mem_fragment_usse_alloc( @@ -234,7 +243,8 @@ static bool create_gxm_context() patcherBufferSize, 4, SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, - &data->patcherBufferUid + &data->patcherBufferUid, + "patcherBuffer" ); data->patcherVertexUsse = @@ -373,7 +383,8 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height) 4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT, SCE_GXM_COLOR_SURFACE_ALIGNMENT, SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, - &this->displayBuffersUid[i] + &this->displayBuffersUid[i], + "displayBuffers" ); if (SCE_ERR( @@ -402,7 +413,8 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height) 4 * sampleCount, SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT, SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, - &this->depthBufferUid + &this->depthBufferUid, + "depthBufferData" ); this->stencilBufferData = vita_mem_alloc( @@ -410,7 +422,8 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height) 4 * sampleCount, SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT, SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, - &this->stencilBufferUid + &this->stencilBufferUid, + "stencilBufferData" ); if (SCE_ERR( @@ -445,8 +458,16 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height) if (SCE_ERR( sceGxmShaderPatcherRegisterProgram, this->shaderPatcher, - mainFragmentProgramGxp, - &this->mainFragmentProgramId + mainColorFragmentProgramGxp, + &this->mainColorFragmentProgramId + )) { + return; + } + if (SCE_ERR( + sceGxmShaderPatcherRegisterProgram, + this->shaderPatcher, + mainTextureFragmentProgramGxp, + &this->mainTextureFragmentProgramId )) { return; } @@ -505,30 +526,58 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height) } } - // main opaque + // main color opaque if (SCE_ERR( sceGxmShaderPatcherCreateFragmentProgram, this->shaderPatcher, - this->mainFragmentProgramId, + this->mainColorFragmentProgramId, SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, SCE_GXM_MULTISAMPLE_NONE, &blendInfoOpaque, mainVertexProgramGxp, - &this->opaqueFragmentProgram + &this->opaqueColorFragmentProgram )) { return; } - // main transparent + // main color blended if (SCE_ERR( sceGxmShaderPatcherCreateFragmentProgram, this->shaderPatcher, - this->mainFragmentProgramId, + this->mainColorFragmentProgramId, SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, SCE_GXM_MULTISAMPLE_NONE, &blendInfoTransparent, mainVertexProgramGxp, - &this->transparentFragmentProgram + &this->blendedColorFragmentProgram + )) { + return; + } + + // main texture opaque + if (SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + this->shaderPatcher, + this->mainTextureFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + SCE_GXM_MULTISAMPLE_NONE, + &blendInfoOpaque, + mainVertexProgramGxp, + &this->opaqueTextureFragmentProgram + )) { + return; + } + + // main texture transparent + if (SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + this->shaderPatcher, + this->mainTextureFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + SCE_GXM_MULTISAMPLE_NONE, + &blendInfoTransparent, + mainVertexProgramGxp, + &this->blendedTextureFragmentProgram )) { return; } @@ -567,11 +616,14 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height) this->uProjectionMatrix = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uProjectionMatrix"); // fragment uniforms - this->uLights = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uLights"); // SceneLight[3] - this->uLightCount = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uLightCount"); // int - this->uShininess = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uShininess"); // float - this->uColor = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uColor"); // vec4 - this->uUseTexture = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uUseTexture"); // int + this->color_uLights = sceGxmProgramFindParameterByName(mainColorFragmentProgramGxp, "uLights"); // SceneLight[3] + this->color_uAmbientLight = sceGxmProgramFindParameterByName(mainColorFragmentProgramGxp, "uAmbientLight"); // vec3 + this->color_uShininess = sceGxmProgramFindParameterByName(mainColorFragmentProgramGxp, "uShininess"); // float + this->color_uColor = sceGxmProgramFindParameterByName(mainColorFragmentProgramGxp, "uColor"); // vec4 + this->texture_uLights = sceGxmProgramFindParameterByName(mainTextureFragmentProgramGxp, "uLights"); // SceneLight[3] + this->texture_uAmbientLight = sceGxmProgramFindParameterByName(mainTextureFragmentProgramGxp, "uAmbientLight"); // vec3 + this->texture_uShininess = sceGxmProgramFindParameterByName(mainTextureFragmentProgramGxp, "uShininess"); // float + this->texture_uColor = sceGxmProgramFindParameterByName(mainTextureFragmentProgramGxp, "uColor"); // vec4 // clear uniforms this->colorShader_uColor = sceGxmProgramFindParameterByName(colorFragmentProgramGxp, "uColor"); // vec4 @@ -900,6 +952,108 @@ GXMMeshCacheEntry GXMRenderer::GXMUploadMesh(const MeshGroup& meshGroup) cache.indexBuffer = indexBuffer; cache.indexCount = indices.size(); +#ifdef GXM_PRECOMPUTE + bool isOpaque = meshGroup.color.a == 0xff; + const SceGxmTexture* texture = nullptr; + if(meshGroup.texture) { + Uint32 textureId = GetTextureId(meshGroup.texture, false); + texture = &this->m_textures[textureId].gxmTexture; + } + + const SceGxmProgram* fragmentProgramGxp; + const SceGxmFragmentProgram *fragmentProgram; + if(texture) { + fragmentProgramGxp = mainTextureFragmentProgramGxp; + fragmentProgram = isOpaque ? this->opaqueTextureFragmentProgram : this->blendedTextureFragmentProgram; + } else { + fragmentProgramGxp = mainColorFragmentProgramGxp; + fragmentProgram = isOpaque ? this->opaqueColorFragmentProgram : this->blendedColorFragmentProgram; + } + + // get sizes + const size_t drawSize = ALIGN(sceGxmGetPrecomputedDrawSize(this->mainVertexProgram), SCE_GXM_PRECOMPUTED_ALIGNMENT); + const size_t vertexStateSize = ALIGN(sceGxmGetPrecomputedVertexStateSize(this->mainVertexProgram), SCE_GXM_PRECOMPUTED_ALIGNMENT); + const size_t fragmentStateSize = ALIGN(sceGxmGetPrecomputedFragmentStateSize(fragmentProgram), SCE_GXM_PRECOMPUTED_ALIGNMENT); + const size_t precomputeDataSize = + drawSize + + vertexStateSize * GXM_VERTEX_BUFFER_COUNT + + fragmentStateSize * GXM_FRAGMENT_BUFFER_COUNT; + + const size_t vertexDefaultBufferSize = sceGxmProgramGetDefaultUniformBufferSize(mainVertexProgramGxp); + const size_t fragmentDefaultBufferSize = sceGxmProgramGetDefaultUniformBufferSize(fragmentProgramGxp); + const size_t uniformBuffersSize = + vertexDefaultBufferSize * GXM_VERTEX_BUFFER_COUNT; + fragmentStateSize * GXM_FRAGMENT_BUFFER_COUNT; + + sceClibPrintf("drawSize: %d\n", drawSize); + sceClibPrintf("vertexStateSize: %d\n", vertexStateSize); + sceClibPrintf("fragmentStateSize: %d\n", fragmentStateSize); + sceClibPrintf("precomputeDataSize: %d\n", precomputeDataSize); + sceClibPrintf("vertexDefaultBufferSize: %d\n", vertexDefaultBufferSize); + sceClibPrintf("fragmentDefaultBufferSize: %d\n", fragmentDefaultBufferSize); + sceClibPrintf("uniformBuffersSize: %d\n", uniformBuffersSize); + + // allocate the precompute buffer, combined for all + uint8_t* precomputeData = (uint8_t*)cdram_alloc(precomputeDataSize, SCE_GXM_PRECOMPUTED_ALIGNMENT); + cache.precomputeData = precomputeData; + + uint8_t* uniformBuffers = (uint8_t*)cdram_alloc(uniformBuffersSize, 4); + cache.uniformBuffers = uniformBuffers; + + // init precomputed draw + SCE_ERR(sceGxmPrecomputedDrawInit, + &cache.drawState, + this->mainVertexProgram, + precomputeData + ); + void* vertexStreams[] = { vertexBuffer }; + sceGxmPrecomputedDrawSetAllVertexStreams(&cache.drawState, vertexStreams); + sceGxmPrecomputedDrawSetParams( + &cache.drawState, + SCE_GXM_PRIMITIVE_TRIANGLES, + SCE_GXM_INDEX_FORMAT_U16, + indexBuffer, + indices.size() + ); + precomputeData += drawSize; + + // init precomputed vertex state + for(int bufferIndex = 0; bufferIndex < GXM_VERTEX_BUFFER_COUNT; bufferIndex++) { + SCE_ERR(sceGxmPrecomputedVertexStateInit, + &cache.vertexState[bufferIndex], + this->mainVertexProgram, + precomputeData + ); + sceGxmPrecomputedVertexStateSetDefaultUniformBuffer( + &cache.vertexState[bufferIndex], + uniformBuffers + ); + precomputeData += vertexStateSize; + uniformBuffers += vertexDefaultBufferSize; + } + + // init precomputed fragment state + for(int bufferIndex = 0; bufferIndex < GXM_FRAGMENT_BUFFER_COUNT; bufferIndex++) { + SCE_ERR(sceGxmPrecomputedFragmentStateInit, + &cache.fragmentState[bufferIndex], + fragmentProgram, + precomputeData + ); + if(texture) { + sceGxmPrecomputedFragmentStateSetTexture( + &cache.fragmentState[bufferIndex], + 0, texture + ); + } + sceGxmPrecomputedFragmentStateSetDefaultUniformBuffer( + &cache.fragmentState[bufferIndex], + uniformBuffers + ); + precomputeData += fragmentStateSize; + uniformBuffers += fragmentDefaultBufferSize; + } + assert(precomputeData - (uint8_t*)cache.precomputeData <= precomputeDataSize); +#endif return cache; } @@ -1033,25 +1187,35 @@ HRESULT GXMRenderer::BeginFrame() this->StartScene(); auto lightData = this->LightsBuffer(); - int lightCount = std::min(static_cast(m_lights.size()), 3); - for (int i = 0; i < lightCount; ++i) { - const auto& src = m_lights[i]; - lightData->lights[i].color[0] = src.color.r; - lightData->lights[i].color[1] = src.color.g; - lightData->lights[i].color[2] = src.color.b; - lightData->lights[i].color[3] = src.color.a; + int i = 0; + for(const auto& light : m_lights) { + if(!light.directional && !light.positional) { + lightData->ambientLight[0] = light.color.r; + lightData->ambientLight[1] = light.color.g; + lightData->ambientLight[2] = light.color.b; + continue; + } + if(i == 2) { + sceClibPrintf("light overflow\n"); + continue; + } - lightData->lights[i].position[0] = src.position.x; - lightData->lights[i].position[1] = src.position.y; - lightData->lights[i].position[2] = src.position.z; - lightData->lights[i].position[3] = src.positional; + lightData->lights[i].color[0] = light.color.r; + lightData->lights[i].color[1] = light.color.g; + lightData->lights[i].color[2] = light.color.b; + lightData->lights[i].color[3] = light.color.a; - lightData->lights[i].direction[0] = src.direction.x; - lightData->lights[i].direction[1] = src.direction.y; - lightData->lights[i].direction[2] = src.direction.z; - lightData->lights[i].direction[3] = src.directional; + lightData->lights[i].position[0] = light.position.x; + lightData->lights[i].position[1] = light.position.y; + lightData->lights[i].position[2] = light.position.z; + lightData->lights[i].position[3] = light.positional; + + lightData->lights[i].direction[0] = light.direction.x; + lightData->lights[i].direction[1] = light.direction.y; + lightData->lights[i].direction[2] = light.direction.z; + lightData->lights[i].direction[3] = light.directional; + i++; } - lightData->lightCount = lightCount; sceGxmSetFragmentUniformBuffer(this->context, 0, lightData); return DD_OK; @@ -1100,21 +1264,19 @@ void GXMRenderer::SubmitDraw( sceGxmPushUserMarker(this->context, marker); sceGxmSetVertexProgram(this->context, this->mainVertexProgram); - if (this->transparencyEnabled) { - sceGxmSetFragmentProgram(this->context, this->transparentFragmentProgram); - } - else { - sceGxmSetFragmentProgram(this->context, this->opaqueFragmentProgram); - } - void* vertUniforms; - void* fragUniforms; - sceGxmReserveVertexDefaultUniformBuffer(this->context, &vertUniforms); - sceGxmReserveFragmentDefaultUniformBuffer(this->context, &fragUniforms); + bool textured = appearance.textureId != NO_TEXTURE_ID; - SET_UNIFORM(vertUniforms, this->uModelViewMatrix, modelViewMatrix); - SET_UNIFORM(vertUniforms, this->uProjectionMatrix, m_projection); - sceGxmSetUniformDataF(vertUniforms, this->uNormalMatrix, 0, 9, static_cast(normalMatrix[0])); + const SceGxmFragmentProgram *fragmentProgram; + if(this->transparencyEnabled) { + fragmentProgram = textured ? this->blendedTextureFragmentProgram : this->blendedColorFragmentProgram; + } else { + fragmentProgram = textured ? this->opaqueTextureFragmentProgram : this->opaqueColorFragmentProgram; + } + sceGxmSetFragmentProgram(this->context, fragmentProgram); + + const SceGxmProgramParameter* uColor = textured ? this->texture_uColor : this->color_uColor; + const SceGxmProgramParameter* uShininess = textured ? this->texture_uShininess : this->color_uShininess; float color[4] = { appearance.color.r / 255.0f, @@ -1122,19 +1284,39 @@ void GXMRenderer::SubmitDraw( appearance.color.b / 255.0f, appearance.color.a / 255.0f }; - SET_UNIFORM(fragUniforms, this->uColor, color); - SET_UNIFORM(fragUniforms, this->uShininess, appearance.shininess); - int useTexture = appearance.textureId != NO_TEXTURE_ID ? 1 : 0; - SET_UNIFORM(fragUniforms, this->uUseTexture, useTexture); - if (useTexture) { + void* vertUniforms; + void* fragUniforms; +#ifdef GXM_PRECOMPUTE + sceGxmSetPrecomputedVertexState(this->context, &mesh.vertexState[this->currentVertexBufferIndex]); + sceGxmSetPrecomputedFragmentState(this->context, &mesh.fragmentState[this->currentFragmentBufferIndex]); + vertUniforms = sceGxmPrecomputedVertexStateGetDefaultUniformBuffer(&mesh.vertexState[this->currentVertexBufferIndex]); + fragUniforms = sceGxmPrecomputedFragmentStateGetDefaultUniformBuffer(&mesh.fragmentState[this->currentFragmentBufferIndex]); +#else + sceGxmReserveVertexDefaultUniformBuffer(this->context, &vertUniforms); + sceGxmReserveFragmentDefaultUniformBuffer(this->context, &fragUniforms); +#endif + + SET_UNIFORM(vertUniforms, this->uModelViewMatrix, modelViewMatrix); + SET_UNIFORM(vertUniforms, this->uProjectionMatrix, m_projection); + sceGxmSetUniformDataF(vertUniforms, this->uNormalMatrix, 0, 9, static_cast(normalMatrix[0])); + + SET_UNIFORM(fragUniforms, uColor, color); + SET_UNIFORM(fragUniforms, uShininess, appearance.shininess); + + if (textured) { auto& texture = m_textures[appearance.textureId]; sceGxmSetFragmentTexture(this->context, 0, &texture.gxmTexture); } +#ifdef GXM_PRECOMPUTE + sceGxmDrawPrecomputed(this->context, &mesh.drawState); + sceGxmSetPrecomputedVertexState(this->context, NULL); + sceGxmSetPrecomputedFragmentState(this->context, NULL); +#else sceGxmSetVertexStream(this->context, 0, mesh.vertexBuffer); sceGxmDraw(this->context, SCE_GXM_PRIMITIVE_TRIANGLES, SCE_GXM_INDEX_FORMAT_U16, mesh.indexBuffer, mesh.indexCount); - +#endif sceGxmPopUserMarker(this->context); } diff --git a/miniwin/src/d3drm/backends/gxm/shaders/.gitignore b/miniwin/src/d3drm/backends/gxm/shaders/.gitignore index 21ce5a1f..04193dc2 100644 --- a/miniwin/src/d3drm/backends/gxm/shaders/.gitignore +++ b/miniwin/src/d3drm/backends/gxm/shaders/.gitignore @@ -1,2 +1,3 @@ *.exe -cache/ \ No newline at end of file +cache/ +*.perf.txt \ No newline at end of file diff --git a/miniwin/src/d3drm/backends/gxm/shaders/Makefile b/miniwin/src/d3drm/backends/gxm/shaders/Makefile index 56241c42..6837ca78 100644 --- a/miniwin/src/d3drm/backends/gxm/shaders/Makefile +++ b/miniwin/src/d3drm/backends/gxm/shaders/Makefile @@ -1,9 +1,13 @@ -shaders += main.frag.gxp main.vert.gxp +shaders += main.vert.gxp shaders += color.frag.gxp image.frag.gxp +shaders += main.color.frag.gxp main.texture.frag.gxp + +PERFS = $(shaders:.gxp=.perf.txt) all: $(shaders) +perfs: $(PERFS) -CGCFLAGS = -Wperf -cache -cachedir cache +CGCFLAGS = -Wperf -cache -cachedir cache -W4 -Wsuppress=5206,5203 cache: mkdir -p cache @@ -13,3 +17,12 @@ cache: %.frag.gxp: %.frag.cg | cache ./psp2cgc.exe $(CGCFLAGS) -profile sce_fp_psp2 $< -o $@ + +main.color.frag.gxp: main.frag.cg | cache + ./psp2cgc.exe $(CGCFLAGS) -profile sce_fp_psp2 $< -o $@ + +main.texture.frag.gxp: main.frag.cg | cache + ./psp2cgc.exe $(CGCFLAGS) -DTEXTURED=1 -profile sce_fp_psp2 $< -o $@ + +%.perf.txt: %.gxp + ./psp2shaderperf.exe -disasm $< > $@ diff --git a/miniwin/src/d3drm/backends/gxm/shaders/color.frag.gxp b/miniwin/src/d3drm/backends/gxm/shaders/color.frag.gxp index 4814e137ce75bfbb3a417237cdb7d13635f8cd3b..854275fba9f2a6a60a6f1536f1f993a88df87a7b 100644 GIT binary patch delta 28 kcmaFD_=Hi!JtBaCku`w%F#`hwPaSt?joRI(6Gbin0C83b%>V!Z delta 28 jcmaFD_=Hi!JtBaCku`w%F#`hwPaSt?si;%VM3D;sYt#p! diff --git a/miniwin/src/d3drm/backends/gxm/shaders/main.color.frag.gxp b/miniwin/src/d3drm/backends/gxm/shaders/main.color.frag.gxp new file mode 100644 index 0000000000000000000000000000000000000000..bc881a9e1941a01d373114fff77b4797dc6b6cde GIT binary patch literal 1304 zcmb_cOK1~O6umD$C#C63YLSszlZd#~6uQWwi4#&VK^HA<3R3*F*nygqrrpY$G?kdN zw$Xx!6_e>_Q4n!o>ZBF7b*rEfaM7j9R+M<}O9E-T^}?I;&YAb_Z*p^Oco3L#(5^ZG zy3c>r^WVR{wJR#v02F9g8{(E7U=mS+OW+YYg9PFL12}`2!_|lTR%=ohilca6i{Jxo z7=hm1sZ)qIP(#GH5NdEbTQ}w)-GNJ1taj3Z^gxsSRtI5|LpEB@250w41MnYmm%r2o z#vo*>r8)oXzQ!DD8{RdEvw^iu#gc$W%X8vbraCf7X5E2i*=SqVRgn9BiWDeTn1Z$ixt z2R3fJTk&XGjE(Fq7Xs>qrAm#s<}d!R3cYH?J0fRM51U0F&oPxFO&fUWZ?kC8l_I2tITwJRgk%w|_SBiA29SB=el18j%v-a~oj8kQGW3AjXk z)&LGKcJBU~r`%B8g-E~<>@dCdBtOCPS%6@l+}}dnU5E$s?GE+QangGd|7E- zVi7JwI}ZY9dpuWF1@GWNr%|yu=HZ%S70#r<8 zEaC?m@mZrTz`7_t_5=Ess2@Q6aPkn}?o={)*64>j(WvWhGv5EME4H(1@gj%pj=jQx zQy5X#bp|#5lEXYAeh27!LUmahfcFhAyjP{!vgohF_)^vDsq_f-D$L@6rQdwWt zj<|i+|Hxx#Vi3Rur_sMlOc=nQTCG+>&Z_m9!!5ib{;8~TIs w>GZAO$mRRTg~?P}pVm{!) 0.0) { - // Diffuse contribution - diffuse += dotNL * lightColor; + diffuse += dotNL * lightColor; - // Specular - if (uShininess > 0.0) { - float3 viewVec = normalize(-vViewPos); // Assuming camera at origin - float3 halfVec = normalize(lightVec + viewVec); - float dotNH = max(dot(vNormal, halfVec), 0.0); - float spec = pow(dotNH, uShininess); - specular += spec * lightColor; - } + // Specular + //float enableSpec = (dotNL > 0.0) * (uShininess > 0.0); + if (dotNL > 0.0 && uShininess > 0.0) { + float3 halfVec = normalize(lightVec + viewVec); + float dotNH = max(dot(vNormal, halfVec), 0.0); + float spec = pow(dotNH, uShininess); + specular += spec * lightColor; } } - outColor = uColor; outColor.rgb = clamp(diffuse * uColor.rgb + specular, 0.0, 1.0); - if (uUseTexture != 0) { - float4 texel = tex2D(uTexture, vTexCoord); - outColor.rgb *= texel.rgb; - outColor.rgb = clamp(outColor.rgb, 0.0, 1.0); - } - - //outColor = float4(vNormal, 1.0); -} \ No newline at end of file + outColor.a = uColor.a; +#if TEXTURED + float4 texel = tex2D(uTexture, vTexCoord); + outColor.rgb *= texel.rgb; +#endif +} diff --git a/miniwin/src/d3drm/backends/gxm/shaders/main.frag.gxp b/miniwin/src/d3drm/backends/gxm/shaders/main.frag.gxp deleted file mode 100644 index d5861ad803e5b96bf967704e8f15ec9fb9e479ea..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1480 zcmaJ>O=uHA6n-M2a)K-g0)Uaz!U`Q9|%RH)Sv-rq-nsD%r;vs zjUs{vg&xvsZw2dJWJNs){?wZ{TPx^MdTOOLzPG#4wG|)CzWLsJ-@G^TX7<>*K46hP zAIDQ1VQC0}hB||M z(WB71uoveHbsuUqz^EXJxbELaj^Dymba}Cc>Bh;N417jn15S!2a+!f&w(P1p@bDYJ z?lg~#b^#<(zNUc0Dt!f0S4ex(kof^pnID_z&2ni!o@{hQ_w-3aj@y>qQ#BwalihZz z)wLI`BgSo|3R08m!a@vKUyJ@?`BtM8puv&`HsW-EtnwgE4=^eaI;_OU zY-6%f2w)v|URHKme*G+{AEfo6%U0G$1aMAlZ94zG!*4NhY@(b-jG?6QEGO4}QLt*Jg%0sYhC@ z+2P~hYVQKOUT*kq^K4eNAJm>=9ad$^t4D9fzE_@DsSBA-XUB{t3XXY0C;iqO1zQ6n z&bLQo7u{un{q*}F*S&o)xgt4Ra9*+n!k{Hq>-UMB8;oRU~#seFfXxPL=+h*p$jZ8FbVxny$GhHYRjXE~D D%AquN diff --git a/miniwin/src/d3drm/backends/gxm/shaders/main.texture.frag.gxp b/miniwin/src/d3drm/backends/gxm/shaders/main.texture.frag.gxp new file mode 100644 index 0000000000000000000000000000000000000000..08717777e930058b4ab6f9c83d606a9548284f1b GIT binary patch literal 1372 zcmb_bO-vI}5T4g=>lUcnA~8#pur#x4#l%xG3s1q*R*0a3kGG)L(ep1ATf)-n{i&zKX$|O{XP&~Lx(*a^S%+SD;Y1y#iv@8WH73p> zO}*?_`lRoPo}b*-9k6dfo6OkQBw)xXX8@QM1KYJFCn3urE0pZI{zInD=gK5W>9>&>p@6sz*#=&jE6yH@Xi z&lTL*G%<^i+OQT8ke3m2U1w0n1%zqRbPv$-oX=(I0Pa_qd85h`dBLw_d@H{tzu)av zxS!o69?z`Eg3rbk*9lSJj)G-!~MdFd@XnoMb$ar|@ jkh9}xCOM8}lCLf^@c2O_JQ^3JA#pSOB%T-#^S=K80e(HU literal 0 HcmV?d00001 diff --git a/miniwin/src/internal/d3drmrenderer_gxm.h b/miniwin/src/internal/d3drmrenderer_gxm.h index 354d1524..0e604527 100644 --- a/miniwin/src/internal/d3drmrenderer_gxm.h +++ b/miniwin/src/internal/d3drmrenderer_gxm.h @@ -20,6 +20,8 @@ DEFINE_GUID(GXM_GUID, 0x682656F3, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, #define GXM_VERTEX_BUFFER_COUNT 2 #define GXM_FRAGMENT_BUFFER_COUNT 3 +//#define GXM_PRECOMPUTE + struct GXMTextureCacheEntry { IDirect3DRMTexture* texture; Uint32 version; @@ -35,6 +37,14 @@ struct GXMMeshCacheEntry { void* vertexBuffer; void* indexBuffer; uint16_t indexCount; + +#ifdef GXM_PRECOMPUTE + void* precomputeData; + void* uniformBuffers; + SceGxmPrecomputedVertexState vertexState[GXM_VERTEX_BUFFER_COUNT]; + SceGxmPrecomputedFragmentState fragmentState[GXM_FRAGMENT_BUFFER_COUNT]; + SceGxmPrecomputedDraw drawState; +#endif }; typedef struct GXMDisplayData { @@ -50,8 +60,8 @@ struct SceneLightGXM { static_assert(sizeof(SceneLightGXM) == 4*4*3); struct GXMSceneLightUniform { - SceneLightGXM lights[3]; - int lightCount; + SceneLightGXM lights[2]; + float ambientLight[3]; }; @@ -175,15 +185,20 @@ class GXMRenderer : public Direct3DRMRenderer { // shader SceGxmShaderPatcherId mainVertexProgramId; - SceGxmShaderPatcherId mainFragmentProgramId; + SceGxmShaderPatcherId mainColorFragmentProgramId; + SceGxmShaderPatcherId mainTextureFragmentProgramId; SceGxmShaderPatcherId imageFragmentProgramId; SceGxmShaderPatcherId colorFragmentProgramId; - SceGxmVertexProgram* mainVertexProgram; // 3d vert - SceGxmFragmentProgram* opaqueFragmentProgram; // 3d with no transparency - SceGxmFragmentProgram* transparentFragmentProgram; // 3d with transparency - SceGxmFragmentProgram* imageFragmentProgram; // 2d images, no lighting - SceGxmFragmentProgram* colorFragmentProgram; // 2d color, no lighting + SceGxmVertexProgram* mainVertexProgram; + // with lighting + SceGxmFragmentProgram* opaqueColorFragmentProgram; + SceGxmFragmentProgram* blendedColorFragmentProgram; + SceGxmFragmentProgram* opaqueTextureFragmentProgram; + SceGxmFragmentProgram* blendedTextureFragmentProgram; + // no lighting + SceGxmFragmentProgram* imageFragmentProgram; + SceGxmFragmentProgram* colorFragmentProgram; // main shader vertex uniforms const SceGxmProgramParameter* uModelViewMatrix; @@ -191,11 +206,14 @@ class GXMRenderer : public Direct3DRMRenderer { const SceGxmProgramParameter* uProjectionMatrix; // main shader fragment uniforms - const SceGxmProgramParameter* uLights; - const SceGxmProgramParameter* uLightCount; - const SceGxmProgramParameter* uShininess; - const SceGxmProgramParameter* uColor; - const SceGxmProgramParameter* uUseTexture; + const SceGxmProgramParameter* color_uLights; + const SceGxmProgramParameter* color_uAmbientLight; + const SceGxmProgramParameter* color_uShininess; + const SceGxmProgramParameter* color_uColor; + const SceGxmProgramParameter* texture_uLights; + const SceGxmProgramParameter* texture_uAmbientLight; + const SceGxmProgramParameter* texture_uShininess; + const SceGxmProgramParameter* texture_uColor; // color shader frament uniforms const SceGxmProgramParameter* colorShader_uColor;