PureBasic

Forums PureBasic - Français
http://forums.purebasic.com/french/

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

http://forums.purebasic.com/french/viewtopic.php?t=19090

Page 1 sur 1

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

Publié : ven. 08/déc./2023 16:32
par 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)

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

Publié : sam. 09/déc./2023 20:42
par 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

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

Publié : dim. 10/déc./2023 12:31
par 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 :mrgreen:

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

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

Publié : dim. 10/déc./2023 14:22
par SPH
threedslider a écrit : dim. 10/déc./2023 12:31 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 :mrgreen:
Fake cube car pas bien codé. Il manque un tri de faces...
threedslider a écrit : dim. 10/déc./2023 12:31 Et la matière couleur avec le diffuse Lambertien ? Possible ?
Lamber quoi ?

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

Publié : dim. 10/déc./2023 19:39
par threedslider
SPH a écrit : dim. 10/déc./2023 14:22 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 :)

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

Publié : lun. 11/déc./2023 17:57
par SPH
threedslider a écrit : dim. 10/déc./2023 19:39
SPH a écrit : dim. 10/déc./2023 14:22 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à. :o

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

Publié : lun. 18/déc./2023 21:15
par Kwai chang caine
Moi j'y connais quedal, mais je trouve le rendu drôlement chouette 8O
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 8)

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

Publié : mer. 20/déc./2023 14:43
par threedslider
Ce qu'il a fait SPH est très fort oui et en plus sans moteur 8O

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

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 :wink:

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

Publié : mer. 20/déc./2023 15:35
par SPH
threedslider a écrit : mer. 20/déc./2023 14:43 Ce qu'il a fait SPH est très fort oui et en plus sans moteur 8O
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. :wink:
Fuseau horaire sur UTC+01:00
Page 1 sur 1

Développé par phpBB® Forum Software © phpBB Limited

Traduction française officielle © Qiaeru