Teoría de gráficos 3D y código sin OpenGL, DirectX, XNA, y otros

Question

Me preguntaba si había algún tutorial que introdujera la teoría de gráficos 3D mientras mostraba el código relevante, sin usando OpenGL o DirectX o algo así. Estoy muy cómodo con las matemáticas de ingeniería (soy un estudiante de A/V DSP, así que trabajo con muchas matemáticas todo el tiempo).

La mayoría de los tutoriales que veo me muestran los mismos viejos ejemplos de traducción/rotación de matriz, junto con una discusión sobre proyecciones y me muestran usando triángulos similares cómo funcionan las proyecciones o supongo que saben todo sobre 3D o simplemente usan un montón de Primitivas OpenGL. He ordenado un libro (Gráficos interactivos por computadora: un enfoque descendente) sobre el tema, pero me gustaría comenzar ahora mismo.

Realmente me gustaría algo que acaba de funcionar con una superficie SDL o un objeto Java Graphics2D y simplemente usé la matriz matemática para representar todo. Esperaba poder hacer algunas cosas simples, como representar algunas formas simples antes de que llegara el libro. Idealmente, algo que introdujo temas y dio ejemplos codificados sobre cómo funcionaban.

EDIT: todas las respuestas fueron geniales, pero me encantó el código. Exactamente lo que estaba buscando, incluso si estaba en Pascal;)

Answer 1

Buried out old pascal source: D Hace aproximadamente 14 años, lo usaba para mostrar objetos 3d muy simples. xrot, yrot, zrot son para rotar los puntos ([x, y, z] multiplicados por la matriz de rotación). Y usé una transformación de 3d a 2d muy simple, basada en una proyección de punto de fuga con el punto de fuga en el medio de la pantalla. Como ejemplo, hay una matriz de vértices definida. También debe agregar una matriz de trigons.

const depth = 1500; 
     deg = pi/180; 

     { some vertices for a dice :) } 
     vertices:array[0..23] of real= (50, 50, 50,  { 0} 
           -50, 50, 50,  { 1} 
            50,-50, 50,  { 2} 
           -50,-50, 50,  { 3} 
            50, 50,-50,  { 4} 
           -50, 50,-50,  { 5} 
            50,-50,-50,  { 6} 
           -50,-50,-50,  { 7} 
           ); 

{ transform 3d coordinates to pixel coordinates } 
procedure 3d_to_2d(x, y, z : real; var px, py : longint); 
var k:real; 
begin 
k:=((depth shr 1)+z)/depth; 
px:=(getmaxx shr 1)+trunc(x*k);  { getmaxx is the width of the screen } 
py:=(getmaxy shr 1)+trunc(y*k);  { getmaxy is the height of the screen } 
end; 

{ rotate around the x axis by rx degrees } 
procedure xrot(var x,y,z:real;rx:integer); 
var x1,y1,z1:real; 
begin 
y1:=(y * cos(rx * deg))+(z* (sin(rx * deg))); 
z1:=(-y* sin(rx * deg))+(z* (cos(rx * deg))); 
y:=y1; z:=z1; 
end; 

{ rotate around the y axis by ry degrees } 
procedure yrot(var x,y,z:real;ry:integer); 
var x1,y1,z1:real; 
begin 
x1:=(x * cos(ry * deg))+(z*(sin(ry * deg))); 
z1:=(-x * sin(ry * deg))+(z*(cos(ry * deg))); 
x:=x1; z:=z1; 
end; 

{ rotate around the z axis by rz degrees } 
procedure zrot(var x,y,z:real; rz:integer); 
var x1,y1,z1:real; 
begin 
x1:=(x* cos(rz * deg))+(y*(sin(rz * deg))); 
y1:=(-x* sin(rz * deg))+(y*(cos(rz * deg))); 
x:=x1; y:=y1; 
end; 

Para trigons rellenos, que utiliza la función de un amigo, que dibuja la forma usando líneas horizontales (HLINE (x, y, ancho, color)):

TYPE pt=RECORD x,y:LongInt;END; 

PROCEDURE Tri(P:ARRAY OF pt;co:BYTE); 
VAR q,w:INTEGER; 
    S:pt; 
    f12,f13,f23:LongInt; 
    s1,s2:LongInt; 


BEGIN 

    IF p[0].y>p[2].y THEN BEGIN s:=p[0];p[0]:=p[2];p[2]:=s;END; { sort the points } 
    IF p[0].y>p[1].y THEN BEGIN s:=p[0];p[0]:=p[1];p[1]:=s;END; 
    IF p[1].y>p[2].y THEN BEGIN s:=p[1];p[1]:=p[2];p[2]:=s;END; 

    q:=(p[0].y-p[1].y); { y distance between point 0 and 1 } 
    IF q<>0 THEN f12:=LongInt((p[0].x-p[1].x) shl 6) DIV q ELSE f12:=0; 

    q:=(p[0].y-p[2].y); 
    IF q<>0 THEN f13:=LongInt((p[0].x-p[2].x) shl 6) DIV q ELSE f13:=0; 

    q:=(p[1].y-p[2].y); 
    IF q<>0 THEN f23:=LongInt((p[1].x-p[2].x) shl 6) DIV q ELSE f23:=0; 

    s1:=p[0].x shl 6;s2:=s1; 
    FOR q:=p[0].y TO p[1].y DO 
    BEGIN 
    Hline(s1 shr 6,s2 shr 6,q,co); 
    s1:=s1+f12; 
    s2:=s2+f13; 
    END; 
    s1:=p[2].x shl 6;s2:=s1; 
    FOR q:=p[2].y DOWNTO p[1].y DO 
    BEGIN 
    Hline(s1 shr 6,s2 shr 6,q,co); 
    s1:=s1-f23; 
    s2:=s2-f13; 
    END; 
END; 

Answer 2

Una forma de evitar las soluciones OpenGL y DirectX es buscar libros gráficos anteriores que sean anteriores a OpenGL y DirectX, algo de mediados de los 80, por ejemplo (OpenGL puede han existido, pero no tienen un uso generalizado en la PC). Prepárate para traducir desde GWBasic o similar. ;>

O, simplemente tome un libro de texto de trigonometría. La proyección de coords 3D a 2D no es más que trigonometría y a veces se trata como un tema avanzado en trig books.

Answer 3

Esta serie de artículos me ayudó a entender los conceptos básicos de gráficos 3D: Exploring 3D in Flash. Los artículos se encuentran en Actionscript/ECMAScript en un entorno Flash DOM pero se pueden traducir fácilmente a otros entornos.

Personalmente seguí los artículos traduciendo los ejemplos al dibujo Tcl/Tk en un lienzo Tk. Puede probar Perl/Tk o TkInter en su lugar o una traducción mucho más cercana es javascript utilizando canvas HTML5 o algo así como Raphael para hacer el dibujo. Al final del artículo, tendrá una API 3D simple pero utilizable.

Answer 4

Obtener este libro

o al menos prestado de la biblioteca de su universidad más cercana.

---

Está a unos cuantos años de edad ahora, pero era (antes de la revolución de sombreado programable) consideraron la Biblia gráficos. Probablemente pueda omitir muchos de los primeros capítulos sobre métodos de entrada y pantallas paletizadas, pero casi todo lo demás se ha mantenido excepcionalmente bien.