Motorcillo 3D para Spectrum.

[jepalza]

Eso es exactamente el dibujo

Muchas gracias.

¿Pero entonces, no necesitas que se mueva esa pantalla? Por que entonces, no es 3D, sino Pseudo3D. Pantallas 3D llevadas a 2D, como por ejemplo, podría ser el ATIC-ATAC que es un 3D sin movimiento.

¿O necesitas que se mueva en 3D, como el DOOM? Por que si es así, es donde viene el problema de la velocidad.

[Toniman]

Por favor Jepalza si te ha parecido que yo he dado señales de molestia en algun momento, no es asi, ya que yo creo que en un principio no me estaba explicando bien,.

No importa, ya ves que tampoco me lo he tomado mal, y he seguido ayudando en lo posible.

Menos mal, no hay que problema ninguno.

Mc_Leod, he probado tu programa de basic y lo dibuja bastante rapido para ser basic, pero ASM siempre sera mas rapido.

Me hecho un par de pantallas para mostraros como me gustaria que se viera el juego, pero son solo imagenes de concepto, habra 2 capas, una con los sprites(todas las naves son sprites normales) y otra en la que se pinta el fondo tirando lineas, creando animacion:


Para que no haya color clash, he borrado lo que queda de los sprites hasta el final del caracter, prefiero que sea asi a que se confundan.

Espero que os guste.

[mcleod_ideafix]

Resultados con el mismo dibujo, en C/M. La rutina de pintado de puntos es moderadamente rápida (usa tablas para precalcular la dirección del punto). La de líneas es muy mejorable (es una copia de la de la ROM: no usa tablas, y no aprovecha la dirección del punto recién pintado). De hecho, es posible pintar líneas horizontales casi 8 veces más rápido que lo que se muestra aquí. El cuello de botella para los algoritmos de dibujado de líneas es cuando las líneas no son ni horizontales ni verticales.

Con todo, lo mejor sería escribir desde 0 una rutina de pintado de líneas que pinte directamente en pantalla, y no como ésta que he hecho, que lo que hace es generar coordenadas x,y para que otra rutina de pintado de puntos sea la que pinte, no sé si me explico.

Tarda, como ves, 11 retrazos de pantalla (muy lento). A modo de referencia, la versión en BASIC tarda unos 40 retrazos.

resultado_render_cm_1.png (5.15 KiB) Visto 8182 veces

[jltursan]

Si únicamente se va a dibujar en 3D esa "trinchera", la animación se puede precalcular en forma de 4 frames (por ejemplo) con todos sus vertices y con una buena rutina de pintado de líneas iría volado. En un MSX2 con el comando del VDP para dibujar líneas ya ni te cuento
Las rutinas de sprites se podrían aprovechar de que el fondo se repinta en cada frame para no tener que preservar el fondo; así se podrían introducir mogollón de sprites. Pena de color clash en el caso del Spectrum.

[Toniman]

Resultados con el mismo dibujo, en C/M. La rutina de pintado de puntos es moderadamente rápida (usa tablas para precalcular la dirección del punto). La de líneas es muy mejorable (es una copia de la de la ROM: no usa tablas, y no aprovecha la dirección del punto recién pintado). De hecho, es posible pintar líneas horizontales casi 8 veces más rápido que lo que se muestra aquí. El cuello de botella para los algoritmos de dibujado de líneas es cuando las líneas no son ni horizontales ni verticales.

Con todo, lo mejor sería escribir desde 0 una rutina de pintado de líneas que pinte directamente en pantalla, y no como ésta que he hecho, que lo que hace es generar coordenadas x,y para que otra rutina de pintado de puntos sea la que pinte, no sé si me explico.

Tarda, como ves, 11 retrazos de pantalla (muy lento). A modo de referencia, la versión en BASIC tarda unos 40 retrazos.

resultado_render_cm_1.png

11 retrazos ¿son 11 lineas de las 192?

¿Ves posible lo que he hecho en las capturas?

[mcleod_ideafix]

11 retrazos ¿son 11 lineas de las 192?

Qué va! Significa que tarda 11 pantallas en dibujarse (1 retrazo=20ms, pues tarda poco más de 2 décimas de segundo en dibujarse)

¿Ves posible lo que he hecho en las capturas?

Todo depende de a qué velocidad quieres que se mueva la trinchera, y si además de moverse la altitud puede variar (la perspectiva). Como ser posible, es posible. Que además vaya lo suficientemente rápido como para que resulte vistoso, eso ya es otra cosa.

[jepalza]

Te vamos a liar entre Mcleod_Ideafix y yo, pero en fín, que cada uno te muestra o te guia por un camino.

