Skip to content
TheChatArchiveThe Chat Archive
Googlegemma-3-27b-it· GoogleHugging Face Arena Expert 5K

#include "ReShade.fxh"…

  1. User

    #include "ReShade.fxh"

    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // ZONE DE CONFIGURATION //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

    #define PIXELNUMBER 24

    static const float3 UIPixelCoord_UINr[PIXELNUMBER]= { float3(1363,318,1), // float3(1363,781,1), float3(920,133,2), // Book float3(962,146,2), float3(883,75,3), // Paper float3(924,93,3), float3(679,92,4), // Paper2 float3(696,94,4), float3(61,1050,5), // Intro float3(259,1070,5), float3(407,1060,5), float3(1737,10,5), float3(1799,18,5), float3(1857,16,5), float3(1035,1048,5), float3(1465,1046,5), float3(888,80,6), // Paper 3 float3(882,87,6), float3(710,74,7), // Paper 4 float3(728,75,7), float3(912,145,8), // TP Confirm float3(927,145,8), float3(600,89,9), // Paper 5 float3(611,96,9), };

    static const float3 UIPixelRGB[PIXELNUMBER]= { float3(68,62,36), // float3(51,46,27), float3(195,172,137), // book float3(99,77,49), float3(181,146,90), // paper float3(206,178,123), float3(189,154,115), // paper2 float3(173,125,82), float3(0,0,0), // intro/log/loading float3(0,0,0), float3(0,0,0), float3(0,0,0), float3(0,0,0), float3(0,0,0), float3(0,0,0), float3(0,0,0), float3(113,35,0), // paper 3 float3(123,88,56), float3(90,69,41), // paper 4 float3(165,142,90), float3(104,101,85), // tp confirm float3(57,55,47), float3(107,28,16), // paper 5 float3(151,104,52), };

    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // FIN DE ZONE DE CONFIGURATION //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

    // Variables globales #define offset_ 0.5

    // Textures et échantillonneurs texture texColorOrig { Width = BUFFER_WIDTH; Height = BUFFER_HEIGHT; }; sampler ColorOrig { Texture = texColorOrig; };

    texture texUIDetect { Width = 1; Height = 1; Format = R8; }; sampler UIDetect { Texture = texUIDetect; };

    // Shaders de pixels float PS_UIDetect(float4 pos : SV_Position, float2 texcoord : TEXCOORD) : SV_Target { float3 pixelColor, uiPixelColor, diff; float2 pixelCoord; float ui = 1; bool uiDetected = false; bool uiNext = false;

    for (int i = 0; i < PIXELNUMBER; i++) { [branch] if (UIPixelCoord_UINr[i].z - ui == 0) { if (uiNext == false) { pixelCoord = float2(UIPixelCoord_UINr[i].x + offset_, UIPixelCoord_UINr[i].y + offset_) * BUFFER_PIXEL_SIZE; pixelColor = round(tex2Dlod(ReShade::BackBuffer, float4(pixelCoord, 0, 0)).rgb * 255); uiPixelColor = UIPixelRGB[i].rgb; diff = pixelColor - uiPixelColor; if (!any(diff)) { uiDetected = true; } else { uiDetected = false; uiNext = true; } } } else { if (uiDetected == true) return ui * 0.1; ui += 1; uiNext = false; i -= 1; } } return uiDetected * ui * 0.1; }

    #include "NeatPerfection.ini"

    float4 PS_StoreColor(float4 pos : SV_Position, float2 texcoord : TEXCOORD) : SV_Target { return tex2D(ReShade::BackBuffer, texcoord); }

    float4 PS_RestoreColor(float4 pos : SV_Position, float2 texcoord : TEXCOORD) : SV_Target { float ui = tex2D(UIDetect, float2(0, 0)).x; float4 colorOrig = tex2D(ColorOrig, texcoord); float4 color = tex2D(ReShade::BackBuffer, texcoord); color = ui == 0 ? color : colorOrig; return color; }

    // Techniques technique UIDetect < ui_tooltip = "UIDetect can be used to automatically toggle effects depending on the\n" "visibility of UI elements. It is configured by editing the defines at the top of this file.\n";

    { pass { VertexShader = PostProcessVS; PixelShader = PS_UIDetect; RenderTarget = texUIDetect; ClearRenderTargets = true; } }

    technique UIDetect_Before { pass { VertexShader = PostProcessVS; PixelShader = PS_StoreColor; RenderTarget = texColorOrig; ClearRenderTargets = true; } }

    technique UIDetect_After { pass { VertexShader = PostProcessVS; PixelShader = PS_RestoreColor; ClearRenderTargets = true; } }

    Voici mon shader .fx pour Reshade, celui ci permet de bypass les effets situé entre les 2 balise Before et After dans la pipeline de reshade lorsque des pixels, precisement d'une certaine couleur, sont a un localisation bien precise dans l'image. Malheureusement, cette technique est dépendante de la position exacte des pixels. Dans une résolution différente, leurs position sera forcement différente, et la détection de la condition sera loupé. Donc j'aimerai explorer une autre methode de detection de pixels en cherchant des Pattern de pixels. (tu pourra effacer tout les profils de pixels et coordoné que j'ai déjà entrés dans la zone de configuration, qui seronts obsolete avec cette nouvelle methode). comme le fait d'analyser la couleur de tout les pixels de l'image a chaque frame sera extrêmement couteux, Nous allons donc restreindre la détection a certaines Zones de l'image:

    Zone de Détection 1 :

    • Position du centre de la zone :
      • Sur l'axe horizontal : à 96% de la largeur totale de l'écran (ce qui le place très à droite).
      • Sur l'axe vertical : à 97,5% de la hauteur totale de l'écran (ce qui le place tout en bas).
    • Dimensions de la zone :
      • Largeur : 50 pixels.
      • Hauteur : 30 pixels.
    • Motif à trouver n'importe où dans cette zone : Une ligne horizontale continue d'au moins 4 pixels de large, où chaque pixel de cette ligne est exactement d'une teinte beige clair (composantes Rouge 197, Verte 194, Bleue 158).

    Zone de Détection 2 :

    • Position du centre de la zone :
      • Sur l'axe horizontal : à 4,2% de la largeur totale de l'écran (ce qui le place très à gauche).
      • Sur l'axe vertical : à 53% de la hauteur totale de l'écran (ce qui le place légèrement en dessous du milieu).
    • Dimensions de la zone :
      • Largeur : 15 pixels.
      • Hauteur : 100 pixels.
    • Motif à trouver n'importe où dans cette zone : Une ligne horizontale continue d'au moins 4 pixels de large, où chaque pixel de cette ligne est exactement d'une teinte beige clair (composantes Rouge 197, Verte 194, Bleue 158).

    Zone de Détection 3 :

    • Position du centre de la zone :
      • Sur l'axe horizontal : à 56% de la largeur totale de l'écran (ce qui le place légèrement à droite du centre).
      • Sur l'axe vertical : à 50% de la hauteur totale de l'écran (ce qui le place exactement au milieu).
    • Dimensions de la zone :
      • Largeur : 80 pixels.
      • Hauteur : 20 pixels.
    • Motif à trouver n'importe où dans cette zone : Un petit rectangle plein de 2 pixels de large et 10 pixels de haut, où chaque pixel à l'intérieur de ce petit rectangle est exactement de couleur noir pur (composantes Rouge 0, Verte 0, Bleue 0).

    Zone de Détection 4 :

    • Position du centre de la zone :
      • Sur l'axe horizontal : à 1% de la largeur totale de l'écran (ce qui le place tout à fait à gauche).
      • Sur l'axe vertical : à 0,5% (un demi pourcent) de la hauteur totale de l'écran (ce qui le place tout à fait en haut).
    • Dimensions de la zone :
      • Largeur : 20 pixels.
      • Hauteur : 4 pixels.
    • Motif à trouver n'importe où dans cette zone : Un petit rectangle plein de 15 pixels de large et 2 pixels de haut, où chaque pixel à l'intérieur de ce petit rectangle est exactement de couleur noir pur (composantes Rouge 0, Verte 0, Bleue 0).

    Ajoute aussi un uniform "case a cocher" de Debug qui, si activée, dessine des rectangles rouges autour des zones de détection pour visualiser leurs emplacement.

    Ajoute aussi un uniform pour choisir une valeur de FrameSkip (pour que le shader ne s'execute pas a toute les frame, afin d'économiser des ressource) par exemple avec 1, c'est le mode par défaut standard... s'execute normalement a chaque frame. avec 30, le shader s'execute une fois toute les 30 frames.

    Envoi moi ce code modifié pour essayer cette nouvelle methode stp, attention a ne surtout pas renommer les "technique". Retire les // commentaires, et N'ajoute pas non plus de // commentaire au code, ca sera plus concis.

  2. Google Assistant
    #include "ReShade.fxh"
    
    #define ZONE_COUNT 4
    
    static const int FRAME_SKIP_DEFAULT = 1;
    
    uniform int FrameSkip = FRAME_SKIP_DEFAULT;
    uniform bool DebugMode = false;
    
    // Zone definitions
    struct Zone {
        float2 Center;
        float2 Size;
        int PatternType; // 1: Horizontal Beige Line, 2: Horizontal Beige Line, 3: Black Rectangle, 4: Black Rectangle
    };
    
    static const Zone Zones[ZONE_COUNT] = {
        { float2(0.96, 0.975), float2(50, 30), 1 }, // Zone 1
        { float2(0.042, 0.53), float2(15, 100), 2 }, // Zone 2
        { float2(0.56, 0.50), float2(80, 20), 3 }, // Zone 3
        { float2(0.01, 0.005), float2(20, 4), 4 }  // Zone 4
    };
    
    static const float3 BeigeColor = float3(197, 194, 158);
    static const float3 BlackColor = float3(0, 0, 0);
    
    // Helper function to check for horizontal beige line
    bool CheckHorizontalBeigeLine(float2 texcoord, int width) {
        for (int i = 0; i < width; ++i) {
            float3 pixelColor = tex2D(ReShade::BackBuffer, texcoord + float2(i * BUFFER_PIXEL_SIZE.x, 0)).rgb;
            if (abs(pixelColor.r - BeigeColor.r) > 1 || abs(pixelColor.g - BeigeColor.g) > 1 || abs(pixelColor.b - BeigeColor.b) > 1) {
                return false;
            }
        }
        return true;
    }
    
    // Helper function to check for black rectangle
    bool CheckBlackRectangle(float2 texcoord, float2 size) {
        for (int y = 0; y < size.y; ++y) {
            for (int x = 0; x < size.x; ++x) {
                float3 pixelColor = tex2D(ReShade::BackBuffer, texcoord + float2(x * BUFFER_PIXEL_SIZE.x, y * BUFFER_PIXEL_SIZE.y)).rgb;
                if (abs(pixelColor.r - BlackColor.r) > 1 || abs(pixelColor.g - BlackColor.g) > 1 || abs(pixelColor.b - BlackColor.b) > 1) {
                    return false;
                }
            }
        }
        return true;
    }
    
    float PS_UIDetect(float4 pos : SV_Position, float2 texcoord : TEXCOORD) : SV_Target {
        static int frameCount = 0;
        frameCount++;
    
        if (frameCount % FrameSkip != 0) {
            return 0.0f;
        }
    
        bool uiDetected = false;
    
        for (int i = 0; i < ZONE_COUNT; ++i) {
            float2 zoneCenter = Zones[i].Center;
            float2 zoneSize = Zones[i].Size;
    
            float minX = zoneCenter.x - zoneSize.x / 2.0f;
            float maxX = zoneCenter.x + zoneSize.x / 2.0f;
            float minY = zoneCenter.y - zoneSize.y / 2.0f;
            float maxY = zoneCenter.y + zoneSize.y / 2.0f;
    
            if (texcoord.x >= minX && texcoord.x <= maxX && texcoord.y >= minY && texcoord.y <= maxY) {
                switch (Zones[i].PatternType) {
                    case 1:
                        if (CheckHorizontalBeigeLine(texcoord, 4)) {
                            uiDetected = true;
                            break;
                        }
                        break;
                    case 2:
                        if (CheckHorizontalBeigeLine(texcoord, 4)) {
                            uiDetected = true;
                            break;
                        }
                        break;
                    case 3:
                        if (CheckBlackRectangle(texcoord, float2(2, 10))) {
                            uiDetected = true;
                            break;
                        }
                        break;
                    case 4:
                        if (CheckBlackRectangle(texcoord, float2(15, 2))) {
                            uiDetected = true;
                            break;
                        }
                        break;
                }
            }
        }
    
        if (DebugMode) {
            for (int i = 0; i < ZONE_COUNT; ++i) {
                float2 zoneCenter = Zones[i].Center;
                float2 zoneSize = Zones[i].Size;
    
                float minX = zoneCenter.x - zoneSize.x / 2.0f;
                float maxX = zoneCenter.x + zoneSize.x / 2.0f;
                float minY = zoneCenter.y - zoneSize.y / 2.0f;
                float maxY = zoneCenter.y + zoneSize.y / 2.0f;
    
                if (texcoord.x >= minX && texcoord.x <= maxX && texcoord.y >= minY && texcoord.y <= maxY) {
                    return 1.0f; // Draw red rectangle
                }
            }
        }
    
        return uiDetected ? 1.0f : 0.0f;
    }
    
    #include "NeatPerfection.ini"
    
    float4 PS_StoreColor(float4 pos : SV_Position, float2 texcoord : TEXCOORD) : SV_Target {
        return tex2D(ReShade::BackBuffer, texcoord);
    }
    
    float4 PS_RestoreColor(float4 pos : SV_Position, float2 texcoord : TEXCOORD) : SV_Target {
        float ui = tex2D(UIDetect, float2(0, 0)).x;
        float4 colorOrig = tex2D(ColorOrig, texcoord);
        float4 color = tex2D(ReShade::BackBuffer, texcoord);
        color = ui == 0 ? color : colorOrig;
        return color;
    }
    
    technique UIDetect < ui_tooltip = "UIDetect can be used to automatically toggle effects depending on the\n" "visibility of UI elements. It is configured by editing the defines at the top of this file.\n";
    {
        pass {
            VertexShader = PostProcessVS;
            PixelShader = PS_UIDetect;
            RenderTarget = texUIDetect;
            ClearRenderTargets = true;
        }
    }
    
    technique UIDetect_Before {
        pass {
            VertexShader = PostProcessVS;
            PixelShader = PS_StoreColor;
            RenderTarget = texColorOrig;
            ClearRenderTargets = true;
        }
    }
    
    technique UIDetect_After {
        pass {
            VertexShader = PostProcessVS;
            PixelShader = PS_RestoreColor;
            ClearRenderTargets = true;
        }
    }
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.