Red de conocimiento informático - Computadora portátil - Código fuente de Arno

Código fuente de Arno

Este programa fue escrito por Brother Vulture en el extranjero y se publicó el código fuente. Esta es una de sus obras de 1995. ¡Realmente lo admiro! Demasiado fuerte. ¡Estudia mucho! ! ! !

;Método de compilación: 1tasm3d.asm.

2 tlink 3d.obj

3 exe 2bin3d.exe 3d.com

Ensamblador de Vulture. ;

;Ejemplo de sistema 3D. Gire el punto usando la siguiente fórmula:

Gire alrededor del eje x

YT = Y * COS(xang)-Z * SIN( xang) /256;

;ZT = Y * SIN(xang)Z * COS(xang)/256;

;Y = YT

;z = ZT ;

;

; Girar alrededor del eje y

;

;ZT = X * SIN(Yang)Z * COS(Yang)/256;

;X = XT

;z = ZT;< / p>

;;

;Rotar alrededor del eje z;

;XT = X * COS(Zang)- Y * SIN(Zang)/256;

YT = X * SIN(Zang)Y * COS(Zang)/256;

X = XT

Y = YT

;

; Dividimos por 256, porque también multiplicamos nuestro valor de pecado por 256. ;

;Este ejemplo no es muy rápido en este momento, pero funcionará bien. ;

;;

;Fecha actual: 9 de junio de 1995 Buitre;

;;

Ideal; Modelo ideal

P386 permite 80386 instrucciones

Saltos; Tasm maneja saltos fuera de rango (¡rulez!:))

El segmento de código comienza

Asuma cs: code, ds: code; deje que cs y ds apunten al segmento de código

ORG 100h; Cree un archivo .COM

Inicio:;

mov ax, 0013h; inicializar vga

int 10h

Mover ax, cs

mov ds, ax ds apunta al segmento de código

p>

mov ax, 0a000h

mov es, ax; es apunta a vga [Página]

lea si, [palette]; > mov dx, 3c8h

Operación XOR

Salida dx, al

mov dx, 3c9h

mov cx, 189*3

repz outsb

; ===Establecer algunas variables===

mov [DeltaX], 1 velocidad inicial

mov [ DeltaY], 1; cambia esto y mira qué pasa

mov [DeltaZ], 1;

¡Muy divertido!

mov [Xoff], 256

mov [Yoff], 256; usado para calcular la posición vga

mov [Zoff], 300;

Bucle principal:

Llamar a MainProgram es... cumplir cadena perpetua...;-)

Teclado de aluminio, escaneo 60h

cmp al, 1; prueba de escape

jne bucle principal; si no se presiona ninguna tecla, continuar

; ===Salir de DOS ===

mov ax, 0003h volver al modo texto

int 10h

lead dx, [créditos]

mov ah, 9

int 21h

p>

mov ax, 4c00h devuelve el control a DOS

int 21h; llama a DOS interrupción

===subrutina===

PROC WaitVrt espera el retroceso vertical para reducir los "copos de nieve"

mov dx, 3dah

Vrt:

at al, dx

Prueba a1, 8

jnz Vrt espera hasta que comience el retroceso vertical

NoVrt:

In al, dx

Prueba a1, 8

jz NoVrt espera a que finalice el retroceso vertical

ret regresa al programa principal

ENDP Witte

Ángulo de actualización PROC

; Calcular nuevos ángulos x, y, z

; Girar alrededor

mov ax, [ángulo x]; bx, [Yang乐]

mov cx, [Zanger]

Agregar ax, [DeltaX]; agregar velocidad

También ax, 11111111b; .. 255

mov [XAngle], ax; actualizar 255

mov[Yang Le], bx; actualizar Y

agregar cx, [DeltaZ]; agregar velocidad

y cx, 11111111b; rango de 0. .255

mov [ZAngle], CX; actualizar Z

Remojar en agua para suavizar

Ángulo de actualización de ENDP

Proceso GetSinCos

Requiere: bx = ángulo(0..255)

; bx=Cos

Empujar bx; Guardar ángulo (usado como puntero)

shl bx, 1; toma una palabra para que bx=bx*2 [Página]

mov ax, [SinCos bx]; get sine

pop bx Restaura el puntero a bx

Empuja el hacha y guarda el seno en la pila

Agregar; bx, 64; suma 64 para obtener el valor del coseno

Y bx, 11111111b ; Rango de 0..255

shl bx, 1; p>

mov ax, [SinCos bx]; Obtener valor del coseno

mov bx, ax guardar bx=Cos

pop ax restaurar ax=Sin

Remojar en agua para suavizar

ENDP·Gaisenkos

Rotación de recolección del proceso

Establecer el valor del coseno de seno ampx, y, z

mov bx, [x ángulo]; agarrar ángulo

Llamar Obtener

SinCos obtiene la suma de los senos.

coseno

mov [Xsin], hacha; guardar sin

