Un cube 3D codé sans l'aide d'un moteur comme Ogre

[SPH]

Code : Tout sélectionner

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Code : SPH et Nemerod (2023) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

InitSprite() 
InitMouse() 
InitKeyboard() 

win=OpenWindow(#PB_Any, 0, 0, 0, 0, "Cube 3D",  #PB_Window_Maximize |  #PB_Window_BorderLess )
scr_w=WindowWidth(win)
scr_h=WindowHeight(win)
OpenWindowedScreen (WindowID(win),0 , 0, scr_w, scr_h,0, 0, 0, #PB_Screen_SmartSynchronization)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Dim imtix.f(7,1)
imtix(0,0) = -1
imtix(1,0) = 01
imtix(2,0) = -1
imtix(3,0) = 01
imtix(4,0) = -1
imtix(5,0) = 01
imtix(6,0) = -1
imtix(7,0) = 01
Dim imtiy.f(7,1)
imtiy(0,0) = -1
imtiy(1,0) = -1
imtiy(2,0) = 01
imtiy(3,0) = 01
imtiy(4,0) = -1
imtiy(5,0) = -1
imtiy(6,0) = 01
imtiy(7,0) = 01
Dim imtiz.f(7)
imtiz(0) = -1
imtiz(1) = -1
imtiz(2) = -1
imtiz(3) = -1
imtiz(4) = 01
imtiz(5) = 01
imtiz(6) = 01
imtiz(7) = 01
Dim g(32,2)
Dim gd(32,2)

a.f=0.0205
b.f=0.0117
c.f=0.0177
zoom=200
dk=500
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
nb_trace=10
trace_la=0
Dim oldx.f(nb_trace,7,1)
Dim oldy.f(nb_trace,7,1)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Repeat
  
  Repeat
  Event = WindowEvent()
  Until Event=0
  ClearScreen(0)
;     If a.f>0.0050:sx=1:ElseIf a.f<-0.0050:sx=0:EndIf:If sx=0:a.f+0.00004:Else:a.f-0.00002:EndIf
;     If b.f>0.0050:sy=1:ElseIf b.f<-0.0050:sy=0:EndIf:If sy=0:b.f+0.00001:Else:b.f-0.00002:EndIf
;     If c.f>0.0050:sz=1:ElseIf c.f<-0.0050:sz=0:EndIf:If sz=0:c.f+0.00003:Else:c.f-0.00004:EndIf

      For i=0 To 7
      x.f=imtix(i,0);point de base X
      y.f=imtiy(i,0);point de base Y
      z.f=imtiz(i); un peu useless mais point Z
      
      xx.f =(Cos(a.f)*x.f )-(Sin(a.f)*y.f ); axe X
      yy.f =(Sin(a.f)*x.f) +(Cos(a.f)*y.f ); profondeur
      
      xxx.f=(Cos(b.f)*xx.f)+(Sin(b.f)*z   ); axe Y
      zz.f =(Cos(b.f)*z.f) -(Sin(b.f)*xx.f); vertical 
      
      yyy.f=(Cos(c.f)*yy.f)-(Sin(c.f)*zz.f); axe Z
      zzz.f=(Sin(c.f)*yy.f)+(Cos(c.f)*zz.f); largeur
      
      imtix(i,1)=((xxx.f*2)/(zzz.f+3)); perpestive
      imtiy(i,1)=((yyy.f*2)/(zzz.f+3)); peu etre ajusté avec le 2 et le 3
      oldx(trace_la,i,1)=imtix(i,1)
      oldy(trace_la,i,1)=imtiy(i,1)

      imtix(i,0)=xxx.f; valeur de base modifier si besoin
      imtiy(i,0)=yyy.f;
      imtiz(i)=zzz.f  ;
      oldx(trace_la,i,0)=xxx
      oldy(trace_la,i,0)=yyy
    Next
    trace_la+1
    trace_la%(nb_trace+1)
    
    StartDrawing(ScreenOutput())
    ;;;;
    nb=trace_la
    For i=0 To nb_trace-1
    LineXY(oldx(nb,0,1)*zoom+dk,oldy(nb,0,1)*zoom+dk,oldx(nb,1,1)*zoom+dk,oldy(nb,1,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))
    LineXY(oldx(nb,1,1)*zoom+dk,oldy(nb,1,1)*zoom+dk,oldx(nb,3,1)*zoom+dk,oldy(nb,3,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))
    LineXY(oldx(nb,3,1)*zoom+dk,oldy(nb,3,1)*zoom+dk,oldx(nb,2,1)*zoom+dk,oldy(nb,2,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))
    LineXY(oldx(nb,2,1)*zoom+dk,oldy(nb,2,1)*zoom+dk,oldx(nb,0,1)*zoom+dk,oldy(nb,0,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))
    LineXY(oldx(nb,4,1)*zoom+dk,oldy(nb,4,1)*zoom+dk,oldx(nb,5,1)*zoom+dk,oldy(nb,5,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))
    LineXY(oldx(nb,5,1)*zoom+dk,oldy(nb,5,1)*zoom+dk,oldx(nb,7,1)*zoom+dk,oldy(nb,7,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))
    LineXY(oldx(nb,7,1)*zoom+dk,oldy(nb,7,1)*zoom+dk,oldx(nb,6,1)*zoom+dk,oldy(nb,6,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))
    LineXY(oldx(nb,6,1)*zoom+dk,oldy(nb,6,1)*zoom+dk,oldx(nb,4,1)*zoom+dk,oldy(nb,4,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))
    LineXY(oldx(nb,0,1)*zoom+dk,oldy(nb,0,1)*zoom+dk,oldx(nb,4,1)*zoom+dk,oldy(nb,4,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))
    LineXY(oldx(nb,1,1)*zoom+dk,oldy(nb,1,1)*zoom+dk,oldx(nb,5,1)*zoom+dk,oldy(nb,5,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))
    LineXY(oldx(nb,2,1)*zoom+dk,oldy(nb,2,1)*zoom+dk,oldx(nb,6,1)*zoom+dk,oldy(nb,6,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))
    LineXY(oldx(nb,3,1)*zoom+dk,oldy(nb,3,1)*zoom+dk,oldx(nb,7,1)*zoom+dk,oldy(nb,7,1)*zoom+dk,RGB(8+i*50/nb_trace,8+i*50/nb_trace,8+i*50/nb_trace))

      nb+1
      nb%(nb_trace+1)
    Next
    LineXY(imtix(0,1)*zoom+dk,imtiy(0,1)*zoom+dk,imtix(1,1)*zoom+dk,imtiy(1,1)*zoom+dk,$0000ff)
    LineXY(imtix(1,1)*zoom+dk,imtiy(1,1)*zoom+dk,imtix(3,1)*zoom+dk,imtiy(3,1)*zoom+dk,$0000ff)
    LineXY(imtix(3,1)*zoom+dk,imtiy(3,1)*zoom+dk,imtix(2,1)*zoom+dk,imtiy(2,1)*zoom+dk,$0000ff)
    LineXY(imtix(2,1)*zoom+dk,imtiy(2,1)*zoom+dk,imtix(0,1)*zoom+dk,imtiy(0,1)*zoom+dk,$0000ff)
    LineXY(imtix(4,1)*zoom+dk,imtiy(4,1)*zoom+dk,imtix(5,1)*zoom+dk,imtiy(5,1)*zoom+dk,$0000ff)
    LineXY(imtix(5,1)*zoom+dk,imtiy(5,1)*zoom+dk,imtix(7,1)*zoom+dk,imtiy(7,1)*zoom+dk,$0000ff)
    LineXY(imtix(7,1)*zoom+dk,imtiy(7,1)*zoom+dk,imtix(6,1)*zoom+dk,imtiy(6,1)*zoom+dk,$0000ff)
    LineXY(imtix(6,1)*zoom+dk,imtiy(6,1)*zoom+dk,imtix(4,1)*zoom+dk,imtiy(4,1)*zoom+dk,$0000ff)
    LineXY(imtix(0,1)*zoom+dk,imtiy(0,1)*zoom+dk,imtix(4,1)*zoom+dk,imtiy(4,1)*zoom+dk,$0000ff)
    LineXY(imtix(1,1)*zoom+dk,imtiy(1,1)*zoom+dk,imtix(5,1)*zoom+dk,imtiy(5,1)*zoom+dk,$0000ff)
    LineXY(imtix(2,1)*zoom+dk,imtiy(2,1)*zoom+dk,imtix(6,1)*zoom+dk,imtiy(6,1)*zoom+dk,$0000ff)
    LineXY(imtix(3,1)*zoom+dk,imtiy(3,1)*zoom+dk,imtix(7,1)*zoom+dk,imtiy(7,1)*zoom+dk,$0000ff)
    ;;;;
    ;;;;
    
    StopDrawing()
    
    Delay(1)
    FlipBuffers()
  
  ExamineKeyboard()
Until KeyboardPushed(#PB_Key_Escape)
; Delay(400)
; Repeat
;   ExamineKeyboard()
; Until KeyboardPushed(#PB_Key_Escape)

[SPH]

Un cube "plein". Il est en alpha 50%
Comme vous pouvez le voir, les faces ne sont pas triées selon leur "profondeur". Donc, on a un cube un peu bancal... Mais j'apprend !

Code : Tout sélectionner

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Code : SPH et Nemerod (2023) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;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

;-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, "SPH_Tableaux_OpenGL",#PB_Window_Maximize|#PB_Window_BorderLess)
If win=0
  MessageRequester("Erreur","OpenWindow() impossible")
  End
EndIf

screenGL=OpenGLGadget(#OpenGLGadget,0,0,ddw,ddh)
If screenGL=0
  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)

;*********************************************************************************************************************************
  
;   mirror=0
;;;;;;;;;;;
;ShowCursor_(0)


  f1.f=0.4
  f2.f=0.31
  f3.f=0.4
  f4.f=0.3
  
  ff1.f=Random(2500)/100000+0.01
  ff2.f=Random(2500)/100000+0.01
  ff3.f=Random(2500)/100000+0.01
  ff4.f=Random(2500)/100000+0.01
  
  xyf1.f=Random(255)/255
  xyf2.f=Random(255)/255
  xyf3.f=Random(255)/255
  xyf4.f=5/255
  
  ddwx2=Random(800)-400
  ddhx2=Random(800)-400
  ddwy2=Random(800)-400
  ddhy2=Random(800)-400
  
  diam1=Random(1000)+50
  diam2=Random(1000)+50
  diam3=Random(1000)+50
  diam4=Random(1000)+50

  timer=ElapsedMilliseconds()


  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Dim imtix.f(7,1)
imtix(0,0) = -1
imtix(1,0) = 01
imtix(2,0) = -1
imtix(3,0) = 01
imtix(4,0) = -1
imtix(5,0) = 01
imtix(6,0) = -1
imtix(7,0) = 01
Dim imtiy.f(7,1)
imtiy(0,0) = -1
imtiy(1,0) = -1
imtiy(2,0) = 01
imtiy(3,0) = 01
imtiy(4,0) = -1
imtiy(5,0) = -1
imtiy(6,0) = 01
imtiy(7,0) = 01
Dim imtiz.f(7)
imtiz(0) = -1
imtiz(1) = -1
imtiz(2) = -1
imtiz(3) = -1
imtiz(4) = 01
imtiz(5) = 01
imtiz(6) = 01
imtiz(7) = 01
Dim g(32,2)
Dim gd(32,2)

a.f=0.0205
b.f=0.0217
c.f=0.0177
zoom=200
dk=500
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; nb_trace=20
; trace_la=0
; Dim oldx.f(nb_trace,7,1)
; Dim oldy.f(nb_trace,7,1)

;;;;;;;-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#################;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;### D E B U T ###;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#################;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Repeat
  
;   If ElapsedMilliseconds()-timer>25000
    
;     cls+1
;     cls%2
      
;   If cls=0
  glClear_(#GL_COLOR_BUFFER_BIT | #GL_DEPTH_BUFFER_BIT)


;   mirror=0;Random(2)
  ;Beep_(1500,100)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  ;*****
  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
            End
        EndSelect
    EndSelect
    
  Until Event = 0
  
  
;##############################################
        For i=0 To 7
      x.f=imtix(i,0);point de base X
      y.f=imtiy(i,0);point de base Y
      z.f=imtiz(i); un peu useless mais point Z
      
      xx.f =(Cos(a.f)*x.f )-(Sin(a.f)*y.f ); axe X
      yy.f =(Sin(a.f)*x.f) +(Cos(a.f)*y.f ); profondeur
      
      xxx.f=(Cos(b.f)*xx.f)+(Sin(b.f)*z   ); axe Y
      zz.f =(Cos(b.f)*z.f) -(Sin(b.f)*xx.f); vertical 
      
      yyy.f=(Cos(c.f)*yy.f)-(Sin(c.f)*zz.f); axe Z
      zzz.f=(Sin(c.f)*yy.f)+(Cos(c.f)*zz.f); largeur
      
      imtix(i,1)=((xxx.f*2)/(zzz.f+3)); perpestive
      imtiy(i,1)=((yyy.f*2)/(zzz.f+3)); peu etre ajusté avec le 2 et le 3

      imtix(i,0)=xxx.f; valeur de base modifier si besoin
      imtiy(i,0)=yyy.f;
      imtiz(i)=zzz.f  ;
    Next
    trace_la+1
    trace_la%(nb_trace+1)
    
    
;il faut faire une procedure de poly a 4 sommets :

    ;;;;
;     dpo(imtix(0,1)*zoom+dkx,imtiy(0,1)*zoom+dky,imtix(1,1)*zoom+dkx,imtiy(1,1)*zoom+dky,imtix(3,1)*zoom+dkx,imtiy(3,1)*zoom+dky,imtix(2,1)*zoom+dkx,imtiy(2,1)*zoom+dky,$0000ff)
    glBegin_(#GL_POLYGON)
    glBlendFunc_(#GL_SRC_ALPHA,#GL_ONE_MINUS_SRC_ALPHA)
    glColor4f_(255,0,0,0.5)
    glVertex2f_(imtix(0,1)*zoom+dk,imtiy(0,1)*zoom+dk);
    glVertex2f_(imtix(1,1)*zoom+dk,imtiy(1,1)*zoom+dk);
    glVertex2f_(imtix(3,1)*zoom+dk,imtiy(3,1)*zoom+dk);
    glVertex2f_(imtix(2,1)*zoom+dk,imtiy(2,1)*zoom+dk);
    glEnd_()                      ; 
    ;;;
;     dpo(imtix(1,1)*zoom+dkx,imtiy(1,1)*zoom+dky,imtix(5,1)*zoom+dkx,imtiy(5,1)*zoom+dky,imtix(7,1)*zoom+dkx,imtiy(7,1)*zoom+dky,imtix(3,1)*zoom+dkx,imtiy(3,1)*zoom+dky,$00ff00)
    glBegin_(#GL_POLYGON)
    glBlendFunc_(#GL_SRC_ALPHA,#GL_ONE_MINUS_SRC_ALPHA)
    glColor4f_(0,255,0,0.5)
    glVertex2f_(imtix(1,1)*zoom+dk,imtiy(1,1)*zoom+dk);
    glVertex2f_(imtix(5,1)*zoom+dk,imtiy(5,1)*zoom+dk);
    glVertex2f_(imtix(7,1)*zoom+dk,imtiy(7,1)*zoom+dk);
    glVertex2f_(imtix(3,1)*zoom+dk,imtiy(3,1)*zoom+dk);
    glEnd_()                      ; 
    ;;;
;     dpo(imtix(5,1)*zoom+dkx,imtiy(5,1)*zoom+dky,imtix(4,1)*zoom+dkx,imtiy(4,1)*zoom+dky,imtix(6,1)*zoom+dkx,imtiy(6,1)*zoom+dky,imtix(7,1)*zoom+dkx,imtiy(7,1)*zoom+dky,$ff0000)
    glBegin_(#GL_POLYGON)
    glBlendFunc_(#GL_SRC_ALPHA,#GL_ONE_MINUS_SRC_ALPHA)
    glColor4f_(0,0,255,0.5)
    glVertex2f_(imtix(5,1)*zoom+dk,imtiy(5,1)*zoom+dk);
    glVertex2f_(imtix(4,1)*zoom+dk,imtiy(4,1)*zoom+dk);
    glVertex2f_(imtix(6,1)*zoom+dk,imtiy(6,1)*zoom+dk);
    glVertex2f_(imtix(7,1)*zoom+dk,imtiy(7,1)*zoom+dk);
    glEnd_()                      ; 
;     dpo(imtix(4,1)*zoom+dkx,imtiy(4,1)*zoom+dky,imtix(0,1)*zoom+dkx,imtiy(0,1)*zoom+dky,imtix(2,1)*zoom+dkx,imtiy(2,1)*zoom+dky,imtix(6,1)*zoom+dkx,imtiy(6,1)*zoom+dky,$00ffff)
    glBegin_(#GL_POLYGON)
    glBlendFunc_(#GL_SRC_ALPHA,#GL_ONE_MINUS_SRC_ALPHA)
    glColor4f_(255,0,255,0.5)
    glVertex2f_(imtix(4,1)*zoom+dk,imtiy(4,1)*zoom+dk);
    glVertex2f_(imtix(0,1)*zoom+dk,imtiy(0,1)*zoom+dk);
    glVertex2f_(imtix(2,1)*zoom+dk,imtiy(2,1)*zoom+dk);
    glVertex2f_(imtix(6,1)*zoom+dk,imtiy(6,1)*zoom+dk);
    glEnd_()                      ; 
;     dpo(imtix(0,1)*zoom+dkx,imtiy(0,1)*zoom+dky,imtix(4,1)*zoom+dkx,imtiy(4,1)*zoom+dky,imtix(5,1)*zoom+dkx,imtiy(5,1)*zoom+dky,imtix(1,1)*zoom+dkx,imtiy(1,1)*zoom+dky,$ffff00)
    glBegin_(#GL_POLYGON)
    glBlendFunc_(#GL_SRC_ALPHA,#GL_ONE_MINUS_SRC_ALPHA)
    glColor4f_(255,255,0,0.5)
    glVertex2f_(imtix(0,1)*zoom+dk,imtiy(0,1)*zoom+dk);
    glVertex2f_(imtix(4,1)*zoom+dk,imtiy(4,1)*zoom+dk);
    glVertex2f_(imtix(5,1)*zoom+dk,imtiy(5,1)*zoom+dk);
    glVertex2f_(imtix(1,1)*zoom+dk,imtiy(1,1)*zoom+dk);
    glEnd_()                      ; 
;     dpo(imtix(2,1)*zoom+dkx,imtiy(2,1)*zoom+dky,imtix(3,1)*zoom+dkx,imtiy(3,1)*zoom+dky,imtix(7,1)*zoom+dkx,imtiy(7,1)*zoom+dky,imtix(6,1)*zoom+dkx,imtiy(6,1)*zoom+dky,$ff00ff)
    glBegin_(#GL_POLYGON)
    glBlendFunc_(#GL_SRC_ALPHA,#GL_ONE_MINUS_SRC_ALPHA)
    glColor4f_(0,255,255,0.5)
    glVertex2f_(imtix(2,1)*zoom+dk,imtiy(2,1)*zoom+dk);
    glVertex2f_(imtix(3,1)*zoom+dk,imtiy(3,1)*zoom+dk);
    glVertex2f_(imtix(7,1)*zoom+dk,imtiy(7,1)*zoom+dk);
    glVertex2f_(imtix(6,1)*zoom+dk,imtiy(6,1)*zoom+dk);
    glEnd_()                      ; 


;##############################################
  
  
  SetGadgetAttribute(#OpenGLGadget, #PB_OpenGL_FlipBuffers, #True)

ForEver

End


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

[threedslider]

Très cool sans moteur 3D !

Mais on peut dire aussi c'est un fake cube 3D, non ? Car je vois tu simules bien mais ça reste fake quand même

Et la matière couleur avec le diffuse Lambertien ? Possible ?

[SPH]

Très cool sans moteur 3D !

Mais on peut dire aussi c'est un fake cube 3D, non ? Car je vois tu simules bien mais ça reste fake quand même

Fake cube car pas bien codé. Il manque un tri de faces...

Et la matière couleur avec le diffuse Lambertien ? Possible ?

Lamber quoi ?

[threedslider]

Lamber quoi ?

Je parle de diffuse shading terme en anglais, https://fr.wikipedia.org/wiki/Source_lu ... orthotrope et https://www.rombo.tools/2021/12/15/lambert-sphere/ pour plus d'information

[SPH]

Lamber quoi ?

Je parle de diffuse shading terme en anglais, https://fr.wikipedia.org/wiki/Source_lu ... orthotrope et https://www.rombo.tools/2021/12/15/lambert-sphere/ pour plus d'information

Merci pour les liens. Je n'en suis pas encore là.

[Kwai chang caine]

Moi j'y connais quedal, mais je trouve le rendu drôlement chouette
Et je trouve ça cool qu'il existe encore des programmeurs qui essaient de coder from scratch dans ce monde ou on se fait parfois emmerder par les librairies utilisées à tout bout de champs, même si parfois c'est pas justifié et qui rendent nos appareils démodés
En tout cas merci du partage

[threedslider]

Ce qu'il a fait SPH est très fort oui et en plus sans moteur

Même moi j'imaginais pas qu'on peut faire cela mais avec Purebasic c'est sans limite hein on est d'accord ?

Tu peux faire plein de chose avec Purebasic des petits trucs sympa sans besoin de faire graphisme, après bien sûr cela dépend ton souhait en fait

[SPH]

Ce qu'il a fait SPH est très fort oui et en plus sans moteur

Le code n'est pas de moi mais de Nemerod. Rendons à César ce qui lui appartient.

@treed...
Un moteur 3D, c'est une routine comme celle là, puis on rajoute des effets à la pelle.