Alpha OpenGL

SPH · Message par **SPH** » dim. 11/déc./2022 13:22

Salut,

quand on superpose plusieurs triangles les uns sur les autres et que ces triangles sont blancs et presque transparents, les couleurs s'éclaircissent.
Quand la couleur est devenue blanche (RGB(255,255,255)) et que l'on rajoute un triangle, elle reste blanche.
Et bien, je voudrais que la couleur redémarre au noire.
Comment faire ?

Je suis sûr que ça se passe au tréfond de Windows mais il y a bien un fichier qui indique comment doit se passer le chevauchement de couleurs !

Merci pour vos lumières

Ar-S · Message par **Ar-S** » dim. 11/déc./2022 18:25

Si tu sais que ton Nieme triangle finit en 255.255.255, supprime tes triagles à ce moment non ou passe ta couleur à 0.0.0?
Si je suis à coté de la plaque mets du code parce qu'en l'état ^^.

G-Rom · Message par **G-Rom** » dim. 11/déc./2022 19:45

modulo ?

Code : Tout sélectionner

nb_triangle = 2456


For i = 0 To nb_triangle-1
  
  composante_couleur = i % 256
  
  Debug composante_couleur
  
  
Next

SPH · Message par **SPH** » lun. 12/déc./2022 0:06

Je parlais pour être plus précis d'un enchevètrement de polygons plus ou moins transparent.
Oui, c'est vrai, je peux balayer l'écran après chaque polygons pour changer point par point les pixels blancs.

Mais je me dis qu'il y a bien un fichier propre à l'OpenGL qui ne fait pas ce que je voudrais qu'il fasse.
Une idée sur ce fichier ?

kernadec · Message par **kernadec** » lun. 12/déc./2022 9:26

bjr SPH
Sans code pas facile de comprendre ce problème

tu nous parle de triangle blanc presque transparent, et tu parle d'une couleur sans alpha RGB(255,255,255)
peut être une erreur dans le code entre : glColor3d(0,0,0) avec glColor4d(0,0,0,0)

Ps: Voir aussi les lien suivant:
http://www.opengl-tutorial.org/fr/inter ... nsparency/
https://opengl.developpez.com/tutoriels ... s-blending

Cordialement

G-Rom · Message par **G-Rom** » lun. 12/déc./2022 15:11

SPH a écrit : lun. 12/déc./2022 0:06 Je parlais pour être plus précis d'un enchevètrement de polygons plus ou moins transparent.
Oui, c'est vrai, je peux balayer l'écran après chaque polygons pour changer point par point les pixels blancs.

Mais je me dis qu'il y a bien un fichier propre à l'OpenGL qui ne fait pas ce que je voudrais qu'il fasse.
Une idée sur ce fichier ?

un fichier opengl ? ca ne veut rien dire.
la couleur , c'est bien toi qui la choisi ? applique un modulo et basta. y a pas de filtre ou de blending qui fait ce que tu veut faire.

Ollivier · Message par **Ollivier** » jeu. 15/déc./2022 10:25

Salut sph et salut à tous,

ça ne serait pas les options de mélange (blend) qui t'intéresserait ?
Un peu comme SpriteBlendingMode() ?

G-Rom · Message par **G-Rom** » jeu. 15/déc./2022 19:11

Ollivier a écrit : jeu. 15/déc./2022 10:25 Salut sph et salut à tous,

ça ne serait pas les options de mélange (blend) qui t'intéresserait ?
Un peu comme SpriteBlendingMode() ?

G-Rom a écrit : lun. 12/déc./2022 15:11 y a pas de filtre ou de blending qui fait ce que tu veut faire.

Ollivier · Message par **Ollivier** » jeu. 15/déc./2022 20:36

G-Rom a écrit :y a pas de filtre ou de blending qui fait ce que tu veut faire.

Je ne l'avais pas vu, la petite phrase cachée.

Donc, si c'est progressif, normalement, effe tivement, il n'y a pas de filtre.

Mais, il y a quand même une palanquée de combinaisons de filtres. Tellement que même le cerveau dopé, on ne peut tous les imaginer de tête. À deux reprises, j'ai dû dessiner une espèce de rotonde avec divers motifs dans un petit sprite, et faire une table de 9 * 9 mélanges de 2 sprites pour tous les observer.

Il y en a qui se ressemblent beaucoup donc ça n'est pas 81 mélanges distincts, mais il y a quand même beaucoup de mélanges différents.