Yo te voy a dejar aquí un código que hice para mover, girar, y ampliar un simple cubo en Basic, calculando en tiempo real (no precálculos).
Está hecho para FreeBasic, y se gira con el ratón, se mueve con el boton derecho creo que era, y se amplia con la ruleta.
Tengo una versión mas avanzada, que renderiza en tiempo real, pero es mu largo el código para poner aqui.

Te sirve, para que veas como se puede implementar el movimiento 3D en tiempo real, y ver si es posible llevarlo a ASM del Z80.

Código: Seleccionar todo

DefDbl b-z
DefInt a-a

dim shared cuenta
dim shared x,y
dim shared rr,n,d
dim shared bx,by,bz
dim shared totv,c1,c2,ca,xi,yi,sa
dim shared rex,rey,relx,rely
dim shared xf,yf,ymini,ymaxi
dim shared gris,colores
DIM SHARED AX,AY,AX2,AY2,AM,AM2,AB
DIM SHARED INCX,INCY,ZOOM
Dim Shared REDIBUJAR

' NIVEL DE LUZ A EMPLEAR
LUZ = 5

Declare Sub RELLENAR()
Declare Sub PINTAR()
Declare Sub ECUACION()
Declare Sub ROTAR()
Declare Sub ROTX()
Declare Sub ROTY()
Declare Sub ROTZ()
Declare Sub LEESTL(A As String)

     XMAX = 1024
     YMAX = 768
     SCREEN 20 ' 1024x768

' DESPLAZAMIENTO DENTRO DE LA PANTALLA DESDE EL CENTRO
  INCX=0:INCY=0
 
  REDIBUJAR=1 'SI ES 1, REFRESCAMOS IMAGEN
       
        SetMouse XMAX/2, YMAX/2, 1 '0 PARA OCULTAR EL RATON
        'GETMOUSE AX,AY,AM,A
        AX2=AX:AY2=AY:AM2=AM
 
' LAS VARIABLES REX Y REY INDICAN LA RELACION DE ASPECTO EN PANTALLA
' EN FORMATO 4:3 Y LO PODEMOS EMPLEAR PARA HACER ZOOM
     ZOOM = 480
     REX = ZOOM / (3/4)
     REY = ZOOM


RELX = XMAX / REX
RELY = YMAX / REY

' INCR ES EL INCREMENTO POR ROTACION

INCR = 3.141592 / 55

DIM Shared MAX(YMAX)
DIM Shared MIN(YMAX)

' D ES LA DISTANCIA DESDE EL OBSERVADOR A LA PANTALLA
' CUANTO MENOR ES, MAS AXONOMETRICO, MAS DEFORMADO Y ERRORNEO
' CUANTO MAYOR ES (DIGAMOS 10000), MAS ISOMETRICO Y PERFECTO
' VALORES BAJOS, DE MENOR ALTURA QUE LA FIGURA, HACEN QUE SE
' SALGA DE LA PANTALLA, COMO SI ENTRARAMOS EN EL SOLIDO
D = 300 ' LO MINIMO PARA EL CUBO DE 100x100

     ' ILUMINACION: ARRIBA (1), CENTRO (0),    ABAJO (-1)
     ILUY=0 'CENTRO
 
     ' ILUMINACION: IZQUIERDA (-1), CENTRO (0),DERECHA (1)
     ILUX=0 ' CENTRO
     
     ILUX = ILUX * 320
     ILUY = ILUY * -320
     ILUZ = -D ' LA MISMA QUE LA DISTANCIA AL OBSERVADOR


' INICIO
Cls
' PALETA COMO TONOS DE GRIS DENTRO DE LOS PRIMEROS 64 COLORES

FOR N = 0 TO 63
     PALETTE N, N + N * 256 + N * 65536
NEXT N

' PONEMOS EL COLOR 255 COMO BLANCO Y LO SELECCIONAMOS
' COMO COLOR ACTUAL

PALETTE 255, 63 + 63 * 256 + 63 * 65536
COLOR 255

TOTV=8 ' VERTICES DE UN CUBO
TOTL=6*2 ' CARAS DEL CUBO *2 (2 lineas forman cada cara)
DIM Shared V(TOTV-1, 2)
DIM Shared L%(TOTL-1, 4) '4 lados de un cuadrado/rectangulo
'Call LEESTL("1.TXT")


'LEEMOS LOS VERTICES DE UN CUBO (8)
Restore CUBO
For F=0 To TOTV-1
      Read V(F,0),V(F,1),V(F,2)
Next F

For F=0 To TOTL-1
   L%(F,0)=4 ' NUMERO DE LADOS, EN UN CUADRADO 4, formado por dos rectas
   Read L%(F,1),L%(F,2) ' linea uno de la cara
   Read L%(F,3),L%(F,4) ' linea dos de la cara
Next

DIM Shared MED(TOTL - 1, 1)
DIM Shared C(TOTV - 1, 1)

' BUCLE PRINCIPAL

