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
Absolument. Après une analyse détaillée du code, je peux vous donner une explication complète et précise de son fonctionnement.
C'est un excellent exemple de shader utilitaire pour ReShade.
Objectif Principal du Shader
Ce code est un shader pour ReShade dont le but est de détecter l'interface utilisateur (UI ou HUD) d'un jeu. Son objectif final est de désactiver tous les autres effets graphiques de ReShade (comme le flou, la netteté, les corrections de couleur, etc.) lorsque cette interface est visible à l'écran.
Pourquoi faire ça ? Pour éviter que les effets graphiques n'altèrent la lisibilité de l'interface. Par exemple, un effet de flou cinématique ne doit pas s'appliquer sur la carte ou la barre de vie. Un effet de grain de film ne doit pas rendre le texte illisible. Ce shader agit donc comme un "interrupteur" intelligent.
Explication Détaillée du Fonctionnement (Étape par Étape)
Le shader fonctionne en trois passes distinctes, orchestrées par les
techniqueà la fin du fichier. C'est un processus très courant dans ReShade pour ce genre de tâche.Étape 1 : Sauvegarde de l'image originale (
technique UIDetect_Before)- Quand ? Cette passe s'exécute avant tous les autres effets graphiques.
- Quoi ? Elle utilise le pixel shader
PS_StoreColorMAP. - Action : Ce shader est très simple. Il prend l'image du jeu telle qu'elle est à l'origine (
ReShade::BackBuffer) et la copie dans une texture de sauvegarde nomméetexColorOrigMAP. - Résultat : On dispose maintenant d'une copie intacte de l'image du jeu, non modifiée par les effets de ReShade.
Étape 2 : Détection de l'interface (
technique UIDetect)- Quand ? Cette passe s'exécute juste après la sauvegarde, mais toujours avant les autres effets principaux.
- Quoi ? Elle utilise le pixel shader
PS_UIDetectMAP. - Action : C'est le cœur de la logique.
- Optimisation : D'abord, il vérifie
if((FrameIndex % SKIP_FRAMES) != 0).FrameIndexest le numéro de l'image actuelle.SKIP_FRAMESest défini à30. Cela signifie que la détection ne s'exécute qu'une fois toutes les 30 images. C'est une optimisation cruciale, car l'interface utilisateur ne change généralement pas à chaque image, et cela évite de consommer des ressources inutilement. - Zones de Détection : Le shader définit quatre rectangles de détection (
R1àR4) à des endroits précis de l'écran, avec des tailles et des couleurs spécifiques.R1: Une petite zone en bas à droite (0.96, 0.975). Il y cherche une ligne horizontale de 4 pixels de couleur beige(197,194,158).R2: Une zone verticale sur le côté gauche (0.042, 0.53). Il y cherche aussi une ligne horizontale de 4 pixels de la même couleur beige.R3: Une zone assez large vers le centre (0.56, 0.50). Il y cherche un bloc vertical de 2x10 pixels de couleur noire(0,0,0).R4: Une toute petite zone en haut à gauche (0.01, 0.005). Il y cherche un bloc horizontal de 15x2 pixels de couleur noire(0,0,0).
- Fonctions de détection (
D1àD4) : Chaque fonction parcourt sa zone respective et cherche la présence exacte du motif de pixels défini. Si le motif est trouvé, la fonction renvoietrue. - Le Drapeau : Le shader
PS_UIDetectMAPécrit son résultat (soit1si une UI est détectée dans l'une des zones, soit0sinon) dans une minuscule texture de 1x1 pixel nomméetexUIDetectMAP. Cette texture agit comme un simple "drapeau" ou un interrupteur global (ON/OFF).
- Optimisation : D'abord, il vérifie
Étape 3 : Restauration de l'image si nécessaire (
technique UIDetect_After)- Quand ? Cette passe s'exécute en dernier, après que tous les autres effets graphiques de ReShade (ceux que l'on veut potentiellement désactiver) ont été appliqués.
- Quoi ? Elle utilise le pixel shader
PS_RestoreColorMAP. - Action : Pour chaque pixel de l'écran :
- Il lit la valeur du drapeau dans la texture
texUIDetectMAP. - Il récupère la couleur du pixel de l'image modifiée par les effets (
ReShade::BackBuffer). - Il récupère la couleur du pixel de l'image originale sauvegardée à l'étape 1 (
ColorOrigMAP). - Il exécute la logique décisive :
c = ui==0 ? c : o;- Si le drapeau
uiest à0(pas d'UI détectée), le pixel final est le pixelc(modifié par les effets). Les effets graphiques sont visibles. - Si le drapeau
uiest à1(UI détectée), le pixel final est le pixelo(de l'image originale). L'image est restaurée à son état d'origine, annulant ainsi tous les effets précédents.
- Si le drapeau
- Il lit la valeur du drapeau dans la texture
Composants Clés et Détails Supplémentaires
#define R1...R4: Ce sont les définitions des zones de détection. Elles sont très spécifiques à un jeu et à une résolution particuliers. Pour que ce shader fonctionne sur un autre jeu, il faudrait probablement ajuster les coordonnées (ANCHOR), les tailles (WIDTH,HEIGHT) et les couleurs (COLOR) pour qu'elles correspondent à l'interface de ce nouveau jeu.#include "NeatPerfection.ini": Cette ligne indique que ce shader fait partie d'un preset ReShade plus large, probablement nommé "Neat Perfection". Le fichier.inicontient les paramètres qui peuvent être modifiés via l'interface de ReShade, comme l'activation du modeDebug.uniform bool Debug = false;: C'est une variable que vous pouvez activer dans le menu ReShade. Si vous la passez àtrue, le shader dessinera des bordures rouges autour des quatre zones de détection. C'est un outil extrêmement utile pour l'auteur (et pour vous) afin de visualiser où le shader "regarde" et de vérifier que les zones sont bien positionnées.
En Résumé
Ce code est un détecteur d'interface utilisateur (UI) intelligent et optimisé pour ReShade.
- Il sauvegarde l'image propre du jeu.
- Il cherche (de manière peu coûteuse, une fois toutes les 30 images) des éléments d'UI très spécifiques (des lignes ou blocs de pixels d'une couleur précise) dans quatre zones prédéfinies de l'écran.
- S'il trouve quelque chose, il lève un "drapeau".
- À la toute fin, il vérifie ce drapeau :
- Drapeau baissé : Il ne fait rien, laissant les effets graphiques de ReShade s'afficher.
- Drapeau levé : Il remplace l'image modifiée par la sauvegarde de l'image propre, annulant ainsi tous les effets pour ce "frame".
C'est une technique sophistiquée pour assurer une parfaite intégration des mods graphiques sans compromettre la fonctionnalité de l'interface du jeu.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.