mov [Xcos], bx; guardar cos

mov bx, [杨乐]

Llamar a GetSinCos

mov [Ysin], ax

mov [Ycos], bx

mov bx, [Zangle]

Llamar a GetSinCos

mov [Zsin], ax

mov [Zcos], bx

Remojar en agua para ablandar

ENDP establecer rotación

PROC Rotar punto; rotar punto alrededor de x, y, z

; obtener valores originales de x, y, z

; Continúe en otro lugar

movsx ax, [cubic si]; si = X (byte movsx coz)

mov [X], ax

movsx ax, [cubic si 1]; si 1 = Y

mover[Y], ax

movsx ax, [cubic si 2]; Z], ax

; Girar alrededor del eje x

; YT = Y * COS(xang) - Z * SIN(xang) / 256

; ZT = Y * SIN(xang) Z * COS(xang) / 256

;Y = YT

;Z = ZT

Mover eje, [ Y ]

mov bx, [XCos]

imul bxax = Y * Cos(xang)

Mover bp, ax

Mover eje , [Z]

mov bx, [XSin]

imul bxax = Z * Sin(xang)

sub bp, ax bp = Y * Cos (xang) - Z * Sin(xang)

sar pb, 8 pb = Y * Cos(xang) - Z * Sin(xang) / 256

Movimiento [este año hasta la fecha], BP

Mover eje, [Y]

mov bx, [XSin]

imul bxax = Y * Sin(xang)

Mover bp, ax

Mover eje, [Z]

mov bx, [XCos]

imul bxax = Z * Cos( xang)

Sumar pb, ax; BP = Y * SIN(xang)Z * COS(xang)[Página]

sar pb, 8; * COS(xang) / 256

mov [Zt], bp

mov ax, [Yt] valor de cambio

move [Y], ax<; /p>

Mover eje, [Zt]

Mover [Z], eje

; Girar alrededor del eje y

; COS (Yang) - Z * PECADO (Yang) / 256

; ZT = X * PECADO (Yang) Z * COS (Yang) / 256

; p>

;Z = ZT

Mover eje, [X]

mov bx, [YCos]

imul bxax = X * Cos( Yang )

Mover pb, hacha

>

Mover eje, [Z]

mov bx, [YSin]

imul bxax = Z * Sin (Yang)

sub bp, ax ;bp = X * Cos(Yang)- Z * Sin(Yang)

sar bp, 8; bp = p>mov [Xt], bp

Mover eje, [X ]

mov bx, [YSin]

imul bxax = X * Sin (Yang)

Mover bp, ax

Mover eje , [Z]

mov bx, [YCos]

imul bxax = Z * Cos (Yang)

Sumar pb, ax = X * SIN; (Yang) Z * COS (Yang)

sar pb, 8 pb = X * SIN (Yang) Z * COS (Yang)/ 256

mov [Zt], pb

mov ax, [Xt]; cambiar valor

mov [X], ax

Mover eje, [Zt]

Mover [Z], hacha

; girar alrededor del eje z

; XT = X * COS (Zang)- Y * SIN(Zang)/ 256

; YT = X * SIN(Zang)Y * COS(Zang)/ 256

; X = XT

Y = YT

Mover eje, [X]

mov bx, [ZCos]

imul bxax = X * Cos(Zang)

Mover bp, ax

Mover eje, [Y]

mov bx, [ZSin]

imul bxax = Y * Sin (Zang)

sub pb, ax pb = X * Cos( Zang)- Y * Sin(Zang)

sar pb, 8 pb = X * Cos(Zang) - Y * Sin(Zang)/ 256

mov [Xt], bp

Mover eje, [X]

mov bx, [ZSin]

imul bxax = X * Sin(Zang)

Mover bp, ax

Mover eje, [Y]

mov bx, [ZCos ]

imul bxax = Y * Cos(Zang)

Agregar bp, ax; bp = X * SIN(Zang)Y * COS(Zang)[Página]

sar bp, 8; bp =, [Xt];

mov [X], hacha

mov hacha, [Yt]

Mover [Y], hacha

Remojar en agua suaviza

Punto de rotación ENDP

Punto de visualización del proceso

; calcular la suma de la posición de la pantalla

; dibujar en el punto de la pantalla

mov ax; , [Xoff]; Xoff*X / Z Zoff = pantalla X

mov bx, [X]

imul bx

mov bx, [Z]

Agregar bx, [Zoff]; distancia

idiv bx

Agregar ax, [Mx];

hacha

mov ax, [Yoff]; Yoff*Y / Z Zoff = pantalla Y

mov bx, [Y]

imul bx

mov bx, [Z]

Agregar bx, [Zoff];

mov bx, 320

imul bx

Agregar hacha, BP; ax = (y*320) x

Mover di, ax

mov ax, [Z]; obtener color del eje Z

Agregar ax, 100d (este código se puede mejorar)

mov [byte ptr; es: di], al; colocar un punto con color al