RENDER = 0
FOR N = 0 TO TOTV - 1
     call ECUACION
     C(N, 0) = X
     C(N, 1) = Y
NEXT N

A$ = INKEY$
WHILE A$ <> "S" AND A$ <> "s"

     FOR N = 0 TO TOTL - 1
          LNUM = L%(N, 0)
          FOR F = 1 TO LNUM
          SIGUIE = F + 1
          IF F = LNUM THEN SIGUIE = 1
          XI = C(L%(N, F), 0)+INCX
          YI = C(L%(N, F), 1)+INCY
          XF = C(L%(N, SIGUIE), 0)+INCX
          YF = C(L%(N, SIGUIE), 1)+INCY
          Call PINTAR
          NEXT F
     NEXT N
   
'     END IF
     
NOBX:    A$ = INKEY$
    ' WHILE A$ = ""
    '  A$ = INKEY$
    ' WEND
   
    Wait &H3DA, 8
   
     IF A$=Chr$(27) THEN END
     
     If A$ = "I" OR A$ = "i" THEN
       D=(10000 And D=300)+(300 And D=10000)
       Call ROTX
       GoTo SIBX
     End If 
     
      GETMOUSE AX,AY,AM,AB
      'AX=AX/10:AY=AY/10 ' REDUCE LA SENSIBILIDAD AL RATON
      'LOCATE 1,1:PRINT AX,AY,AM,AB
      ' TRASLACIONES
      IF AB>0 THEN
           If AX>AX2 THEN AX2=AX: INCX=INCX+10:Call ROTX:GOTO SIBX
           If AX<AX2 THEN AX2=AX: INCX=INCX-10:Call ROTX:GOTO SIBX
           If AY>AY2 THEN AY2=AY: INCY=INCY+10:Call ROTY:GOTO SIBX
           IF AY<AY2 THEN AY2=AY: INCY=INCY-10:Call ROTY:GOTO SIBX
      END If
     
     
      ' ZOOMS
      If AM<>AM2 THEN
         If AX+AY<=0 Then GoTo NOBX ' ESTO ES PARA EVITAR EL GOLPE DEL ZOOM AL SALIRSE EL RATON DE LA PANTALLA
           If AM>AM2 Then A$="M"
           If AM<AM2 Then A$="N"
           AM2=AM
      End IF
      If A$ = "M" OR A$ = "m" Then
        ZOOM=ZOOM-50
        REX = ZOOM / (3/4)
        REY = ZOOM
        RELX = XMAX / REX
        RELY = YMAX / REY
        Call ROTX
        GoTo SIBX
      End If
      If A$ = "N" OR A$ = "n" Then
        ZOOM=ZOOM+50
        REX = ZOOM / (3/4)
        REY = ZOOM
        RELX = XMAX / REX
        RELY = YMAX / REY
        Call ROTX
        GoTo SIBX
      End If 
     
     
      ' ROTACIONES
       If AX>AX2 THEN AX2=AX: BY= INCR: Call ROTY: GoTo SIBX
       If AY>AY2 THEN AY2=AY: BX= INCR: Call ROTX: GoTo SIBX
       If AX<AX2 THEN AX2=AX: BY=-INCR: Call ROTY: GoTo SIBX
       If AY<AY2 THEN AY2=AY: BX=-INCR: Call ROTX: GoTo SIBX

     GoTo NOBX
SIBX:

     
WEND
END
   
' CALCULAMOS LAS ROTACIONES PARA CADA UNO DE LOS VERTICES
   
Sub ROTX()
     A$ = ""
     SA = SIN(BX)
     CA = COS(BX)
     FOR N = 0 TO TOTV - 1
     C1 = V(N, 1)
     C2 = V(N, 2)
     Call ROTAR
     V(N, 1) = C1
     V(N, 2) = C2
     Call ECUACION
     C(N, 0) = X
     C(N, 1) = Y
     NEXT N
     BX = 0
End Sub
   
Sub ROTY()
     A$ = ""
     SA = SIN(BY)
     CA = COS(BY)
     FOR N = 0 TO TOTV - 1
     C1 = V(N, 0)
     C2 = V(N, 2)
     Call ROTAR
     V(N, 0) = C1
     V(N, 2) = C2
     Call ECUACION
     C(N, 0) = X
     C(N, 1) = Y
     NEXT N
     BY = 0
End Sub

Sub ROTZ()
     A$ = ""
     SA = SIN(BZ)
     CA = COS(BZ)
     FOR N = 0 TO TOTV - 1
     C1 = V(N, 0)
     C2 = V(N, 1)
     Call ROTAR
     V(N, 0) = C1
     V(N, 1) = C2
     call ECUACION
     C(N, 0) = X
     C(N, 1) = Y
     NEXT N
End Sub



