de su mano derecha siga el eje de rotaci?, sus dedos se curvar疣 en la
direcci? positiva de la rotaci?.
Hay dos versiones de todas las funciones matem疸icas de 3d: una usando
aritm騁ica de punto fijo, y la otra usando coma flotante. La sintaxis para
C++, Allegro tambi駭 sobrecarga estas funciones para que las use con la
clase "fija".
La transformaci? 3d se realiza modelando una matriz. Esta es un array de
4x4 n?eros que pueden ser multiplicados con un punto 3d para producir otro
originales una despu駸 de la otra. Por ejemplo, si tiene una matriz que
rota un punto, y otra que lo mueve en una direcci?, puede combinarlas para
producir una matriz que realizara la rotaci? y translaci? en un paso.
Puede crear transformaciones extremadamente complejas de este modo,
teniendo que multiplicar cada punto 3d por una sola matriz.
Allegro hace trampa al implementar la estructura de la matriz. La rotaci? y
el escalado de un punto 3d puede ser realizado con una matriz simple de 3x3,
pero para trasladar el punto y proyectarlo en la pantalla, la matriz tiene
que ser extendida a 4x4, y el punto extendido a una cuarta dimensi?, al
a?dir una coordenada extra: w=1. Esto es algo malo en t駻minos de
arriba a la izquierda implementa la rotaci? y el escalado. Los tres valores
de arriba de la cuarta columna (d, h y l) implementan la translaci?, y
siempre y cuando la matriz sea usada s?o para transformaciones afines, m, n
aparte para la proyecci?, las funciones de matriz s?o tienen que servir
para la transformaci? af?, lo que significa que no hay que guardar la fila
inferior de la matriz. Allegro asume que esta contiene (0,0,0,1), y por eso
optimiza las funciones de manipulaci? de matrices.
Las matrices se almacenan en estructuras:
typedef struct MATRIX - matriz de punto fijo
{
fixed v[3][3]; - componente 3x3 de escalado y rotaci?
fixed t[3]; - componente x/y/z de translaci?
} MATRIX;
typedef struct MATRIX_f - matriz de coma flotante
{
float v[3][3]; - componente 3x3 de escalado y rotaci?
float t[3]; - componente x/y/z de translaci?
} MATRIX_f
extern MATRIX identity_matrix;
extern MATRIX_f identity_matrix_f;
Variable global que contiene la matriz con identidad 'vac?'. Multiplicar
por la matriz de identidad no tiene ning? efecto.
void get_translation_matrix(MATRIX *m, fixed x, fixed y, fixed z);
void get_translation_matrix_f(MATRIX_f *m, float x, float y, float z);
apply_matrix,
get_transformation_matrix,
qtranslate_matrix.
void get_scaling_matrix(MATRIX *m, fixed x, fixed y, fixed z);
void get_scaling_matrix_f(MATRIX_f *m, float x, float y, float z);
Construye una matriz de escalado, almacen疣dola en m. Cuando se aplica a
un punto (px, py, pz), esta matriz produce un punto (px*x, py*y, pz*z).
En otras palabras, agranda o empeque?ce las cosas.
Relacionado con:
apply_matrix,
get_transformation_matrix,
qscale_matrix.
void get_x_rotate_matrix(MATRIX *m, fixed r);
void get_x_rotate_matrix_f(MATRIX_f *m, float r);
Construye las matrices de rotaci? del eje X, almacen疣dolas en m. Cuando
se aplican a un punto, estas matrices lo rotar疣 sobre el eje X el 疣gulo
especificado (en binario, 256 grados hacen un c?culo).
Relacionado con:
apply_matrix,
get_rotation_matrix,
get_y_rotate_matrix,
get_z_rotate_matrix.
void get_y_rotate_matrix(MATRIX *m, fixed r);
void get_y_rotate_matrix_f(MATRIX_f *m, float r);
Construye las matrices de rotaci? del eje Y, almacen疣dolas en m. Cuando
se aplican a un punto, estas matrices lo rotar疣 sobre el eje Y el 疣gulo
especificado (en binario, 256 grados hacen un c?culo).
Relacionado con:
apply_matrix,
get_rotation_matrix,
get_x_rotate_matrix,
get_z_rotate_matrix.
void get_z_rotate_matrix(MATRIX *m, fixed r);
void get_z_rotate_matrix_f(MATRIX_f *m, float r);
Construye las matrices de rotaci? del eje Z, almacen疣dolas en m. Cuando
se aplican a un punto, estas matrices lo rotar疣 sobre el eje Z el 疣gulo
especificado (en binario, 256 grados hacen un c?culo).
Relacionado con:
apply_matrix,
get_rotation_matrix,
get_x_rotate_matrix,
get_y_rotate_matrix.
void get_rotation_matrix(MATRIX *m, fixed x, fixed y, fixed z);
void get_rotation_matrix_f(MATRIX_f *m, float x, float y, float z);
get_transformation_matrix,
get_vector_rotation_matrix,
get_align_matrix,
get_x_rotate_matrix,
get_y_rotate_matrix,
get_z_rotate_matrix.
void get_align_matrix(MATRIX *m, fixed xfront, yfront, zfront,
fixed xup, fixed yup, fixed zup);
Rota la matriz de tal forma que la alinea sobre las coordenadas de los
vectores especificados (estos no tienen que ser normalizados o
perpendiculares, pero up y front no pueden ser iguales). Un vector front
de 1,0,0 y un vector up de 0,1,0 devolver疣 la matriz de identidad.
Relacionado con:
apply_matrix,
get_camera_matrix.
void get_align_matrix_f(MATRIX *m, float xfront, yfront, zfront,
float xup, yup, zup);
Versi? en coma flotante de get_align_matrix().
Relacionado con:
get_align_matrix.
void get_vector_rotation_matrix(MATRIX *m, fixed x, y, z, fixed a);
Relacionado con:
apply_matrix,
get_rotation_matrix,
get_align_matrix.
Relacionado con:
apply_matrix,
get_rotation_matrix,
get_scaling_matrix,
get_translation_matrix.
void get_transformation_matrix_f(MATRIX_f *m, float scale,
float xrot, yrot, zrot, x, y, z);
Versi? en coma flotante de get_transformation_matrix().
Relacionado con:
get_transformation_matrix.
void get_camera_matrix(MATRIX *m, fixed x, y, z, xfront, yfront, zfront,
fixed xup, yup, zup, fov, aspect);
Construye la matriz de c疥ara para trasladar objetos del espacio a una
vista normalizada del espacio, preparada para la proyecci? de
perspectiva. Los par疥etros x, y, z especifican la posici? de la c疥ara,
xfront, yfront y zfront son los vectores 'de frente' que especifican
hacia adonde apunta la c疥ara (estos pueden ser de cualquier tama?, no
es necesaria la normalizaci?), y xup, yup y zup son los vectores de la
direcci? 'arriba'. El par疥etro fov especifica el campo de visi? (el
ancho del foco de la c疥ara) en binario, haciendo 256 grados un c?culo.
Para proyecciones t?icas, un campo de visi? de entre 32 a 48 trabajara
bien. Finalmente, la raz? de aspecto es usada para el escalado en la
dimensi? Y relativamente al eje X, para que pueda ajustar las
proporciones de la imagen final (ponga a uno para no escalar).
Relacionado con:
apply_matrix,
get_align_matrix.
void get_camera_matrix_f(MATRIX_f *m, float x, y, z, xfront, yfront,zfront,
float xup, yup, zup, fov, aspect);
Versi? en coma flotante de get_camera_matrix().
Relacionado con:
get_camera_matrix.
void qtranslate_matrix(MATRIX *m, fixed x, fixed y, fixed z);
void qtranslate_matrix_f(MATRIX_f *m, float x, float y, float z);
Rutina optimizada para trasladar una matriz ya generada: esto
simplemente a?de el 'offset' de translaci?, por lo que no hay que crear
dos matrices temporales y multiplicarlas.
Relacionado con:
get_translation_matrix.
void qscale_matrix(MATRIX *m, fixed scale);
void qscale_matrix_f(MATRIX_f *m, float scale);
Rutina optimizada para escalar una matriz ya generada: esto simplemente
a?de el factor de escalaci?, por lo que no hay que crear dos matrices
temporales y multiplicarlas.
Relacionado con:
get_scaling_matrix.
void matrix_mul(const MATRIX *m1, MATRIX *m2, MATRIX *out);
void matrix_mul_f(const MATRIX_f *m1, MATRIX_f *m2, MATRIX_f *out);
Multiplica dos matrices, guardando el resultado en out (que puede ser
un duplicado de una de las dos m疸rices de entrada, pero es m疽 r疳ido
cuando las entradas y la salida son todas distintas). La matriz
matrix_mul(m1,m2) != matrix_mul(m2,m1).
Relacionado con:
apply_matrix.
fixed vector_length(fixed x, fixed y, fixed z);
float vector_length_f(float x, float y, float z);
Calcula la longitud del vector (x, y, z), usando ese buen teorema de
Pit疊oras.
Relacionado con:
normalize_vector.
void normalize_vector(fixed *x, fixed *y, fixed *z);
void normalize_vector_f(float *x, float *y, float *z);
Convierte un vector (*x, *y, *z) a un vector normalizado. Este apunta en
la misma direcci? que el vector original, pero tiene una longitud de
uno.
Relacionado con:
vector_length,
dot_product,
cross_product.
fixed dot_product(fixed x1, y1, z1, x2, y2, z2);
float dot_product_f(float x1, y1, z1, x2, y2, z2);
Calcula el producto escalar (x1, y1, z1) . (x2, y2, z2), devolviendo el
resultado.
Relacionado con:
cross_product,
normalize_vector.
void cross_product(fixed x1, y1, z1, x2, y2, z2, *xout, *yout, *zout);
void cross_product_f(float x1, y1, z1, x2, y2, z2, *xout, *yout, *zout);
Calcula el producto vectorial (x1, y1, z1) x (x2, y2, z2), almacenando el
resultado en (*xout, *yout, *zout). El resultado es perpendicular a los
dos vectores de entrada, para que pueda ser usado para generar las
normales de los pol?onos.
Relacionado con:
dot_product,
polygon_z_normal,
normalize_vector.
fixed polygon_z_normal(const V3D *v1, V3D *v2, V3D *v3);
float polygon_z_normal_f(const V3D_f *v1, V3D_f *v2, V3D_f *v3);
Encuentra la componente Z de la normal de un vector de tres v駻tices
especificados (que deben ser parte de un pol?ono convexo). Esto es usado
principalmente en la ocultaci? de caras. Las caras traseras de un
poliedro cerrado nunca son visibles al espectador, y por tanto no
Relacionado con:
cross_product.
void apply_matrix(const MATRIX *m, fixed x, y, z, *xout, *yout, *zout);
void apply_matrix_f(const MATRIX_f *m, float x, y, z, *xout, *yout, *zout);
Multiplica el punto (x, y, z) por la transformaci? de la matriz m,
almacenando el resultado en el punto (*xout, *yout, *zout).
Relacionado con:
matrix_mul.
Relacionado con:
persp_project.
void persp_project(fixed x, y, z, *xout, *yout);
void persp_project_f(float x, y, z, *xout, *yout);
Proyecta el punto 3d (x, y, z) del espacio sobre una pantalla 2d,
almacenando el resultado en (*xout, *yout) usando los par疥etros
anteriormente ajustados por set_projection_viewport(). Esta funci?
proyecta desde la pir疥ide de vista normalizada, que tiene una c疥ara en
el origen apuntando al eje z positivo. El eje x va de izquierda a
derecha, y va de arriba a abajo, y z se incrementa con la profundidad de
la pantalla. La c疥ara tiene un 疣gulo de visi? de 90 grados, es
decir, los planos x=z y -x=z ser疣 los bordes izquierdo y derecho de la
pantalla, y los planos y=z y -y=z ser疣 la parte superior e inferior de
la pantalla. Si quiere un campo de visi? diferente a la posici? de la
c疥ara, deber? transformar todos sus objetos con la matriz de visi?
apropiada. Ejemplo, para obtener el efecto de haber girado la c疥ara 10
grados a la izquierda, rote todos sus objetos 10 grados a la derecha.
Relacionado con:
set_projection_viewport.
Volver al Indice