mov[erase si], di; guardar posición borrada

Remojar en agua para suavizar

Punto de rendimiento ENDP

Programa principal del proceso

Llame a UpdateAngles para calcular nuevos ángulos

Llame a SetRotation para encontrar el seno amperio coseno de estos ángulos

xor si, si; el primer punto tridimensional

mov cx, número máximo de puntos

Mostrar bucle:

Llame a RotatePoint para rotar el punto usando la fórmula anterior

Llamar a ShowPoint ilustra el problema

Agregar si, 3; el siguiente punto tridimensional

Visualización de bucle

Llame a WaitVrt para esperar el retroceso

xor si, si; comienza en 0 puntos

xor al, al; color = 0 = black

mov cx, número máximo de puntos

Eliminar:

mov di, [erase si]; vgapos punto antiguo

mov [byte ptr es: di], al ; eliminarlo

Agregar si, 3; Siguiente punto

Eliminación del ciclo

Remojar en agua para suavizar

Programa principal ENDP

; ===datos===

Crédito DB 13, 10, "Código Buitre/Forajido", 13, 10, "Dólar"

Etiquetado SinCos palabra; 256 valores

dw 0, 6, 13, 19, 25, 31, 38, 44, 50, 56 [Página]

dw 62, 68, 74, 80, 86, 92, 98, 104, 109, 115

dw 121, 126, 132, 137, 142, 147, 152, 157, 162, 167

dw 172, 177, 181, 185, 190, 194, 198, 202, 206, 209

dw 213 216 220 223 226 229 231 234 237 239

dw 241.243 245 247 248 251.2 52 253 254

Alemania 255, 255, 256, 256, 256, 256, 255, 255, 254

dw 253252251.250248247245243241.239

dw 237 234 231 229 223 220 216 213 209

dw 206 , 202, 198, 194, 190, 185, 181, 177, 172, 167

dw 162, 157, 152, 147, 142, 137, 132, 126, 121, 115

Dibujos 109, 104

, 98, 92, 86, 80, 74, 68, 62, 56

dw 50, 44, 38, 31, 25, 19, 13, 6, 0, -6

dw -13, -19, -25, -31, -38, -44, -50

56, -62, -68

dw -74, -80, -86, -92, -98, -104, -109, -115, -121, -126

dw -132, -137, -142, -147, -152, -157, - 162, -167, -172, -177

dw -181, -185, -190, -194, -198, -202, -206, -209, -213, -216

dw -220, -223, -226, -229, -231, -234, -237, -239, -241, -243

dw -245, -247, -248 , -250, -251, -252, -253, -254, -255, -255

dw -256, -256, -256, -256, -256, -255, -255, -254, -253, -252

dw -251, -250, -248, -247, -245, -243, -241, -239, -237, -234

dw -231, -229, -226, -223, -220, -216, -213, -209, -206, -202

dw -198, -194, -190, - 185, -181, -177, -172, -167, -162, -157

dw -152, -147, -142, -137, -132, -126, -121, -115 , -109, -104

dw -98, -92, -86, -80, -74, -68, -62, -56, -50, -44

dw -38, -31, -25, -19, -13, -6

Etiqueta bytes de cubo; puntos 3d

c = -35; 125) puntos

Informe 5

b = -35

Informe 5

a = -35

Informe 5

db a, b, c

a = a 20

endm

b = b 20

p >

endm

c = c 20

endm

Byte de paleta de etiquetas; la paleta a usar

db 0, 0 , 0; 63*3 tono gris

d = 63

Reporte 63

db d, d, d

db d, d, d

db d, d, d

d = d - 1

endm

X DW? ;X variable de fórmula

Y DW?

¿Z DW?

Xt DW? ;Variable temporal de x

Yt DW?

¿Zt DW?

XAngle DW 0; Ángulo de rotación alrededor de x

Yang Le DW 0

Zange DW 0

DeltaX DW? ;El número de Xangles irá aumentando cada vez

¿DeltaY DW?

¿DeltaZ DW?

¿Xoff DW?

¿Y fuera DW?

¿Zoff DW? ;Distancia del público

XSin DW? ;

Seno y coseno del ángulo de rotación

¿XCos DW?

YSin DW? [Página]

YCos DW?

¿ZSin DW?

¿ZCos DW?

MX DW 160; medio de la pantalla

Mi DW 100

MaxPoints EQU 125; número de puntos 3d

Borrar DW MaxPoints DUP (?); Eliminar la matriz de puntos de la pantalla

Fin del código; fin del segmento de código

Fin del inicio claro....:)

; Puedes utilizar este código en tu propio trabajo, pero

;elogia a quien merece el crédito. Sólo un lisiado robaría código, así que intenta crear tu propio motor 3D y usa este código como ejemplo.

Gracias a Arno Brouwer y Ash para su liberación

Fuente de muestra.

Hola, amigos,

Buitre/Fugitivo Underworld