Sub ECUACION()
   ' PROYECCION PARA PASAR DE 3D A 2D
     X = (V(N, 0) * D) / (V(N, 2) + D) + REX / 2
     Y = (V(N, 1) * D) / (V(N, 2) + D) + REY / 2
End Sub



Sub ROTAR()
   ' ROTACION
     dblC1 = C1 * CA - C2 * SA
     C2 = C1 * SA + C2 * CA
     C1 = dblC1
     CLS
End Sub

Sub PINTAR()
   ' DIBUJADO DE LA LINEA CALCULADA (BORDE DE LA FIGURA)
   COLORLINEA=255 ' BLANCO
   LINE (XI * RELX, YI * RELY)-(XF * RELX, YF * RELY), COLORLINEA
End Sub

Sub RELLENAR()
 FOR Y = YMINI TO YMAXI
   X0 = MIN(Y)
   X1 = MAX(Y)
   IF X0 <= X1 Then 
        LINE (X0, Y)-(X1, Y), GRIS
        Line (X0,Y)-(X0+3,Y+3),70,BF ,&b0000000011110000 ' OPCIONALES, PARA RESALTAR LAS ARISTAS
        Line (X1,Y)-(X1-3,Y-3),70,BF ,&b0000000011110000 ' Y LOS TRIANGULOS QUE FORMAN LAS CARAS
   END IF
 NEXT Y
End Sub
 
   
' definicion de un cubo por sus 6 caras planas
' cuadradas de dos lineas rectas cada una   
CUBO:
' vertices anteriores del 0 al 3
Data 0,0,0
Data 100,0,0
Data 0,100,0
Data 100,100,0
' vertices posteriores del 4 al 7
Data 0,0,100
Data 100,0,100
Data 0,100,100
Data 100,100,100

'delantera
Data 0,1
Data 3,2
'trasera
Data 4,5
Data 7,6
'arriba
Data 0,1
Data 5,4
'abajo
Data 2,3
Data 7,6
'izquierda
Data 1,5
Data 7,3
'derecha
Data 0,4
Data 6,2

'ejemplo cara delantera
' 0 +----+ 1  RECTAS 0-1 sentido agujas reloj
'   |    |           3-2
'   |    |           
' 2 +----+ 3     

'ejemplo cara trasera
' 4 +----+ 5  RECTAS 4-5 sentido agujas reloj
'   |    |           7-6
'   |    |           
' 6 +----+ 7     


[mcleod_ideafix]

Tarda, como ves, 11 retrazos de pantalla (muy lento)

Precalculando los signos de los desplazamientos me quito un poco de código del algoritmo de dibujado de líneas, a costa de que ahora cada línea ocupa 6 bytes en lugar de 4. Eso, y algo tan tonto como desplazar la pila de máquina a memoria no contenida, me ha permitido bajar a 9 frames.

Aún así, la rutina sigue siendo muuuuy mejorable.

[Toniman]

11 retrazos ¿son 11 lineas de las 192?

Qué va! Significa que tarda 11 pantallas en dibujarse (1 retrazo=20ms, pues tarda poco más de 2 décimas de segundo en dibujarse)

¿Ves posible lo que he hecho en las capturas?

Todo depende de a qué velocidad quieres que se mueva la trinchera, y si además de moverse la altitud puede variar (la perspectiva). Como ser posible, es posible. Que además vaya lo suficientemente rápido como para que resulte vistoso, eso ya es otra cosa.

Pues la idea es que la trinchera no se cambie de ninguna manera al mover la nave, simplemente es una animacion que va de fondo.

Para mi que los sprites que estan por encima, que vayan a 25 frames por segunto, la capa de wireframe que hay por debajo, que vaya a 2 o 4 frames por segundo, lo que le de, eso si, podria dejarlo en un poco de menos poligonos.

Las animaciones seran normales y con loop, se iran encadenando.

He hablado con Climacus, me ha dicho que mirara la idea del juego, estoy esperando ahora su respuesta.

[Toniman]

Muchas gracias por el codigo fuente Jepalza y Mc_Leod, gracias por la investigacion, lo ideal seria que yo hiciera los frames de las animaciones a mano, como he hecho con el que le he pasado a Mc_Leod. No quiero que el juego calcule nada para los wireframes, solo que pinte los vertices ciegamente, mas facil imposible

La parte de sprites, por si no lo habeis deducido, esta inspirado en la primera parte de Silpheed, no se si lo conoceis en PC, pero la primera version de este juego esta chula, aunque ellos usan poligonos para las naves, no como yo que usare sprites de toda la vida.

Mi idea es usar una imagen de 256x192, 6912k para los sprites, el resto de memoria para el juego. La pantalla para el juego, al ser mas vertical, se podria usar una zona de 224x192, asi que ahi rascamos algo de memoria de pantalla para nosotros.