Besoin d'aide sur un premier "renderer"

[lomn]

Hello je suis nouveau sur ce forum. Ca fait un moment que je suis intrigué par les demos que j'ai pus voir à droite à gauche et du coup j'ai choisi dans tenter le coup, comme mon truc c'est plutôt les maths et le code je suis parti dans l'idée de coder une base pour pouvoir aboutir a une petite démo.
Du coup  j'ai écrit mon code en OCaml en partant d'une bibliothèque ultra basique (la seule qui permette de faire des applications avec un GUI a ma connaissance.)

Jusque là tout va bien j'ai écrit toute la partie matricielle. Pour l'instant je n'ai qu'un rendu wireframe et j'aimerais bien passer a quelque chose de plus sympa. Je sais pas comment implémenter le moteur de rendu proprement, faut il que j'utilise un Zbuffer en enregistrant les valeurs de profondeur pour chaque pixel (si oui je suis a la recherche de doc pour écrire ça) ? Sinon j'ai vu du code plus rapide a process où le type calcul les barycentre de chaque face pour ensuite les tracées dans l'ordre de profondeur (est ce une bonne technique malgré les risques de chevauchement des faces ?).

Voila je sais pas trop comment m'y prendre donc tout conseil est la bienvenu. vu que je connais pas grand chose dans le domaine je suis preneur pour toute sorte de doc.

Merci bien !

[LittleWhite]

Bonjour,

Du coup, vous faites un renderer purement logiciel ? (sans OpenGL ou DirectX) Donc complètement CPU ?
Pourquoi pas et cela se fait. mais ce n'est pas nécessairement ainsi que son faites les démos.
Vous pouvez suivre ce cours : https://www.youtube.com/watch?v=R2jMkg1TpEM&list=PL4A8BA1C3B38CFCA0

faut il que j'utilise un Zbuffer en enregistrant les valeurs de profondeur pour chaque pixel (si oui je suis a la recherche de doc pour écrire ça)

C'est le cas pour la méthode naïve. On a un tampon de la taille de la cible de rendu, pour les valeurs de profondeur.

[lomn]

Oui je fais tout en soft et du coup c'est calculé par le CPU, j'en ai déjà fait les frai niveau puissance de calcul mais pour quelque chose d'assez basique ça devrait le faire sans trop de problème (j'espère).

Du coup merci pour la video je vais aller regarder ça !!

[Graindolium]

extrait avec des api qui gère l'envoi d'un buffer

Code: [Select]

''''''''''''-->BUFFER'''''''''''''

Declare Function LoadImage Lib "user32" Alias "LoadImageA" (ByVal hInst As Long, ByVal lpsz As String, ByVal dwImageType As Long, ByVal dwDesiredWidth As Long, ByVal dwDesiredHeight As Long, ByVal dwFlags As Long) As Long
'Declare Function GetBitmapBits Lib "gdi32" alias "GetBitmapBits" (ByVal hBitmap As Long, ByVal dwCount As Long, lpBits As long) As Long
Declare Function SetBitmapBits Lib "gdi32" alias "SetBitmapBits" (ByVal hBitmap As Long, ByVal dwCount As Long, lpBits As long) As Long
Declare Function DeleteObject Lib "gdi32" alias "DeleteObject" (ByVal hObject As Long) As Long
Declare Function GetObject Lib "gdi32" Alias "GetObjectA" (ByVal hObject As Long, ByVal nCount As Long, lpObject As long) As Long

Type BITMAP
    bmType As Long
    bmWidth As Long
    bmHeight As Long
    bmWidthBytes As Long
    bmPlanes As short
    bmBitsPixel As short
    bmBits As Long
End Type

dim bmpx as BITMAP
dim BPX as single
dim BTX as single' 80*60*BPX
dim hhdc as long
defint poss
Dim Nbbyte(19200) As Byte

SUB Buffer( opt as single )
 DeleteObject(hhdc)
 hhdc = LoadImage( 0,"ARTWORK.bmp", 0, 80, 60,&H10)
 setBitmapBits (hhdc, BTX, varptr(Nbbyte(1)))
 II.handle=hhdc
 'GetBitmapBits (hhdc1, 19200, varptr(Nbbyte(1)))  ' Clear
 MEMSET(VARPTR(Nbbyte(1)), 0, BTX*SIZEOF(Byte))
 MEMSET(VARPTR(mz(1)), 0, BTX*SIZEOF(single))
 'ReDim mz(0) as single                 ' /!\ mauvaise idée, ReDim bouffe la mémoire
 'ReDim mz(1 to 19200) as single        ' vos mieux utiliser MEMSET(,,) pour faire un clear tableau
END SUB
j'avais fait une démo en cpu totalement , en utilisant des envois de buffer bien sûr

vos mieux manipuler une matrice de profondeur ça donne beaucoup de possibilité ...