Il y a aussi un "bug" (?) dans le sens où l'écran a un alpha fantôme. (Sprite sur Ecran) <> (Sprite sur Sprite)

[colorE][alphaE] (pixel de l'écran)
vvvvvvvvvvvvv
[colorS][alphaS] (pixel du sprite)
vvvvvvvvvvvvv
[colorF][alphaF] (pixel Final affiché)

; possible équivalent des mélanges (DisplayTransparentSprute)
; 4 entrées x, y, boolX et boolY
; x y de 0 à 3
; boolX et boolY soit 0 soit -1
value(0) = colorE
value(1) = alphaE
value(2) = colorS
value(3) = alphaS
alphaF = -1 ; ça c'est << si jdis pas d'connerie >>
colorF = (value(x) ! boolX) | (value(y) ! boolY) ; fonction OU(*)

La fonction OU rend impossible (car a|b = b|a donc pas de priorité d'un pixel sur l'autre) d'imposer une couleur en un seul temps (un seul Display). Mais avec plusieurs DisplayTransparentSprite() chacun réglé avec un type.de mélange, dans certain cas, on peut "eraser" puis réafficher.

Les conditions :
1) pas de persistance donc ClearBuffer obligatoire
2) je sais pas. Je vais pioncer.

À + les amis !

(PS : j'ai donné un exemple en Automne 2015 pour imiter le mode texte des anciennes cartes video, c'est en deux passes. Ça efface pile les pixels d'une lettre à afficher, et puis ça remplace par une couleur au choix. Donc ça fait une lettre d'une cpuleur au choix. Mais je ne souhaitais pas dessiner des lettres dans des couleurs graduées, pourtant il suffisait de dessiner une texture de couleur plus complexe qu'un simple pixel pour y parvenir)

(*) : la fonction OU est un modèle un peu "pété", mais ça représente l'addition d'une fonction de mélange :
valeurA * coef + valeurB * (1-coef)

@sph

si tu peux donner des précisions imagées de ce que tu veux, ça pourrait grandement aider.

Edit : je viens de retrouver le code (c'est 2017 celui en openGL, pas 2015).

Je fais une 1ère passe avec :

WorkBlend(#GL_SRC_ALPHA, #GL_DST_COLOR)

Et une seconde passe avec

WorkBlend(#GL_DST_ALPHA, #GL_ONE_MINUS_DST_ALPHA)

Ce sont deux textures différentes : l'une a le négatif de la lettre, et l'autre est une simple couleur dans une texture. Toi, ça n'est pas qu'une simple couleur, mais 2 dégradés.

Fonctions openGL (équivalent du SpriteBlendingMode pour les sprites) :

Code : Tout sélectionner

Procedure WorkBlend(E0.I, E1.I)
        glEnable_(#GL_BLEND)
        glBlendFunc_(E0, E1)        
EndProcedure

Code intégral :

Code : Tout sélectionner

 

Define FullName.S

FullName = OpenFileRequester("Open", "", "", 0)


Structure Tex
        ID.I
        Image.I
        Width.I
        Height.I
        *DrawBuffer
EndStructure

Procedure WorkGadget(Gadget.I, X.I, Y.I, W.I, H.I)
        Define Result.I
        Result = OpenGLGadget(Gadget, X, Y, W, H, #PB_OpenGL_Keyboard)
        If Result
                If Gadget = #PB_Any
                        Gadget = Result
                EndIf
                SetGadgetAttribute(Gadget, #PB_OpenGL_SetContext, #True)
                glViewport_(0, 0, W, H)
                glMatrixMode_(#GL_PROJECTION)
                glLoadIdentity_()
                glOrtho_(0, W, H, 0, 0, 1)
                ProcedureReturn Gadget
        Else
                ProcedureReturn 0
        EndIf
EndProcedure

Procedure WorkClear(Gadget.I, R.F, G.F, B.F, A.F)
        SetGadgetAttribute(Gadget, #PB_OpenGL_SetContext, #True)
        glClear_(#GL_COLOR_BUFFER_BIT)
        glClearColor_(R, G, B, A)
EndProcedure

Procedure WorkBlend(E0.I, E1.I)
        glEnable_(#GL_BLEND)
        glBlendFunc_(E0, E1)        
EndProcedure

Procedure TexCreate(Width.I, Height.I)
        *This.Tex = AllocateMemory(SizeOf(Tex) )
        *This\Width = Width
        *This\Height = Height
        *This\Image = CreateImage(#PB_Any, *This\Width, *This\Height, 32)
        If StartDrawing(ImageOutput(*This\Image) )
                *This\DrawBuffer = DrawingBuffer()
                StopDrawing()
                ProcedureReturn *This
        EndIf
EndProcedure

Procedure TexMake(*This.Tex)
        glGenTextures_(1, @*This\ID)
        glBindTexture_(#GL_TEXTURE_2D, *This\ID)
        glTexParameteri_(#GL_TEXTURE_2D, #GL_TEXTURE_MIN_FILTER, #GL_LINEAR)
        glTexParameteri_(#GL_TEXTURE_2D, #GL_TEXTURE_MAG_FILTER, #GL_LINEAR)
        glTexImage2D_(#GL_TEXTURE_2D, 0, 4, *This\Width, *This\Height, 0, #GL_BGRA_EXT, #GL_UNSIGNED_BYTE, *This\DrawBuffer)
EndProcedure

Procedure TexDisplay(*This.Tex, X.F, Y.F, Wc.F = 1.0, Hc.F = 1.0)
        glClear_(#GL_DEPTH_BUFFER_BIT)
        glEnable_(#GL_TEXTURE_2D)
        glBindTexture_(#GL_TEXTURE_2D, *This\ID)
        glBegin_(#GL_QUADS)
        glTexCoord2f_(0.0, 1.0) ; ToLe
        glVertex2f_(X, Y)
        glTexCoord2f_(0.0, 0.0) ; BoLe
        glVertex2f_(X, Y + *This\Height * Hc)
        glTexCoord2f_(1.0, 0.0) ; BoRi
        glVertex2f_(X + *This\Width * Wc, Y + *This\Height * Hc)
        glTexCoord2f_(1.0, 1.0) ; ToRi
        glVertex2f_(X + *This\Width * Wc, Y)                
        glEnd_()
EndProcedure

Procedure MaskDisplay(*This.Tex, X.F, Y.F, W.F, H.F, R.F, G.F, B.F)
        glColor4f_(R, G, B, 1.0)
        glTexCoord2f_(0.0, 1.0) ; ToLe
        glVertex2f_(X, Y)
        glTexCoord2f_(0.0, 0.0) ; BoLe
        glVertex2f_(X, Y + H)
        glTexCoord2f_(1.0, 0.0) ; BoRi
        glVertex2f_(X + W, Y + H)
        glTexCoord2f_(1.0, 1.0) ; ToRi
        glVertex2f_(X + W, Y)                
EndProcedure

Global Dim LA.S(31) ; (L)ast (A)scii
Global Dim LR.F(31)
Global Dim LG.F(31)
Global Dim LB.F(31)

Procedure LaSet(n, Name.S, r.F, g.F, b.F)
        LA(n) = Name
        LR(n) = r
        LG(n) = g
        LB(n) = b
EndProcedure

Procedure MarkDisplay(*This.Tex, String.S, X.F, Y.F, Wc.F = 1.0, Hc.F = 1.0)
        
        LaSet(0, "PROCEDURE", 0.0, 0.5, 0.0)
        LaSet(1, "ENDPROCEDURE", 0.0, 0.5, 0.0)
        LaSet(2, "WITH", 0.5, 0.5, 0.0)
        LaSet(3, "ENDWITH", 0.5, 0.5, 0.0)
        LaSet(4, "IF", 0.0, 0.0, 0.5)
        LaSet(5, "ENDIF", 0.0, 0.0, 0.5)
        LaSet(6, "FOR", 0.0, 0.5, 0.5)
        LaSet(7, "NEXT", 0.0, 0.5, 0.5)
        LaSet(8, "TO", 0.0, 0.5, 0.5)
        LaSet(9, "GLOBAL", 0.0, 0.5, 0.0)
        LaSet(10, "STRUCTURE", 0.0, 0.3, 0.0)
        LaSet(11, "ENDSTRUCTURE", 0.0, 0.3, 0.0)
        LaSet(12, "DEFINE", 0.0, 0.5, 0.0)
        LaSet(13, "REPEAT", 0.0, 0.5, 0.0)
        LaSet(14, "UNTIL", 0.0, 0.5, 0.0)
        LaSet(15, "ELSE", 0.0, 0.0, 0.5)
        
        Define.I A, I, LString
        Define.F xA, yA, xB, yB
        Define.S Expr
        LString = Len(String)
        For I = 1 To Len(String) + 1
                A = Asc(Mid(String, I, 1) )
                If A = Asc(";")
                        MaskDisplay(*This.Tex, I * 10 * Wc, Y, (LString - I) * 10 * Wc, 20 * Hc, 0.6, 0.25, 0.25)
                        Break
                EndIf
                If A = 34
                        I1 = I + 1
                        I2 = FindString(String, Chr(34), I1)
                        MaskDisplay(*This.Tex, (I1 - 1) * 10 * Wc, Y, ((I2 - I1) ) * 10 * Wc, 20 * Hc, 1.0, 0.2, 0.1)
                        Delta = ((I2 - I1) + 1)
                        I + Delta
                        X + (Delta * (10.0 * Wc) )
                EndIf
                If (A > 96) And (A < 123)
                        A - 32
                EndIf
                If (((A > 64) And (A < 91) ) Or ((A > 47) And (A < 58) ) ) Or (A = Asc("_") )
                        If Start = 0
                                Start = I
                        EndIf
                        Expr + Chr(A)
                Else
                        For J = 0 To 15
                                LLA = Len(LA(J) )
                                If Right(Expr, LLA) = LA(J)
                                        MaskDisplay(*This.Tex, ((Start - 1) * 10 * Wc), Y, (LLA * 10 * Wc), (20 * Hc), LR(J), LG(J), LB(J) )
                                EndIf
                        Next 
                        Start = 0
                        Expr = ""
                EndIf
                X + (10.0 * Wc)
        Next
        MaskDisplay(*This, X, Y, W, H, R, G, B)
EndProcedure

Procedure JustDisplay(*This.Tex, X.F, Y.F, W.F, H.F)
        glTexCoord2f_(0.0, 1.0) ; ToLe
        glVertex2f_(X, Y)
        glTexCoord2f_(0.0, 0.0) ; BoLe
        glVertex2f_(X, Y + H)
        glTexCoord2f_(1.0, 0.0) ; BoRi
        glVertex2f_(X + W, Y + H)
        glTexCoord2f_(1.0, 1.0) ; ToRi
        glVertex2f_(X + W, Y)                
EndProcedure

Procedure CharBegin(*This.Tex)
        glClear_(#GL_DEPTH_BUFFER_BIT)
        glEnable_(#GL_TEXTURE_2D)
        glBindTexture_(#GL_TEXTURE_2D, *This\ID)
        glBegin_(#GL_QUADS)
EndProcedure

Structure WorkFont
        x0.F
        y0.F
        x1.F
        y1.F
EndStructure

Procedure CharDisplay(A.I, X.F, Y.F, Array Char.WorkFont(1), Wc.F = 1.0, Hc.F = 1.0)
        Define.F xA, yA, xB, yB
        xA = Char(A)\x0
        yA = Char(A)\y0
        xB = Char(A)\x1
        yB = Char(A)\y1
        glTexCoord2f_(xA, yB) ; ToLe
        glVertex2f_(X, Y)
        glTexCoord2f_(xA, yA) ; BoLe
        glVertex2f_(X, Y + 20 * Hc)
        glTexCoord2f_(xB, yA) ; BoRi
        glVertex2f_(X + 10 * Wc, Y + 20 * Hc)
        glTexCoord2f_(xB, yB) ; ToRi
        glVertex2f_(X + 10 * Wc, Y)                
EndProcedure

Procedure StringDisplay(String.S, X.F, Y.F, Array Char.WorkFont(1), Wc.F = 1.0, Hc.F = 1.0)
        Define.I A, I, LString
        Define.F xA, yA, xB, yB
        LString = Len(String)
        For I = 1 To Len(String)
                A = Asc(Mid(String, I, 1) )
                xA = Char(A)\x0
                yA = Char(A)\y0
                xB = Char(A)\x1
                yB = Char(A)\y1
                glTexCoord2f_(xA, yB) ; ToLe
                glVertex2f_(X, Y)
                glTexCoord2f_(xA, yA) ; BoLe
                glVertex2f_(X, Y + 20 * Hc)
                glTexCoord2f_(xB, yA) ; BoRi
                glVertex2f_(X + 10 * Wc, Y + 20 * Hc)
                glTexCoord2f_(xB, yB) ; ToRi
                glVertex2f_(X + 10 * Wc, Y)                
                X + (10.0 * Wc)
        Next
EndProcedure

Procedure TexDraw(Array *Tex.Tex(1), I.I, W.I, H.I, *DrawProc)
        *Tex(I) = TexCreate(W, H)
        If StartDrawing(ImageOutput(*Tex(I)\Image) )
                DrawingMode(#PB_2DDrawing_AllChannels)
                CallFunctionFast(*DrawProc, W, H)
                StopDrawing()
        EndIf
EndProcedure

Procedure StdFont(W.I, H.I, Array Char.WorkFont(1), *Tex.Tex)
        Define.F xA, yA, xB, yB
        Define C.I = RGBA(0, 0, 0, 0)
        If StartDrawing(ImageOutput(*Tex\Image) )
                DrawingMode(#PB_2DDrawing_AllChannels)
                Box(0, 0, W, H, C)
                DrawingFont(FontID(1) )
                For Y = 0 To 11
                        For X = 0 To 15
                                I = Y * 16 + X + 32
                                If I > 127
                                        I + 32
                                EndIf
                                xA = X * 10
                                yA = Y * 20
                                DrawText(xA, yA, Chr(I), RGBA(255, 255, 255, 255), C)
                                yA = (H - 20) - yA
                                xB = xA + 10
                                yB = yA + 20
                                xA / W
                                yA / H
                                xB / W
                                yB / H
                                Char(I)\x0 = xA
                                Char(I)\y0 = yA
                                Char(I)\x1 = xB
                                Char(I)\y1 = yB                        
                        Next
                Next
                StopDrawing()
        EndIf
EndProcedure

Procedure BlankDraw(W.I, H.I)
        Box(0, 0, W, H, RGBA(255, 255, 255, 255) )
EndProcedure

Procedure LineCursorDraw(W.I, H.I)
        Box(0, 0, W, H, RGBA(255, 255, 255, 255) )
        Box(0, 1, W, 2, RGBA(191, 191, 191, 63) )
        Box(0, H - 2, W, 2, RGBA(191, 191, 191, 63) )
        Box(0, 0, W, 1, RGBA(0, 0, 0, 255) )
        Box(0, H - 1, W, 1, RGBA(0, 0, 0, 255) )
EndProcedure

Global FileFormat

Procedure.I FileLoad(Name.S)
        File = ReadFile(#PB_Any, Name)
        FileFormat = ReadStringFormat(File)
        If File
                Size = Lof(File)
                *T = AllocateMemory(Size)
                Reading = ReadData(File, *T, Size)
                CloseFile(File)
        EndIf
        If Reading
                ProcedureReturn *T
        Else
                ProcedureReturn 0
        EndIf
EndProcedure

Procedure TextLoad(Name.S, Array TextLine.S(1) )
        Define *Text = FileLoad(Name)
        Define Text.S = PeekS(*Text, MemorySize(*Text), FileFormat)
        FreeMemory(*Text)
        Define I, LinesCount = CountString(Text, Chr(13) )
        Dim TextLine.S(LinesCount)
        For I = 1 To LinesCount
                TextLine(I) = RemoveString(StringField(Text, I, Chr(13) ), Chr(10) )
        Next
        ProcedureReturn LinesCount
EndProcedure

Dim *Tex.Tex(2)
Dim Char.WorkFont(255)
Define Zoom.F = 1.0

Define LinesCount
Dim TextLine.S(1)

LinesCount = TextLoad(FullName, TextLine() )

LoadFont(1, "courier new", 13, #PB_Font_Bold)
*Tex(0) = TexCreate(160, 240)
StdFont(160, 240, Char(), *Tex(0) )

TexDraw(*Tex(), 1, 10, 20, @LineCursorDraw() )
TexDraw(*Tex(), 2, 1, 1, @BlankDraw() )

Change = 2
If OpenWindow(0, 0, 0, 1024, 768, "Retina", #PB_Window_SystemMenu | #PB_Window_ScreenCentered | #PB_Window_SizeGadget | #PB_Window_MinimizeGadget | #PB_Window_MaximizeGadget)
        W = WindowWidth(0)
        H = WindowHeight(0)
        WorkGadget(0, 0, 0, W, H)
        TexMake(*Tex(0) )
        TexMake(*Tex(1) )
        TexMake(*Tex(2) )
        SetActiveGadget(0)
        AddWindowTimer(0, 1, 16)
        Repeat
                Event = WaitWindowEvent()
                If Event = #PB_Event_Timer
                EndIf
                EventType = EventType()               
                If EventType = #PB_EventType_KeyDown
                        Key = GetGadgetAttribute(0, #PB_OpenGL_Key)
                        KeyM = GetGadgetAttribute(0, #PB_OpenGL_Modifiers)
                        If KeyM = #PB_OpenGL_Control
                                ControlKey = 1
                        EndIf
                        If Key = #PB_Shortcut_Up
                                If CursorY > 0
                                        CursorY - 20
                                        Change + 1
                                Else
                                        TextOffsetH - 1
                                        Change + 1
                                EndIf
                        EndIf
                        If Key = #PB_Shortcut_Down
                                If CursorY <= (H / Zoom) - 40
                                        CursorY + 20
                                        Change + 1
                                Else
                                        TextOffsetH + 1
                                        Change + 1
                                EndIf
                        EndIf
                        If Key = #PB_Shortcut_Left
                                If CursorX > 0
                                        CursorX - 10
                                        Change + 1
                                EndIf
                        EndIf
                        If Key = #PB_Shortcut_Right
                                If CursorX <= (W / Zoom) - 20
                                        CursorX + 10
                                        Change + 1
                                EndIf
                        EndIf
                EndIf
                If EventType = #PB_EventType_MouseWheel
                        If ControlKey
                                Zoom + (GetGadgetAttribute(0, #PB_OpenGL_WheelDelta) / 10.0)
                                ControlKey = 0
                                Change + 1
                        Else
                                TextOffsetH - (3 * GetGadgetAttribute(0, #PB_OpenGL_WheelDelta) )
                                Change + 1
                        EndIf
                EndIf
                If EventType = #PB_EventType_MouseMove
                        Sx = GetGadgetAttribute(0, #PB_OpenGL_MouseX)
                        Sy = GetGadgetAttribute(0, #PB_OpenGL_MouseY)
                EndIf
                
                If Event = #PB_Event_SizeWindow
                        ResizeGadget(0, 0, 0, WindowWidth(0), WindowHeight(0) )
                EndIf
                If Event = #PB_Event_Repaint
                        Change + 2
                EndIf
                If Change
                        WorkClear(0, 1.0, 1.0, 1.0, 0.0)
                        
                        WorkBlend(#GL_SRC_ALPHA, #GL_DST_COLOR) ; Ok srca;dstc
                        CharBegin(*Tex(0) )
                        LineHMax = ((H / 20) / Zoom) - 1
                        If LineHMax > LinesCount
                                LineHMax = LinesCount
                        EndIf
                        If TextOffsetH < 0
                                TextOffsetH = 0
                        EndIf
                        If TextOffsetH + LineHMax => LinesCount
                                TextOffsetH = LinesCount - LineHMax - 1
                        EndIf
                        For LineH = 0 To LineHMax
                                x.F = 0.0 * Zoom
                                y.F = LineH * 20.0 * Zoom
                                StringDisplay(TextLine(LineH + 1 + TextOffsetH), x, y, Char(), Zoom, Zoom)
                        Next
                        glEnd_()
                        
                        WorkBlend(#GL_DST_ALPHA, #GL_ONE_MINUS_DST_ALPHA) ; Ok dsta;NegDstA
                        CharBegin(*Tex(2) )
                        MaskDisplay(*Tex(2), 0.0, 0.0, W, H, 0.0, 0.0, 0.0)
                        For LineH = 0 To LineHMax
                                x.F = 0.0 * Zoom
                                y.F = LineH * 20.0 * Zoom
                                MarkDisplay(*Tex(2), TextLine(LineH + 1 + TextOffsetH), X, Y, Zoom, Zoom)
                        Next
                        glEnd_()
                        
                        glColor4f_(1.0, 1.0, 1.0, 0.0)
                        WorkBlend(#GL_SRC_ALPHA, #GL_SRC_COLOR)
                        CharBegin(*Tex(1) )
                        JustDisplay(*Tex(1), 0.0 * Zoom, CursorY * Zoom, W, 20.0 * Zoom)
                        glEnd_()
                        
                        WorkBlend(#GL_ONE_MINUS_DST_COLOR, #GL_ONE_MINUS_DST_COLOR)
                        CharBegin(*Tex(2) )
                        JustDisplay(*Tex(2), CursorX * Zoom, CursorY * Zoom, 2.0 * Zoom, 20.0 * Zoom)
                        glEnd_()
                        
                        glColor4f_(0.0, 0.0, 0.0, 1.0)
                        
                        SetGadgetAttribute(0, #PB_OpenGL_FlipBuffers, #True)
                        Change - 1
                EndIf
        Until Event = #PB_Event_CloseWindow
EndIf

SPH · Message par **SPH** » ven. 16/déc./2022 1:21

Promis, demain, je posterais.

Merci en tout cas

SPH · Message par **SPH** » sam. 17/déc./2022 12:46

Code : Tout sélectionner

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;           Essai de ShadeBob          ;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Code : SPH  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; PB6.0 (2022) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;EnableExplicit

;-CONSTANTS
Enumeration
  #MainWindow
  #OpenGLGadget
EndEnumeration



;These two GL constants are used for texture creation. Don't change their values.
#GL_BGR = $80E0
#GL_BGRA = $80E1

If ExamineDesktops()
  ddw=DesktopWidth(0)
  ddh=DesktopHeight(0)
Else
  ddw=1024
  ddh=768
EndIf


;********************* DPI *********************
dpix.f=DesktopResolutionX()
dpiy.f=DesktopResolutionY()

If dpix > 1
  xf.f=(1920/ddw)*dpix
Else
  xf = 1
EndIf

If dpiy > 1
  yf.f=(1024/ddh)*dpiy
Else
  yf = 1
EndIf

;**********************************************

;-STRUCTURES
Structure Integer2
  X.i
  Y.i
EndStructure
Global.Integer2 WindowDim
WindowDim\X = ddw
WindowDim\Y = ddh


;-DEFINES
Define.i Event
Define.i WindowFlags = #PB_Window_ScreenCentered | #PB_Window_MinimizeGadget


;-DECLARES
Declare Render()
Declare Render2DQuad(OGLTexture.i, StartX.d, StartY.d, Width.i, Height.i, Z.d)
Declare SetupOpenGL()
Declare SetupGLTexture(ImageHandle.i)


;-MAIN WINDOW
win=OpenWindow(#MainWindow, 0, 0,ddw,ddh, "Picasso_SPH",#PB_Window_Maximize|#PB_Window_BorderLess)
If win=0
  Beep_(500,250) : Delay(150) : Beep_(500,250)
  MessageRequester("Erreur","OpenWindow() impossible")
  End
EndIf

screenGL=OpenGLGadget(#OpenGLGadget,0,0,ddw,ddh)
If screenGL=0
  Beep_(500,250) : Delay(150) : Beep_(500,250)
  MessageRequester("Erreur","OpenGLGadget() impossible")
  End
EndIf


SetupOpenGL()

AddKeyboardShortcut(0,  #PB_Shortcut_Escape, 666) ; quitter


glOrtho_(0,ddw,ddh,0,-1,1)
glMatrixMode_(#GL_MODELVIEW)
glLoadIdentity_()
glClear_(0)

;*********************************************************************************************************************************

;;;;;;;;;;;
timer=ElapsedMilliseconds()

glClearColor_(0,0,0, 1.0)
ShowCursor_(0)
;-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#################**********************************************
;-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#################**********************************************
;-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#################**********************************************
;-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#################**********************************************
;-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#################**********************************************
Repeat
  
  
  ;glClear_(#GL_COLOR_BUFFER_BIT | #GL_DEPTH_BUFFER_BIT)
  
  
  ;*****
  Repeat
    Event = WindowEvent()
    
    Select Event
      Case #PB_Event_Gadget
        Select EventGadget()
          Case 1
            Resx = GetGadgetAttribute(1, #PB_OpenGL_MouseX)
            Resy = GetGadgetAttribute(1, #PB_OpenGL_MouseY)
            ;;;;;;;         
            Select EventType()
                ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;             
            EndSelect
        EndSelect
      Case #PB_Event_Menu
        Select EventMenu()
          Case 666
            timer=ElapsedMilliseconds()-timer
            ;MessageRequester("Timer", Str(timer)+" ms - "+Str(scene)+" frames",2)
            ;           Debug scene
            ;           Debug timer
            ShowCursor_(1)
            End
        EndSelect
    EndSelect
    
  Until Event = 0
  
  
  ;##############################################
  ;##############################################
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; L I N E S ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
  If nb=0
    
    nb+1
    For i=1 To 200
      glBegin_(#GL_POLYGON);
      
      glBlendFunc_(#GL_SRC_ALPHA,#GL_ONE_MINUS_SRC_ALPHA)
      
      glColor4f_(1,1,1,10/255)
      
      glVertex2f_(Random(ddw),Random(ddh));
      glVertex2f_(Random(ddw),Random(ddh));
      glVertex2f_(Random(ddw),Random(ddh));
                                          ;    glVertex2f_(ddw/2-sph_xx2(i),ddh/2-sph_yy2(i));
                                          ;    glVertex2f_(ddw/2-sph_xx2(i),ddh/2-sph_yy2(i));
      glEnd_()                            ; 
                                          ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                                          ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                                          ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    Next
    SetGadgetAttribute(#OpenGLGadget, #PB_OpenGL_FlipBuffers, #True)
    
  EndIf
  
  
ForEver




Procedure Render()
  
  ;Clearing buffers and resetting clear color to remove old graphics from the last frame.
  glClear_(#GL_COLOR_BUFFER_BIT | #GL_DEPTH_BUFFER_BIT)
  ;  glClearColor_(0.2, 0.2, 0.2, 1.0)
  glClearColor_(0,0,0,1)
  
  ;## DRAWING TEXTURES/IMAGES
  ;First enable the Texture system.
  glEnable_(#GL_TEXTURE_2D)
  
  ;This procedure will create a quad and apply a texture to it.
  ;The Texture variable contains the texture created earlier using SetupGLTexture().
  Render2DQuad(Texture1, 0, 0, ImageWidth(Image1), ImageHeight(Image1), -2)
  ; Render2DQuad(Texture2, 0, 0, ImageWidth(Image2), ImageHeight(Image2), -1)
  
  ;After all the textures have been displayed disable the texture system.
  ;Otherwise it will conflict with the non texture graphics.
  glDisable_(#GL_TEXTURE_2D)
  
EndProcedure

Procedure Render2DQuad(OGLTexture.i, StartX.d, StartY.d, Width.i, Height.i, Z.d)
  
  ;The texture is first bound which tells OpenGL to use this texture for any future rendering.
  glBindTexture_(#GL_TEXTURE_2D, OGLTexture)
  glBegin_(#GL_QUADS)
  glColor4f_   (1,1,1,1)
  glNormal3f_  (0,0,1.0)
  glTexCoord2f_(1.0,1.0)
  glVertex3f_  (StartX+Width,StartY,Z)
  glTexCoord2f_(0.0,1.0)
  glVertex3f_  (StartX,StartY,Z)
  glTexCoord2f_(0.0,0.0)
  glVertex3f_  (StartX,StartY+Height,Z)
  glTexCoord2f_(1.0,0.0)
  glVertex3f_  (StartX+Width,StartY+Height,Z)
  glEnd_()
  
EndProcedure

Procedure SetupOpenGL()
  
  glMatrixMode_(#GL_PROJECTION)
  
  glOrtho_(0.0, WindowDim\X, WindowDim\Y, 0.0, -1000.0, 1000.0)
  
  glMatrixMode_(#GL_MODELVIEW)
  
  ; glEnable_(#GL_DEPTH_TEST)
  
  glEnable_(#GL_BLEND)
  glBlendFunc_(#GL_SRC_ALPHA, #GL_ONE_MINUS_SRC_ALPHA)
  
EndProcedure

Voilà du code.
Je voudrais que chaque chevauchement (ici, le centre de l'écran est concerné) atteignant le blanc maximum (du RGB(255,255,255)) devienne noir au prochain polygone.
Je voudrais modifier le fichier (DLL ?) qui dis que ça doit rester blanc et le changer pour que ça reparte a RGB(0,0,0)

Ollivier · Message par **Ollivier** » sam. 17/déc./2022 22:44

Tu ne peux modifier que ce que OpenGL est programmé pour modifier. Donc, il faut s'en tenir à ses fonctions qui sont, pour certaines, très souples.

Creuse glBlend comme je l'ai fait : affiche 9 * 9 mélanges.
9 mélanges sont obtenus avec les 9 constantes. Et, il me semble que c'est de 0 à 8 leur valeur : à vérifier.

Essaie de faire un code test comme ça :

Code : Tout sélectionner

For y = 0 to 8
   For x = 0 to 8
      glBlend(xDef, yDef)
      displayQuad(x * 50, y * 50)
      glBlend(x, y)
      displayQuad(x* 50 + 5, y * 50 + 5)
   Next
Next

Il me semble bien qu'un des mélanges donne une intersection noire (parties superposée de 2 carrés).

Ollivier · Message par **Ollivier** » lun. 19/déc./2022 21:12

@sph

t'y arrives ?

SPH · Message par **SPH** » mar. 20/déc./2022 7:31

Ollivier a écrit : lun. 19/déc./2022 21:12 @sph

t'y arrives ?

Bin, je n'ai strictement rien compris.

Pour faire plus concret, peux tu reprendre mon code et rajouter ton effet ?

Ollivier · Message par **Ollivier** » mar. 20/déc./2022 8:22

Ben non.

Donc fais une liste de 9 * 9 sprites pour commencer à l'écran. C'est simple et assez rapide à faire.

PureBasic

Alpha OpenGL

Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL

Re: Alpha OpenGL