Voici mon code, tu peux m'expliquer exactement ce qu'il fait stp ??? : /* Copyright (c)…
- User
Voici mon code, tu peux m'expliquer exactement ce qu'il fait stp ??? :
/* Copyright (c) 2025 Nyzoka. All rights reserved.
This shader is free to use for personal projects. Unauthorized copying, modification, redistribution, or commercial use is strictly prohibited without permission from the author. Credit to the author must be included in any permitted use. */
#include "ReShade.fxh"
#define R1_WIDTH 50 #define R1_HEIGHT 30 #define R1_ANCHOR float2(0.96, 0.975) #define R1_COLOR float3(197,194,158)
#define R2_WIDTH 15 #define R2_HEIGHT 100 #define R2_ANCHOR float2(0.042, 0.53) #define R2_COLOR float3(197,194,158)
#define R3_WIDTH 80 #define R3_HEIGHT 20 #define R3_ANCHOR float2(0.56, 0.50) #define R3_COLOR float3(0,0,0)
#define R4_WIDTH 20 #define R4_HEIGHT 4 #define R4_ANCHOR float2(0.01, 0.005) #define R4_COLOR float3(0,0,0)
#define SKIP_FRAMES 30
uniform bool Debug = false; uniform uint FrameIndex < source = "framecount"; >;
texture texColorOrigMAP { Width = BUFFER_WIDTH; Height = BUFFER_HEIGHT; }; sampler ColorOrigMAP { Texture = texColorOrigMAP; };
texture texUIDetectMAP { Width = 1; Height = 1; Format = R8; }; sampler UIDetectMAP { Texture = texUIDetectMAP; };
float3 S(int2 p){ return round(tex2Dlod(ReShade::BackBuffer, float4((float2(p)+0.5)BUFFER_PIXEL_SIZE,0,0)).rgb255); }
bool D1(int2 s,int2 e){ [loop]for(int y=s.y;y<e.y;++y) [loop]for(int x=s.x;x<=e.x-3;++x){ bool ok=true; [unroll]for(int k=0;k<4&&ok;++k) ok&=!any(abs(S(int2(x+k,y))-R1_COLOR)); if(ok) return true; } return false; } bool D2(int2 s,int2 e){ [loop]for(int y=s.y;y<e.y;++y) [loop]for(int x=s.x;x<=e.x-3;++x){ bool ok=true; [unroll]for(int k=0;k<4&&ok;++k) ok&=!any(abs(S(int2(x+k,y))-R2_COLOR)); if(ok) return true; } return false; } bool D3(int2 s,int2 e){ [loop]for(int y=s.y;y<=e.y-9;++y) [loop]for(int x=s.x;x<=e.x-1;++x){ bool ok=true; [unroll]for(int c=0;c<2&&ok;++c) [unroll]for(int r=0;r<10&&ok;++r) ok&=!any(abs(S(int2(x+c,y+r))-R3_COLOR)); if(ok) return true; } return false; } bool D4(int2 s,int2 e){ [loop]for(int y=s.y;y<=e.y-1;++y) [loop]for(int x=s.x;x<=e.x-14;++x){ bool ok=true; [unroll]for(int r=0;r<2&&ok;++r) [unroll]for(int c=0;c<15&&ok;++c) ok&=!any(abs(S(int2(x+c,y+r))-R4_COLOR)); if(ok) return true; } return false; }
void GetRegion(float2 anchor, int2 size, out int2 s, out int2 e, uint w, uint h){ int2 a = int2(anchor * float2(w, h)); s = max(a - size / 2, 0); e = min(s + size, int2(w, h)); }
float PS_UIDetectMAP(float4 pos:SV_Position, float2 tc:TEXCOORD):SV_Target{ if((FrameIndex % SKIP_FRAMES) != 0) discard;
uint w = BUFFER_WIDTH, h = BUFFER_HEIGHT; int2 s,e;
GetRegion(R1_ANCHOR, int2(R1_WIDTH, R1_HEIGHT), s, e, w, h); if(D1(s,e)) return 1; GetRegion(R2_ANCHOR, int2(R2_WIDTH, R2_HEIGHT), s, e, w, h); if(D2(s,e)) return 1; GetRegion(R3_ANCHOR, int2(R3_WIDTH, R3_HEIGHT), s, e, w, h); if(D3(s,e)) return 1; GetRegion(R4_ANCHOR, int2(R4_WIDTH, R4_HEIGHT), s, e, w, h); if(D4(s,e)) return 1;
return 0; }
#include "NeatPerfection.ini"
float4 PS_StoreColorMAP(float4 pos:SV_Position, float2 tc:TEXCOORD):SV_Target{ return tex2D(ReShade::BackBuffer, tc); }
float4 PS_RestoreColorMAP(float4 pos:SV_Position, float2 tc:TEXCOORD):SV_Target{ float ui = tex2D(UIDetectMAP,float2(0,0)).x; float4 o = tex2D(ColorOrigMAP,tc), c = tex2D(ReShade::BackBuffer,tc); c = ui==0 ? c : o;
if(Debug){ uint w=BUFFER_WIDTH,h=BUFFER_HEIGHT; float2 p=tc*float2(w,h);
int2 s1,e1,s2,e2,s3,e3,s4,e4; GetRegion(R1_ANCHOR, int2(R1_WIDTH, R1_HEIGHT), s1, e1, w, h); GetRegion(R2_ANCHOR, int2(R2_WIDTH, R2_HEIGHT), s2, e2, w, h); GetRegion(R3_ANCHOR, int2(R3_WIDTH, R3_HEIGHT), s3, e3, w, h); GetRegion(R4_ANCHOR, int2(R4_WIDTH, R4_HEIGHT), s4, e4, w, h); bool b1=((abs(p.x-s1.x)<1||abs(p.x-e1.x)<1)&&(p.y>=s1.y&&p.y<=e1.y))||((abs(p.y-s1.y)<1||abs(p.y-e1.y)<1)&&(p.x>=s1.x&&p.x<=e1.x)); bool b2=((abs(p.x-s2.x)<1||abs(p.x-e2.x)<1)&&(p.y>=s2.y&&p.y<=e2.y))||((abs(p.y-s2.y)<1||abs(p.y-e2.y)<1)&&(p.x>=s2.x&&p.x<=e2.x)); bool b3=((abs(p.x-s3.x)<1||abs(p.x-e3.x)<1)&&(p.y>=s3.y&&p.y<=e3.y))||((abs(p.y-s3.y)<1||abs(p.y-e3.y)<1)&&(p.x>=s3.x&&p.x<=e3.x)); bool b4=((abs(p.x-s4.x)<1||abs(p.x-e4.x)<1)&&(p.y>=s4.y&&p.y<=e4.y))||((abs(p.y-s4.y)<1||abs(p.y-e4.y)<1)&&(p.x>=s4.x&&p.x<=e4.x)); if(b1||b2||b3||b4) c=float4(1,0,0,1);} return c; }
technique UIDetect { pass { VertexShader=PostProcessVS; PixelShader=PS_UIDetectMAP; RenderTarget=texUIDetectMAP; ClearRenderTargets=false; } } technique UIDetect_Before { pass { VertexShader=PostProcessVS; PixelShader=PS_StoreColorMAP; RenderTarget=texColorOrigMAP; ClearRenderTargets=true; } } technique UIDetect_After { pass { VertexShader=PostProcessVS; PixelShader=PS_RestoreColorMAP; ClearRenderTargets=true; } }
Prend le temps, fais des recherches, enquete, passe en revu tes reflexion puis repond moi uniquement quand te sera sur de toi.
- Assistant
Je vais te proposer une explication détaillée et structurée de ce que fait ce shader, en passant en revue ses différentes parties et leur rôle. Ce code, écrit pour ReShade (un outil de post‑traitement en temps réel), a pour objectif de “détecter” et de “masquer” certains éléments d’interface (UI) en fonction de critères basés sur des zones et des couleurs prédéfinies. Voici le détail :
1. Définitions et constantes
Le code commence par définir plusieurs macros qui décrivent 4 régions (R1 à R4) de l’écran. Pour chacune, on définit :
-
La taille en pixels (largeur et hauteur) :
– Par exemple,R1_WIDTH 50etR1_HEIGHT 30. -
L’ancrage (anchor) en coordonnées relatives (valeurs comprises entre 0 et 1) :
– Par exemple,R1_ANCHOR float2(0.96, 0.975)positionne cette région près du coin inférieur droit. -
La couleur cible en composantes RGB (ici, des entiers non normalisés) :
– Par exemple,R1_COLOR float3(197,194,158).
De plus, une constante
SKIP_FRAMESest définie avec la valeur 30, ce qui servira plus tard pour ne pas exécuter la détection à chaque image.
2. Uniformes et ressources
-
Uniformes :
–bool Debugpermet de déclencher un mode débug visuel qui trace les contours des régions de détection.
–uint FrameIndexest lié au compteur de frames (viaframecount), utile pour le contrôle de la fréquence d’exécution. -
Textures et samplers :
–texColorOrigMAPest une texture de la taille totale de la frame (BUFFER_WIDTH x BUFFER_HEIGHT) qui va stocker une copie de l’image d’origine avant superposition de l’UI.
–texUIDetectMAPest une texture 1×1 (format R8) qui va contenir le résultat de la détection (valeur 1 si un élément UI est détecté, 0 sinon).
3. Fonctions utilitaires
La fonction
S(int2 p)float3 S(int2 p) { return round(tex2Dlod(ReShade::BackBuffer, float4((float2(p)+0.5) * BUFFER_PIXEL_SIZE, 0, 0)).rgb255); }- But :
Cette fonction échantillonne la couleur du tampon arrière (BackBuffer) à la position de pixel donnée parp, en ajoutant 0.5 pour centrer l’échantillonnage dans le pixel. - Traitement :
La couleur obtenue est convertie en espace 0–255 puis arrondie. - Utilité :
Elle permet d’obtenir la couleur exacte d’un pixel afin de comparer avec la couleur cible définie pour chaque région.
La fonction
GetRegion(...)void GetRegion(float2 anchor, int2 size, out int2 s, out int2 e, uint w, uint h)- But :
Calcule les coordonnées entières de début (s) et de fin (e) d’une zone à partir d’un ancrage (position relative) et d’une taille donnée. - Explication :
– L’ancrage est multiplié par la taille de la fenêtre pour obtenir une coordonnée centrale.
– Le point de départsest calculé en décalant ce point central de la moitié de la taille (et en s’assurant qu’on ne sorte pas de l’écran en utilisantmax(..., 0)).
– Le point de finecorrespond às + sizemais est clippé aux dimensions de l’écran (avecmin(..., int2(w, h))).
Les fonctions de détection
D1,D2,D3etD4Ces fonctions ont un rôle très similaire :
Elles parcourent une zone rectangulaire (délimitée par les coordonnéessete) et recherchent la présence d’un « bloc » de pixels dont la couleur correspond exactement à la couleur prédéfinie pour la région concernée (R1_COLOR pour D1, R2_COLOR pour D2, etc.).Chaque fonction exécute :
- Une double boucle sur les coordonnées (x et y) dans la zone définie.
- Pour chaque position de départ dans la zone, une boucle interne (avec
[unroll]pour optimiser) teste une suite de pixels (par exemple, 4 pixels horizontalement pour D1 et D2, une zone de 2×10 pixels pour D3, et 15 pixels sur 2 lignes pour D4). - Pour chacun de ces pixels, la fonction
Sest utilisée pour récupérer la couleur. - La comparaison se fait par la soustraction et la fonction
any(abs(...))qui renvoie vrai si une des composantes diffère (puis l’opérateur!vérifie l’égalité exacte avec la couleur cible).
Si pour l’un des blocs dans la zone la totalité des pixels correspond à la couleur cible, la fonction retourne
true(donc détection positive).
4. Pixel shader de détection :
PS_UIDetectMAPfloat PS_UIDetectMAP(...) { if((FrameIndex % SKIP_FRAMES) != 0) discard; ... GetRegion(R1_ANCHOR, int2(R1_WIDTH, R1_HEIGHT), s, e, w, h); if(D1(s,e)) return 1; GetRegion(R2_ANCHOR, int2(R2_WIDTH, R2_HEIGHT), s, e, w, h); if(D2(s,e)) return 1; GetRegion(R3_ANCHOR, int2(R3_WIDTH, R3_HEIGHT), s, e, w, h); if(D3(s,e)) return 1; GetRegion(R4_ANCHOR, int2(R4_WIDTH, R4_HEIGHT), s, e, w, h); if(D4(s,e)) return 1; return 0; }-
Contrôle de l’exécution :
La détection n’est réalisée que sur 1 frame surSKIP_FRAMES(ici, toutes les 30 frames). Si ce n’est pas le tour, le shader se "discarte" (ne produit aucun résultat). -
Traitement :
Pour chaque région (R1 à R4) :- On calcule la zone à l’aide de
GetRegion. - On appelle la fonction de détection correspondante (D1, D2, …) pour vérifier la présence d’un bloc de pixels de la couleur cible.
- Si l’une de ces fonctions retourne
true, le shader renvoie 1 (indiquant qu’une UI a été détectée).
- On calcule la zone à l’aide de
-
Résultat :
La valeur 1 (sinon 0) est écrite dans la texture 1×1texUIDetectMAP.
5. Sauvegarde et restauration du backbuffer
Il y a deux autres pixel shaders qui jouent un rôle dans le processus global :
a)
PS_StoreColorMAPfloat4 PS_StoreColorMAP(...) { return tex2D(ReShade::BackBuffer, tc); }- But :
Sauvegarder le contenu actuel du backbuffer (c’est-à-dire l’image finale de la frame avant modification) dans la texturetexColorOrigMAP. - Utilité :
Cela permet de disposer d’une “copie originale” de l’image avant que l’UI (dont on veut potentiellement se débarrasser) ne soit superposée.
b)
PS_RestoreColorMAPfloat4 PS_RestoreColorMAP(...) { float ui = tex2D(UIDetectMAP,float2(0,0)).x; float4 o = tex2D(ColorOrigMAP,tc), c = tex2D(ReShade::BackBuffer,tc); c = ui==0 ? c : o; ... if(Debug){ ... red border drawing ... } return c; }-
Fonctionnement :
– Le shader lit la valeur de la texture de détection (UIDetectMAP).
– Il échantillonne à la fois la couleur actuelle (c) et la couleur originale stockée (o). – Décision :- Si aucune UI n’a été détectée (ui == 0), le shader laisse la couleur actuelle intacte.
- Sinon (ui != 0), il restaure l’image en affichant la couleur originale (effaçant ainsi l’UI détectée).
-
Mode débogage (Debug) :
Si l’optionDebugest activée, le shader dessine des contours rouges autour des régions de détection. Pour cela, il retrace les bords calculés avecGetRegionpour chaque région. Cela permet de visualiser les zones dans lesquelles le test de détection est effectué.
6. Techniques et passes ReShade
À la fin du fichier, trois techniques (qui regroupent des passes de rendu dans ReShade) sont définies :
-
Technique
UIDetect_Before:- Pass :
UtilisePS_StoreColorMAPpour copier le backbuffer original danstexColorOrigMAP. - But :
Sauvegarder l’état de l’image avant que l’UI soit éventuellement dessinée ultérieurement.
- Pass :
-
Technique
UIDetect:- Pass :
UtilisePS_UIDetectMAPpour analyser certaines régions de l’écran et écrire le résultat (0 ou 1) danstexUIDetectMAP. - Note :
La cible de rendu n’est pas effacée (ClearRenderTargets = false) pour préserver la valeur entre les passes.
- Pass :
-
Technique
UIDetect_After:- Pass :
UtilisePS_RestoreColorMAPpour décider, pixel par pixel, d’afficher soit la couleur actuelle du backbuffer, soit la couleur originale stockée, en fonction du résultat de la détection. - But :
Si l’UI (ou un élément correspondant aux zones/couleurs définies) a été détectée, l’image est “restaurée” afin de masquer cet élément.
- Pass :
Conclusion
En résumé, ce shader effectue les opérations suivantes :
- Sauvegarde (via
PS_StoreColorMAP) de l’image originale du backbuffer dans une texture temporaire. - Détection (via
PS_UIDetectMAP) sur 4 zones prédéfinies de l’écran, en recherchant des blocs de pixels dont la couleur exacte correspond à celles définies (pour R1, R2, R3 et R4). La détection n’est réalisée qu’une fois toutes les 30 frames. - Restauration (via
PS_RestoreColorMAP) :- Si une des zones a été détectée (la texture de détection contient 1), alors le shader utilise la copie originale de l’image pour les pixels concernés, masquant ainsi ce qu’il considère être l’UI à supprimer.
- Sinon, il laisse l’image telle quelle.
- Mode Debug :
- Si activé, il trace en rouge les contours des zones de détection pour aider à visualiser où la détection s’opère.
L’ensemble du système semble destiné à "nettoyer" l’affichage en retirant (ou en masquant) certains éléments d’interface repérés par leur couleur et leur position. Cela peut servir par exemple à supprimer un overlay indésirable ou à éviter qu’un élément de l’UI interfère avec d’autres traitements graphiques.
J’espère que cette explication détaillée te permet de bien comprendre le fonctionnement et l’intention de ce code shader !
-
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.