tesis_uam/Graficacion en 3D_UAM1969.pdf - cedip

~ ~ I ~ E R AUTONOMA $ ~ 5 ~ 5 METROPOLI
LICE CIATURA EN
Arias Mendoza Carlos
Cuevas Bonilla Raúl
Vilchis Orozco Roberto
Trimestres 9 6-1 y 9 6-P

a
Proyecto en la Ingeniería I y II
"Graficación tridimensiional"
Contenido
Objetivos y plan de trabajo
Espacios Vectoriales
Representación paramétrica de superficies
Rotaciones
Rotaciones en el espacio
Metodos de ordenación en profundidad
Representación en memoria de objetos
tridimensionales
Reconocedor y generador de objetos
tridimensionales
Metodo de "Z-Buffer"
Administración de la memoria
La programación XMS
Utilización de la rutinas XMM1.H
Bibliografía

Objetivo General:
Proyecto de investigación
Titulo: "Graficación 3D"
Crear una biblioteca de funciones de graficación 3D para PC, sujeta al estandard VESA (
SVGA) a 256 colores.
Marco Teórico:
Es bien sabido que la graficación por computadora y en particular la graficación
tridimensional reqltiere de algoritmos complejos y gran cantidad de recursos del sistema
(memoria y velocidad de cómputo): Es por ello que convergen en ésta disciplina técnica de
programación de sistemas, estructuras de datos, compiladores8, optimización, análisis y diseño de
algoritmos, algebra lineal y geometría proyectiva.
Uno de los objetivos principales de este proyecto e:; ( a parte del producto en si )
complementar la formación de los educandos,por medio de la1 integración de sus conocimientos
previamente adquiridos con un propósito comun.
Plan de Trabajo
Primer trimestre:
Estudiar diversas estructuras de datos para representar objetos tridimensionales y en
función de ello escoger la(s) que más convenga(n) a nuestros propósitos.
Analizar y comprender diversos algoritmos como por ejemplo: "ordenación en
profundidad" y "z-buffer". Llevar a cabo s'u implementación.
La programación se realizará en lenguaje C
Segundo Trimestre:
Estudiar técnrcas de manejo de memoria extendida, para satisfacer las necesidades de
memoria de los algoritmos mencionados.
lmplementar una función que genere objetos tridimensionales a partir de ecuaciones de
superficies. (Se usarán tecnicas de Comptladares)

Transformaciones lineales:
Espacios Vectoriales
Dados U E R3 3 V E R3 una transformación lineal cumple las siguientes propiedades:
L(U+V)=L(U)+L(V)
L(cU) = cL(U)
por ejemplo L:R3 -+ R
(a,b,c) -+ a
(a,b,c) -+a +b+c
( a, b, c ) -+ 3a - 4b + 2c
( a, b, c ) -+ 4a, 3b
(a,b,c) -+ 5a,2c
Las siguientes tramfomaciones R3 4 R2 reciben un punto en el espacio ( x,y,z ) y lo
mandan (transforman) a un punto en el plano X'.Y'.
ii,
(1,0,0)+ al, bl
(O,l,O)-+ a2,b2
( O, O, 1 ) -+ a3, b3
2 + x
(O,O,l] (l.O,O]
IR3
y'l
(aZb2)
/"'
(a3.b3)
IR2

Las transformaciones lineales pueden representarse como matrices, por lo que es posible
representar las transformaciones anteriores
de la siguiente manera:
Aplicando las propiedades de las transformaciones lineales se tiene:
La matriz de transformación resulta:
vectores - { }
base
O 0 1

Coordenadas Esféricas
Representación Paramétrica cle Superficies
Una superficie tridimensional puede representarse en coordenadas rectangulares,
cilíndricas y esfericas, en particular nos interesan las ecuacion'es pararnétricas en coordenadas
esfericas, la representación espacial de un punto es como sigue:
/
z = tcos 8
t = r sen Q
x = r sen Q sen 8
y= rcos Q
z= r sen cos8
Del esquema anterior se observa que un punto con coordenadas (x,y,z) puede describirse
en función de dos ángulos ( 6 y 9) los cuales son los parárnetos, y la distancia de dicho punto al
origen de coordenadas. En el caso de las coordenadas esféricas, los ángulos 0 y cp toman valores
de O - 2Il y de O - Il radianes respectivamente, con Io cual se cubre todo el espacio
tridimensional.

Rotaciones
Una rotación es una transformación lineal, un caso particular es la rotación de un sistema
de coordenadas. Considere un punto en el plano X-Y de coordenadas (x,y), expresado en
coordenadas polares se tiene:
1
Q = arc: tan -
X
Y
Si rotamos los ejes coordenados q grados en el sentido contrario a las manesillas del reloj,
obtenenmos un nuevo sistema de referencia X-Y'. Las nuevas coordenadas para el punto en
cuestion resultan:
X
YV = arc tan [-I - 8
Y
Observando los puntos (X,,Y,) = (1,O) y (X,,Y,) = ( C),1) del sistema de coordenadas
original, podemos obtener las nuevas coordenadas para este punto, resultando:
( X,',Y,' ) = ( cos 0, sen 0 )
( X,',Y,' ) = ( -sen 0, cos 8 )
Ahora obtenemos que una rotación del plano X-Y 0 grados positivos se puede expresar
como el producto de dos matrices:
x' = x cos 8 - y sen0
y' = x sene +' y cos O
Es decir para obtener las nuevas coordenadas de un purlto que ha sido rotado 8 grados, se
requieren las coordenadas del punto sin rotar y el ángulo de rotación.

Rotaciones en el espiacio
Si rotamos los ejes X-Y y dejamos fijo el eje Z, tenemos:
Y
Z /
Las nuevas coordenadas resultan:
X
(l,O,O) -+ ( cos 8, sene, O )
(0,1,0) -+ ( -sene, cos 8, O )
(0,0,1) -+ ( o, o, 1 1
y '\
Por lo.tanto la matriz de rotación con el eje Z fijo, es la si'guiente:
Dejando fijo el eje X
(1 O O Y x 1 f x' \
Io cos -sene /I y I = I y' I
\O sene cos e I\ z I \ 2' I
Dejando fijo el eje Y :
(COS e o -sene x ) f x' 1
Io 1 O IIy I = I y' I
\sene O COS e i\ z I 2' I

Métodos de detección de suplerficie visible
Una consideración importante en la generación de despliegues de gráficas realistas es la
identificación de aquellas partes de una escena que son visibles desde una posición de vista
seleccionada
Los algoritmos de detección de superficie visible se clasifican en forma general
dzpendiendo de si manejan definiciones de objetos de ma,nera directa o con sus imágenes
proyectadas. Estos dos planteamientos se denominan métodios de objeto-espacio y métodos de
imagen-espacio, de modo respectivo. Un método de objeto-espacio compara objetos y partes de
objetos con cada tino de los mismos en la definición de la escena a fin de determinar qué
superficies, como un todo, debemos designar como visibles. Ein un algoritmo de imagen-espacio,
la visibilidad se decide punto por punto en cada posición de pixel en el plano de proyección.
Método de clasificación de profundidad
AI utilizar tanto operaciones de imagen-espacio coma1 de objeto espacio, el método de
clasificación de profundidad realiza las funciones básicas siguientes:
1) Se clasifican las superficies en orden de profundidad decreciente.
2) Se convierten por rastreo las superficies en orden, al iniciar con la superficie de la mayor
profundidad.
Las operaciones de clasificación se efectúan tanto en irnagen como en objeto-espacio y la
conversión de rastreo de las superficies de polígono se lleva a cabo en imagen-espacio.
Este método para solucionar el problema de las superficies ocultas a menudo se denomina
algoritmo del pintor. Primero clasificamos las superficies de acuerdo con su distancia desde el
plano de visión, de esta manera se capturan en el búfer de enfriamiento los valores para la
'superficie más alejada. AI manejar cada superficie a la vez ( ein orden decreciente de profundidad
), "pintamos" las intensidades de superficie en el búfer de estructura sobre las intensidades de las
superficies que se procesaron antes.
La pintura de superficies de polígono en el búfer !de estructura de acuerdo con la
profundidad se realiza en varios pasos. Si suponemos que vernos a lo largo de la dirección de las
z, las superficies se ordenan en la primera trayectoria de acuerdo con el valor más alto de z en
cada superficie. La superficie con la profundidad más alta se compara entonces con las otras
superficies en la lista para determinar si hay alguna superposición la profundidad. si no se da
nlnguna superposición en la profundidad, la superficie S se convierte por rastreo. La figura 1
iiustra dos superficies que se superponen en el plano xy pero no tienen ningún traslape de
profundidad.

zmaxb
Zrnin
Asi se repite este proceso para la siguiente superficie en la lista. En tanto que no haya
ninguna superposición, se procesa cada superficie en orden cle profundidad hasta que se hayan
convertido todas por rastreo. Si se detecta una superposicitjn en la profundidad en cualquier
punto de la lista, es necesario realizar algunas comparaciones adicionales para determinar si se
debe reorganizar cualquiera de las superficies.
Practicamos las pruebas siguientes para cada superficile que se traslapa con S. si alguna
de estas pruebas es verdadera, no es necesario llevar a cabo ninguna reorganización para esa
superficie. Las pruebas se listan en orden incremental de dificultad.
1) Los rectángulos limítrofes en el plano de xy para las dos superficies no se sobreponen.
2) La superficie S está por completo detrás de la superficie que se sobrepone con respecto
de la posición de vista.
3) La superficie que se sobrepone está por completo enfrente de S con respecto de la
posición de vista.
4) Las proyecciones de las dos superficies en el plano de visión no se traslapan.
Realizamos estas pruebas en el orden en que se listan y procedemos a la siguiente
superficie que se sobrepone en cuanto encontramos que una de las pruebas es verdadera. Si
todas las superficies que se traslapan pasan por Io menos una de estas pruebas, ninguna de
éstas se halla detrás de S. Así, no es necesario efectuar ninguna reorganización y se convierte
por rastreo S.
La prueba 1 se lleva a cabo en dos partes. Primero verificamos la sobreposición en la
dirección de x, luego verificamos la sobreposición en la dirección de y Si alguna de estas
direcciones no presenta sobreposición, los dos planos no pueden oscurecerse entre si. En la
figura 2 se presenta un ejemplo de dos superficies que se sobreponen en la dirección de z pero
no en la dirección de x.

-7v
Xrnin Xrnax X'rnin X'max
figura 2
Dos supeMaés
con sobreposia5n
en profunddad
pero sin fraslape
en /a dremzn
de x
Podemos practicar las pruebas 2 y 3 con una prueba de polígono "interna y externa". Es
decir, sustituimos las coordenadas para todos los vértices de S en la ecuación del plano para la
superficie que se traslapa y verificamos el signo del resultado,. Si se establecen las ecuaciones
del plano de manera que el exterior de la superficie se dirija hacia la posición de vista, entonces S
está atrás de S's¡ todos los vertices de S están "adentro" de S'( Figura 3).
I figura 3
La supeMaé S
se h311a por comp/eto
atris de [adentro de 1
/a supedaé
sobrepuesta S
De modo similar S' está por completo enfrente de S si todos los vértices de S están por
completo "afuera" de S. La figura 4 ilustra una superficie S' que se traslapa, la cual está por
completo enfrente de S, pero la superficie S no está por completo "adentro" de S'(la prueba 2 no
es verdadera).
+ xi
zi
figura 4
L 3 supehaé
sobrepuesta S' esta'
por cumpleto en trente
de f afuera de]/.
supedaé S, pero Sno
estgpor completo
atkk de S!

t
Si las pruebas 1 y 3 no tiene éxlto, intentamos con la prueba 4 al verificar las
intersecciones entre las aristas limítrofes de las dos superficies utilizando las ecuaciones de la
linea en el plano xy. Como se demuestra en la figura 5. dos superficies pueden intersectarse o no
incluso si sus extensiones de coordenadas se traslapan en las direcciones de x,y y 2.
figura 5
Si las cuatro pruebas fracasan con una superficie de sobreposición particular S',
intercambiamos S y S' en la lista calificada. En la figura 6 se presenta un ejemplo de dos
superficies que se deben reorganizar con este procedimiento.
I
I. I
En este punto aún no sabemos con certeza que hemos encontrado la superficie más
alejada del punto de visión. La figura 7 ilustra una situación en que primero intercambiariamos S
y S'.

Representación en memoria de objetos tridimensionales
Estructura de datos para un objeto tridimensional:
struct punto {
float x,y,z;
1;
struct plano {
int numero-de-vertices;
float z-min,z-max;
float N-X,N-Y,N-Z;
struct punto ** ptr-lista-puntos;
struct plano *siguiente;
1;
struct objeto {
struct punto *ptr-puntos;
struct plano *ptr-planos;
1;
El usuario declara dentro de main() o bien como variable global un puntero a una estructura
de tipo objeto o bien una estructura de tipo objeto :
Caso (1) struct objeto *ptr-objeto;
Caso (2) struct objeto mi-objeto;
Si el usuario opta pcr el caso (1) deberá solicitar memorla para la estructura, como se
muestra a continuación:
ptr-objeto = farrcalloc(1, sizeof ( struct objeto ) );
o bien:
ptr-objeto = malloc( sizeof ( struct objeto ) );
Calculo para los puntos tridimensionales de un bojeto
Dada la ecuación paramétrica de un ob,._:o tridimensional, se plantea al número de puntos a
graficar tomando en cuenta el número de intervalos de división para cada uno de los parámetros
del objeto, por ejemplo, si U y V son los parámetros de cierto objeto, el usuario determina el
número de puntos en los que se divide cada uno, con IC) que obtenemos dos variables :
parametro-U y parametro-\/, la cantidad de puntos a gráficar se obtiene de:
numguntos-a graficar = (( parametro-U +I) * (parametro-V +I));
El siguiente paso es resevar la memoria necesaria para almacenar este número de puntos,
el campo puntos de la estructura objeto almacena la dirección de esta lista dinámica de puntos,
esto lo hacemos con la siguiente instrucción:
ptr-objeto->puntos = farcalloc(numguntos-a_grafic~tr, sizeof(struct punto) );

En este punto se tiene lo slguiente en memoria:
De acuerdo a la ecuación paramétrica de cada objeto. se calculan los valor tridimensionales
(x,y,z) de cada punto de la superficie del objeto, y se almacenan en la lista de puntos.
Calculo de los planos que forman la superficie del objeto
Con los valores de los puntos (x,y,z) en memoria ahora es posible formar una lista para los
planos que formarán el objeto. La estructura de datos declarada como struct plano contiene un
campo llamado siguiente con el que se crea la lista de manera dinámica, el otro campo llamado
*ptr-/ista_puntos es un puntero que apunta a una lista dinámica de punteros a estructuras de tipo
punto, tal y como se muestra en el siguiente esquema:
struct plano wr'
I
1 t I____) .
struct punto
Para crear un plano se solicita memoria dinámica para una estructura de tipo plano, y se
comienza a crear la lista de planos, esta lista es apuntada por ptr-objeto->p/anos.
En el momento de crear un primer nodo de la lista, se debe solicitar también memoria para la
lista de punteros a estructuras de tipo punto, este nuevo arreglo dinámico de punteros solicitara el
número de localidades necesarias según los planos se formen con tres o cuatro puntos, como se
observa en la siguiente instrucción:
struct punto *puntos;
puntos = malloc ( (nurn-de-vertices) * (sizeof (* struct punto) ) );
donde nurn-de-vertices es uno de los campos de la estructura 'struct plano'. El campo
*ptr-lista-puntos apunta a esta lista dinámica de punteros a puntos.

AI momento de formar un plano de 3 o 4 puntos, se calculan los valores de profundidad
minima y profundidad máxima los cuales se guardan en los campos z-min y z-rnax
respectivamente. Recordando que cada vertice del plano tiene componentes x,y,z, es posible
comparar cada uno de los valores para z y obtenr el máximo y el minimo.
Obtención de las
coordenadas
z-min y z-max
para un plano
partucular.
z-min
z-m ax
z-
Tambien es posible calcular en este momento las componentes del vector normal a dicho
plano , que ocupan los campos N-X, N-Y y N-2, estos valores se obtienen de calcular el “produto
cruz” entre dos vectores que pertenecen al plano. A su vez un vector que pertenece al plano se
obtienen de restar dos puntos que pasan por el plano, estos puntos ya fueron calculados en la
etapa previa a la formación de este plano.
z
I
En el caso en que un plano este formado por cuatro puntos, se tiene que cada punto tiene
corrdenadas x,y,z de tal forma que pi = (x,y,z), obtenemos un vector sobre el plano mediante la
resta de dos puntos del plano, por ejemplo:
El producto punto entre dos vectores a y b se obtiene mediante:
a = (al ,a2,a3) y b = (bl,b2,b3)
El producto anterior nos da el vector normal al plano

"Reconocedor y Generadoir
Uno de los objetivos de nuestro proyecto era el de realizar un "Reconocedor y Generador" el cual se encargara
de aceptar expresiones de la forma:
donde:
"varl[ini,fin,inter],var2[ini,fin,inter],x,y,z"
varl .va2:Son los dos parametros de los que dependeran las ecuaciones parametricas.
ini,fin :Es donde comienza y donde termina el intervalo de cada parametro.
inter :Es el No. de divisiones del intervalo.
x,y,z :Son las ecuaciones parametricas del Objeto a graficar.
Una vez reconocida y aceptada la expresión se procede a generar la Lista de Puntos del Objeto.
RECONOCEDOR DE EXPRESIONES
Para reconocer las expresiones se utilizan 3 archivos que el usuario debera utilizar con '%include" y son :
gen3d.h
lex3d.h
parse3d. h
GEN3D.H
El archivo "gen3d.h" incluye (por medio de 'Winclude" ) a "parse3d,h".Prirneramente la función principal es
"genera" y es mandada llamar por el usuario de la siguiente forma:
mi-objeto=genera("expresión");
La variable "mi-objeto" será un apuntador a una estructura tipo objeto, por Io tanto regresara el apuntador a el
objeto ya generado.
Esta función "genera" realizá propiamente el reconocimiento de toda la expresión y como se observa recibe una
cadena que guarda en una variable llamada "exp" la cual a su vez es igualada a la variable "yyin", que es la que
utiliza nuestro analizador lexico.
A la expresión , para nuestro análisis la dividimos en dos partes, la primera es la que contiene a cada una de los
parametros con su respectiva información sobre sus intervalos y la segunda es la que contiene las ecuaciones
parametricas.
La información de la primera parte es guardada en un arreglo de dos llarnado "U" del tipo:
struct GEN-VAR{
float in¡;
float fin;
int n; /*No. de intervalos*/
float val; /*Valor que irá tomado el parametro*/
char nomb[lO]; /*Nombre del parametro*/
1; struct GEN-VAR U[2];
Para el análisis de esta primera parte de la expresión se va recorriendo cada uno de los caracteres de la cadena
y pasandose cada uno a la vez al analizador lexico.
El análisis de la segunda parte se hace dentro de dos ciclos (que van desde "ini" hasta "fin" con un salto de
"inter") que van recorriendo los intervalos de los 2 parametros y dandole valor a cada uno.Obteniendo el valor de
cada uno de los parametros de esta forma , se manda llamar al analizador sernántico para cada una de las
ecuaciones parametricas y por supuesto regresara el valor para "x"',"y" o ' Y que son guardados en una
estructura de tipo "punto".Así al recorrer los 2 ciclos habremos obtenido la lista de puntos del objeto.

En seguida se mandan a llamar las funciones que ya se han comentado anteriormente:
translada(OBJET0) /*Translada la lista de puntos al nuevo sistema de
Coordenadas segun el punto de vision.
Planos(OBJET0) /*Genera los planos del objeto a graf'icar.
Pre-Ordenacion(OBJET0) /*Ordena los planos según la 'Z' mas negativa.
Ordenacion-en-Profundidad(OBJET0) /*Ordena ahora los planos segun el Algoritmo
de Ordenaciopn por Profundidad.
LEX3D.H
Este archivo contiene el Analizador Lexico.Este analizador es llamaclo tanto por la función "genera" como por el
Analizador Semántico, y regresa cada uno de los tokens respectivos:
1) Caractares alfanumericos.
Para este caso tenemos cuatro cadenas en particular que regresan tokens especiales:
"sin" regresa el token SIN.
"cos" regresa el token COS.
"tan" regresa el token TAN.
"Pi" regresa el token PI.
De otro forma solo se regresa el token ID.
2) Digitos (Reconoce de Tipo 'float') y regresa el token NUM.
3) Cualquier otro diferente a los anteriores regresa propiamente el caracter leido.
PARSE3D.H
Este archivo tiene un ''#include" para "lex3d.h".Fue generado por medio de la herramienta BISON para obtener
Analizadores Semánticos :
YO{
"0)
#define alloca malloc
#define WSTYPE double
%token WNUM YYlD SEN COS TAN PI
%left '+,' I-'
Ohleft '*I '1
%right umenos
Ohright 'N
L3 : L2 I,' E {return($3);}
L2 : L1 ',I E {return($3);}
L1 :E {return($l);}
E : E '+' E {$$=S1 +$3;}
I E "' E {$$=$1-$3;}
I E '*I E {$$=$1'$3;}
1 E 'r E {$$=$1/$3;}
I I-' E %prec umenos {$$ = -$2;}
I '(I E I)' {$$=$2;}
I E I*' E {$$=pow($l,$3);}
I YYNUM {$$=yylval;}
I YYlD {$$=yylval;}
I SEN '(I E I)' {$$=sin($3);}

Oh Oh
1 COS '(I E 'j' {$$=COS($~);}
I TAN '(I E I)' {$$=tan($3);}
I PI {$$=Pi;}
I error (return(0);)
#include "lex3d.h"
yyerror(){printf("ERROR!!!!!! ...'I);}
GRAFICACION DEL OBJETO
Para la graficación del Objeto se debe incluir al archivo "graf3d.h" , que tiene las siguientes funciones
comentadas ya anteriormente:
Inicializa-Graficos().Pide el tipo de modo grafico a inicializar
Libera-Objeto(struct objeto *objeto).Recibe un apuntador a la estructura del objeto.
Dibuja(struct objeto *objeto).También recibe ese apuntador al Objeto y va graficando
cada plano ya ordenados propiamente.
INTERFASE CON EL USUARIO
El usuario creará su archivo en C el cual deberá contener primeramente dos '%include" que son "gen3d.h" y
"graf3d.h".Despues .debera inicializar un apuntador a una estructura tipo objeto.Enseguida debera inicializar el
modo grafico mediante la llamada a la funcion Inicializa-Graficos".El apuntador al objeto declarado previamente
será regresado por la llamada a la función "genera",ya teniendo este ;apuntador se pasa éste para ser graficado
mediante la funcion "Dibuja".Cuando el usuario decida debera liberar la memoria requerida por toda la estructura
del Objebmediante la llamada a "Libera-Objeto".
Un ejemplo para graficar un cilindro sería:
#include "gen3d.h"
#include "graf3d.h"
struct objeto *mi-objeto;
man(){
clrscr();
Inicializa-Graficos();
mi objeto=genera("u[0,2*Pi,2O~,v[0,2*Pi,20],50*~~~'~~),20*u,50*sin(v)");
Dibuja(mi-objeto);
getch0;
Libera-Objeto(mi-objeto);
closegraph();
1

Introducci5n:
BUFFER 2
Todas los monitores presentan las imágenes mediante la composición de pequeños
puntas de color que se encienden y apagan en la pantalla; a estos puntos se !es conocen
como pixeles y varían en numero dependiendo de la resol.ución del monitor, a mayor
numero de pixeles en la pantalla de un monitor, mayor será 1.a resolución de imágenes de
este. Como ejemplo de resolución en monitores se tienen:
320x 200
640x 200
@Ox 480
8OOx 600
1024x 764
1024x1024
Estas resoluciones indican e! numero de pixeles en línea horizontal contra el
numero de pixeles en Xnea vertical con lo cual se puede definir un sistema de coordenadas
{X,Y}. Suponiendo que el espacio tridimensional esta formado por el sistema de
coordenadas (X,Y,Z}, definiendo la profundidad como 2 :y haciendo coincidir X & Y del
espacio tridimensional con el X & Y de las coordenadas de la pantalla, entonces, la
visualización de objetos tridimensionales en una pantalla de video será por ia proyección de
los mismos en el plano (X,Y) al cual denominaremos como "Plano de Visión".
El método del Buffer Z es un planteamiento de grafkación de imagen en espacio
que utiliza un método común para detectar superficies visibles comparando las
profundidades de cada superficie en cada una de las posiciones de pixel en la pantalla o
plano de visión. La profundidad mínima o mas próxima de todos los planos que se
proyectan sobre el la posición de pixel analizado es almacenado en un arreglo rectangular
de! igual numero de pixeles de la superficie de visión; es este arreglo !!amado el buffer de
' profundidad o buffer z del cual deriva el nombre de! mt5todo. Es necesario entonces
procesar cada una de las superficies que forman los objetos en una escena.
Procedimiento:
Las escenas en la pantalla están formadas por los objetos que se grafican, los
objetos están compuestos por superficies planas acotadas por los bordes del objeto. El
procedimiento apllcado en la graficación por Buffer Z consiste en reallzar un barrido sobre
todos los puntos de pixel en !a pantaila realizando las operaciones necesarias para
determinar si el pixel barrido esta contenido dentro de l a proyección ortogonal de la
superficie en !e plano de visión y en caso de estarlo determinar la profundidad de la
superficie en ese punto de pixel y compararla con valores almacenados de antemano en el
buffer (es necesario entonces que el buffer sea inicializado a. e! valor mas profundo de la
escena) y reemplazar el valor del buffer con el valor determinado de la profundidad del
plano si este equivale a un punto mas prcximo al plano de visión. Es requerido para este
proceso contar tambiCn con un buffer de color de igual tamaño al buffer de profundidad
para almacenar el valor del color de cada punto de pixel de la pantalla (este buffer también
deberá ser inicializado con e! color del fondo de la pantalla). .Al finalizar el proceso, el buffer
Z contendrá los puntos de profundidad visible para cada punto de pixel en el plano de
visión mientras que el buffer de color contendrá el valor del color de cada punto en el plano
de visión.

El proceso de irnplementación de método Buffer Z es el siguiente:
a) Generar los objetos mediante superficies (planos) con vértices coordenados en el
espacio tridimensional {X,Y,Z). Cada objeto deberá contener la información de numero de
vértices que componen cada una de sus superficies, las coordenadas de cada vértice, las
coordenadas del vector normal de la superficie, color primario del plano y color de la
frontera de la superficie.
b) Inicializar el buffer de profundidad al máximo valor de profundidad posible e inicializar el
buffer de color al color del fondo.
c) Suponiendo que la línea de rastreo barre los pixeles del plano de visión de izquierda a
derecha y de arriba hacia abajo. Se puede ver esta línea de rasrreo como una recta
horizontal sobre el plano {X,Y), es necesario para determinar (si existen) los puntos de
intersección de la línea de barrido con las líneas de los bordes de las proyecciones de l a s
superficies para comprobar si cierto punto de pixel sobre la línea de rastreo esta contenida
en la proyección de la superficie. Una manera sencilla de determinar los puntos de
interseccibn de la línea de rastreo con los bordes de las proyecciones de las superficies es
mediante el uso de triángulos equivalentes; Si cada borde de la proyección es una recta
que m es horizontal ni vertical y que se intersecta con la recta de la línea de rastreQ. es
posible formar dos triingulos rectángulos equivalentes tomando como base de un triángulo
la recta de la diferencia en X de los extremos del borde y la recta del la línea de rastreo.
dl En caso de que un punto de pixel sobre la línea de rasxeo se encuentre dentro de !a
proyección de una superficie se procede a calcular el ,valor de la profundidad de la
superficie en ese punto utilizando para ello la ecuación del plano:
Ax+By+Cz+D=O

9 contendrá
Supóngase que las coordenadas del vector normal de la superficie tratada son
(nx,ny,nz) y que un punto de la superficie en el espació tridimensional es (xl,yl,zl) se
tiene que:
nx(x - XI) + ny(y - yl) + nz(z -. zl) = O
m(x) + ny(y) + nz(z) + (-nx(xl)-ny(yl)-nz(zl)) = O
A=M B = ny c=nz
D = (-m(x1)-ny(yl)-nz(zl))
Donde x & y serán las coordenadas del punto de pixel en la proyección de la superficie.
e) Del valor de la profundidad del plano obtenido en el punto (de pixel tratado se compara
con el valor guardado de antemano en el buffer z. Si el nuevo valor es mas próximo al plano
de visión, el valor almacenado en el buffer z será reemplazado por este nuevo valor y en el
buffer de color será almacenado el color del punto de pixel que deberá tener para ese punto
de profundidad.
f) repetir el procedimiento desde el inciso (c) para cada una de las superficies que
componen la escena a graficar. AI finalizar el proceso con todas las superficies se tiene
almacenado en el buffer z todos los puntos de visión de una escena y el buffer de color
los colores de cada uno de los puntos de pixel de la escena.
g) Buffer z requiere ser del mismo tamaño rectangular que el numero de puntos de pixel en
la pantalla !o que significa tener la capacidad de memoria para. las operaciones, cantidad
que aumentara al aumentar la resolución de las escenas que se grafiquen, por ejemplo:
Para una resolución de 640x200 pixeles y suponiendo que se utilicen valores enteros de
profundidad en el buffer z se requieren 640x200~2 =256 kbytes de memoria para realizar las
operaciones mas 128 kbytes para el buffer de color suponiendo que tan solo se manejen
256 colores lo que suma un total de 384 kbytes de memoria necesaria para graficar la
escena. Esto conlleva a limitaciones de memoria base disponible por lo que se requiere
hacer uso de memoria extendida (si se dispone de ella) o bien dividir la escena en ventanas
de menor tamaño de
ventana por ventana.
tal manera que se pueda ajustar los buffers y realizar !a graficación

Librería Gráfica Buffer Z:
Como parte del proyecto, se genero un archivo de librería para graficación por
Buffer z denominado "GRAF-3D.H" el cual contiene las funciones para la graficación de
objetos tridimensionales generados de antemano por otras librerías.
Funciones para Usuario:
void Graf3D (Objeto3D *ob) < graf-3d. > h
Objetivo: Gráfica un objeto 3D con el método de Buffer 2:. debido a los requerimientos de
memoria del buffer z esta funcicin divide la escena en ventanas de 160x120 puntos de pixel
para 256 colores.
Parámetros: (Objeto3D *ob) apuntador a la estructura de objetos que contiene el apuntador
a la lista de planos del objeto, el apuntador a la tabla de puntos del objeto y el numero de
puntos en la tabla.
retorna: ningún valor.
Funciones Internas de la Libreria:
void Algoritmo buffer z (Plano3D *ob,Punto2D r)
void :Rango xy TPuntoTD *mn,PuntoZD *mx,Punto2D *ax,PuntoZD r.Plano3D *pg)
void Inicializa-buffers (void)
void -1nterseccion jint t,Plano3D *pg,Pint **pin,Punto2D r)
int &ntosInt (int t,Punto2D p1,PuntoZD p2,char *bn)
Punto3D Punto min (Plano3D *g)
Punto3D IPuntoImax (Plano3D *g)

Codino Principal del archivo GRAF-3D.H:
.............................................................. I
/********** UNIVERSIDAD AUTONOMA METROPOLITANA ************* I
/********** Unidad - lztapalapa ************* I
.............................................................. I
/'Proyecto terminal "GRAFICACION 3D" (Trim: 96-1 & 96-P)*/
/*Turbo C*/
/*LIBRERIA GRAF-3D.H'/
#include
#ir,clude
#include
#define pi 3.141592
#define K (1 7324.5)
#define XP ((r.x)*160)
#define YP ((r.y)*120)
typedef struct { /'Estructura de dos dimencione:j*/
int x,y;
} Punto2D;
typedef ?unto2D Delta;
struct intr {
int p;
char sec;
struct, intr *sig;
1;
typedef intr Pint;
void Graf3D (Objeto3D *ob);
void -Algoritmo-buffer-z (Plano3D *ob,Punto2D r);
float L;
int BUFFER-Z[160][120];
char BUFFER~COLOR[160][120];
void Graf3D (Objeto3D *ob)
{
int tl ,t2,xx.yy;
Punto2D tr;
xx=getmaxx ()+I ;yy=getmaxy ()+l;
L=xx/yy;
xx=xx/160;yy=yyI120;
for (t2=0;t2

*PROCEDIMIENTO BUFFER Z*/
void -Algoritmo-buffer-z (Plano3D *ob,Punto2D
{
Plano3D *pg;
Punto3D ptl;
Punto2D mn,mx,cb;
Pint *Inter,*den;
Delta ax;
float A,B,C,D,sx,sy;
int Z,tl ,tZ,xx,yy;
char bnl ,bn2,cl;
xx=getmaxx ();yy=getrnaxy ();
r)
setviewport (XP,YP,XP+159,YP+I 19,l); /*venmtana de buffer*/
- Inicializa-buffers ();
pg =o b;
if (ob==NULL) return:
/*inicializa buffers*/
for (;pg!=NULL;) { /*planos del objeto*/
- Rango-xy (&mn,&mx,&ax,r,pg);
if ((mn.xsec;
if (tl ==den->p) {
bn2=1;
Cl=pg->Cb;
I
if ((t2==ax.x)ll(t2==ax.y)) cl=pg->cb;
den=den->sig;
1
if (bn2!=0) {
if (pg->Normal.z!=O) {
Sx=(tl-320+XP)/(K*L);
sy=240-t2-YP;
if (bnl ==O) { /*determina ecuacion del plano*/
A=pg->Normal.x;
B=pg->Normal.y;
C=pg->Normal.z;
D=(-A*(pg->pt[O]->~))+(-B*(pg->pt[O]->y))
+(-C*(pg->pt[Dp"));
bnl =I;
1
Z=(int)((-(A*sx)-(B*sy)-D)/C); /*determina punto en el plano*/
/*else Z=Z-(A/C);*/
if (BUFFER_Z[tl][t2]

den=lnter;
for (;den!=NULL;) {
Inter=den->sig;
free(den);
den=lnter;
/*libera puntos de interseccion*i
I
1 I
pg=pg->liga;
1
/*siguiente plano*/
for (t2=0;t2x=(int)((K*L*rmin.x+318)-XP);
mx->x=(int)((K*L*rmax.x+322)-XP);
mn->y=(int)((240-rmax.y)-YP);
mx->y=(int)((240-rmin.y)-YP);
ax->x=mn->y;ax->y=mx->y;
if ((mn->x)x=O;
if ((mx->x)>l59) mx->x=l59;
if ((mn->y)y=O;
if ((mx->y)>ll9) mx->y=l19;
' 1
/*PROCEDIMIENTO PARA INICIALIZAR LOS BUFFERS*/
void -Inicializa-buffers (void)
{
int i,j,k;
for (i=O;ix;
m.y=g->pt[Opy;
m.z=g->pt[O]->z;
for (i=l;iNum);i++) {

if (m.x>(g->pt[i]->x)) m.x=g->pt[i]->x;
if (m.y>(g->pt[i]->y)) m.y=g->pt[i]->y;
if (m.z>(g->pt[i]->z)) m.z=g->pt[i]->z;
1
return (m);
1
/*PROCEDIMIENTO PARA DETERMINAR COORDENADAS MAXIMAS DE UN PLANO*/
Punto3D -Punto-max (Plano3D *g)
{ int i;
Punto3D m;
if (g==NULL) return (m);
m.x=g->pt[O]->x;
m.y=g->pt[O]->y;
m.z=g->pt[O]->z;
for (i=l;iNun);¡++) {
if (m.xpt[i]->x)) m.x=g->pt[i]->x;
if (m.ypt[i]->y)) m.y=g->pt[i]->y;
if (m.zpt[i]->z)) m.z=g->pt[i]->z;
1
return (m);
1
/*PROCEDIMIENTO PARA DEREMINAR PUNTOS DE INTERSECCION PLAN-SCANLINE*/
void -1nterseccion (int t,Plano3D *pg,Pint **pin,Punto2D r)
{
Pint *ipl ,*ip2;
Punto2D ptl ,pt2;
char bn;
int i,j,lnter;
for (i=O;iNum;i++) {
ptl .x=(int)((K*L*(pg->pt[i]->x)+320)-XP);
ptl .y=(int)((240-(pg->pt[i]->y))-YP);
pt2.~=(int)((K*L*(pg->pt[(i+l)%(pg->Num)]->x)+320)-XP);
pt2.y=(int)((240-(pg->pt[(i+l)%(pg->Num)]->y))-YP);
Inter=-Puntoslnt (t,ptl ,pt2,&bn);
if (bn==O) {
ipl =(Pint*)malloc(sizeof(Pint));
if (ipl ==NULL) exit (O);
ipl->p=lnter;
ipl->sig=*pin;
*pin=ipl;
}
1
ipl =*pin;
¡=I;
for (;ipl!=NULL;) {
ip2=ipl;
for (;ip2!=NULL;) {
if ((ipl->p)>(ip2->p)) {
Inter=ipl ->p;
ipl ->p=ip2->p;
ip2->p=lnter;
1
ip2=ip2->sig;
I

if (ipl ==*pin) j=ipl ->p:
if (j==ipl->p) ¡=I;
ipl->sec=i;
i=(++i)%2:
if (ipl->sig==NULL) ipl->sec=O;
ipl =ipl->sig;
I
1
/*PROCEDIMIENTO PARA CALCULO DE INTERSECCION DE RECTAS*/
int -Puntoslnt (int t,Punto2D pl ,Punto2D p2,char *bn)
{
float Deter,A,B,a,b;
int In;
if (((t=p2.y))ll((t=pl .y))) {
A=(float)((p2.~)-(pl .x));
B=(float)((pl .y)-(p2.y));
b=(float)(t-(p2.y));
if @!=O) {
a=(b*NB);
In=(int)((p2.x)-a);
*bn=O;
I
else {
*bn=l :
In=O;
else {
*bn=l ;
In=O;
}
return (In);
' 1

Administración de la memoria
En la actualidad una computadora PC moderna esta equipada con al menos 4 MBytes de memoria
principal, habitualmente con un tiempo de acceso de 70 ns o mejor. IBajo DOS sólo se pueden emplear 640
KBytes de esta memoria en forma directa. Estos 640 KB pueden no ser suficientes para algún programa en
particular. por Io que resulta de especial interés el poder emplear el resto de la memoria.
Memoria Extendida ( XMS )
El estándar XMS fue desarrollado por las compañías Microsoft Lotus e Intel. En su creación también
participo la empresa AST Research. Las funciones del XMS se poner! a disposición por un controlador XMS,
que se coloca en el vector de interrupcrón 2Fh.
Las funciones del controlador no se direcclonan mediante una interrupción, sino como Far Call. Para
obtener la dirección del controlador ha de comprobar primero si hay instalado un controlador XMS. Esto Io puede
hacer llamando a la interrupción 2Fh con el valor 4300h en el registro AX. Si se devuelve el valor 80h en el
registro AL, el controlador está instalado. En este caso la interrupción se ha de llamar de nuevo, con el valor
4310h en el regrstro A X. Se obtiene la dirección del segmento del controlador en el registro ES y la dirección del
offset del XMM ( extended Memory Manager ) en el registro BX.
Cuando haya obtenido la dirección del XMM, puede llamar a sus funciones mediante un Far Call. Si la
función se pudo procesar con éxito, habitualmente devuelve el código de estado O001 h en AX. En caso contrario
el registro BL contendrá un código de error. Los códigos de error tiene el siguiente significado:
80
81
82
8E
8F
90
91
92
93
94
A0
AI
A2
A3
A4
A5
A6
A7
A8
A9
AA
AB
AC
AD
BO
B1
B2
Función Desconocida
VDISK-Ramdisk encontrado
Error en la linea de direcciones A20
Error general de controlador
Error irrecuperable
HMA no presente
HMA ya asignado
Tamaño especificado de DX demasiado pequeño
HMA no alojada
Linea de direcciones A20 aún activa
No queda XMS disponible
Todos los handles XMS ocupados
Handle no válido
Handle fuente no válido
Offset fuente no válido
Handle destino no válido
Offset destino no válido
Longitud incorrecta para función MO\. *.
Solapado incorrecto en función MOVE
Parity-Error
UMB no bloqueado
UMB aún bloqueado
Rebase del controlador de bloqueo UMB
UMB no se puede bloquear
UMB disponible es más pequeño
No hay UMB disponible
Dirección del segmento UMB incorrecta

La programación XMS
El número de función de la funciones del XMM se pasa siempre en el registro AH. A continuación se listan
algunas de las funciones básicas que ofrece el XMM.
FunciónOOh Obtener número de versión
Entrada AH = OOh
Salida AX = numero de versión XMS
BX = numero de revisión interno
DX = Estado de la HMA
Con esta función puede averiguar el número de versión del controlador. si en el estado HMA se encuentra
el valor 1, la HMA está disponible, de lo contrario no se permite el acceso a la misma.
Función03h Activar A20 globalmente
Entrada AH = 03h
Salida BL = código de error
Si quiere emplear la HMA en el modo real de forma fiable, ha de llamar esta función antes o después de
la petición de la HMA. Recuerde cerrar la linea de direcciones antles de finalizar su programa, para evitar
rebases de segmento en los programas subsiguientes.
Función04h Cerrar A20 globalmente
Entrada AH = 04h
Salida BL = código de error
FunciÓnOSh Activar A20 localmente
Entrada AH = 05h
Salida BL = código de error
Mkdiante esta función de activa la línea de direcciones A20. Es' decir que sólo se activa si la función no
habia sido llamada con anterioridad. Esta comprobación se realiza mlediante un contador de llamadas, que es
incrementado por la función 05h y decrementado por la función 06h.
FunciÓnOGh Desactivar A20 localmente
Entrada AH = 06h
Salida BL = código de error
Función07h Obtener estado de A20
Entrada AH = 07h
Salida AX = estado de la linea de direcciones
BL = código de error
Si A20 está libre, obtiene el valor O001 h en A X , de 10 contrario será 0000h.
Función08h Obtener XMS libre
Entrada AH = 08h
Salida AX = longitud del mayor bloque libre
DX = tamaño total del XMS en KBytes
BL = código de error
Con esta función puede averiguar la memoria XMS libre. Pero atención, los valores devueltos siempre
mlden 64 KBytes de más, ya que tamblén se cuenta la HMA, que tambien mide 64 KBytes.

FunciÓnOSh Alojar bloque en la memoria extendida
Entrada AH = 09h
DX = Tamaño del bloque en KBytes
Salida DX = Handle para el acceso al bloque
BL = código de error
Esta función reserva un bloque de memoria extendida ( EMB ). El alojamiento sólo funciona si aún queda
libre un bloque del tamaño suficiente en la XMS. El bloque ocupado se puede direccionar a través del Handle
devueito.
FunciónOAh Liberar bloque de memoria extendida
Entrada AH = OAh DX = Handle para el acceso al bloque
Salida BL = código de error
Mediante esta función vuelve a liberar un EMB alojado. Después de la llamada el Handle queda como no
válido, y los datos están permanentemente borrados.
FunciónOBh Copiar memoria
Entrada AH = OBh
DS = Segmento de la estructura de copia
SI = Offset de la estructura de copia
Salida BL = código de error
Con esta función puede copiar memoria a/de la XMS. Ya que los registros no son suficientes para guardar
todos los datos, la func 5n emplea una estructura de copia. La estructura tiene la siguiente forma:
Offset Función Tipo de datos
OOh Longitud del bloque a copiar 1 Dword
04h Handle bloque del fuente 1 Word
36h Offset el en bloque fuente 1 Dword
OAh Handle del bloque destino 1 Word
OCh Offset en el bloque destino 1 Dword
Cuando se presenta el solapado de las zonas, la zona fuente ha de estar antes de la zona destino, sino no
se garantiza un funcionamiento perfecto. Para permitir una copia rápida, debería comenzar sus zonas de
memoria en una dirección divisible entre cuatro.
FunciónOCh Bloquear EMB contra desplazamiento
Entrada AH = OCh
DX = Handle
Salida DX:BX = Dirección lineal de 32 bits
BL = código de error
Para que no se creen agujeros en la XMS, el XMM, si es necesario, desplaza algunos bloques de
memoria. Para asegurar un bloque contra el desplazamiento, Io que puede ser interesante SI se quiere acceder
directamente a la memoria, se emplea esta función. Como resultado st?. obtiene en DX:BX la dirección lineal bajo
la cual puede direccionar la memoria.
FunciónODh Desbloquear EMB asegurado
Entrada AH = ODh
DX = Handle
Salida BL = código de error

FunciónOEh Obtener información sobre el EMB
Entrada AH = OEh
DX = Handle
Salida DX = Longitud del bloque
Mediante estas funciones se pueden obtener tanto informaciones sobre el bloque de memoria, como
determinar el número de handles XMS libres. Si la función ha trabajada sin errores, en AX se puede encontrar el
valor 0001h. En este caso se encuentra en BH el contador de bloqueo del EMB. El contador se incrementa con
cada llamada a la función OCh y se decrementa con cada llamada a la función ODh. Si el valor de BH es mayor
de O, ha de llamar a la función ODh BH veces, para liberar el bloque. En BL se encuentra la cantidad de handles
XMS libres. Tenga en cuenta que es mejor ocupar bloques de memoria lo más grande posibles, ya que el
número de handles es limitado.
FunciónOFh Modificar tamaño del EMB
Entrada AH = OFh
BX = Nuevo tamaño del EMB
DX = Handle
Salida BL = código de error

Utilización de las rutinas XMM.H
El archivo XMM.H contiene la declaración de una clase llamada vfp (very far pointer) por medio del cual se
tendrá acceso a la memoria extendida, esta clase representa un tipo de dato puntero a memoria extendida.
Declarando objetos de esta clase el usuario puede almacenar sus datos en la XMS. Las funciones miembro de
esta clase son algunas de las mencionadas anteriormente, como por ejemplo, verificar la existencia de un
controlador XMM, reservar memoria extendida, liberar memoria extendida, copiar de memoria convencional a
extendida, de XMS a memoria convencional, etc.
Estas rutinas se podrán compilar y generar código ejecutable utilizando un compilador C++ que contenga
el uso de 'templates', por ejemplo "Borland C++ 3.0" o superior. A continuación se muestra la manera de
declarar un objeto vfp, asignar valores, leer valores, etc.
Declaración de objetos vfp
#include "XMM.H"
Declaración de un solo elemento
Declarar un solo elemento vfp se logra con la siguiente sintaxis:
vfp nombre-del-puntero;
donde Tipo-de-dato se refiere a un tipo de dato predefinido $ 0 bien a un tipo de dato definido por el
usuario, y nombre-del-puntero es la variable con la cual se puede hacer referencia al dato que se guarda en
memoria extendida.
Por ejemplo el segmento de programa siguiente declara un entero apuntado por puntero-a-entero, y una
estructura de tipo punto apuntada por puntero-a-mi-estructura, ambos datos el entero y la estructura se
guardaran en memoria extendida:
#include "XMh1.H"
typedef struct {
int x;
int y;
int z;
} punto;
void main()
{
vfp puntero-a-entero;
vfp puntero-a-mi-estructura;
...
1
La manera de referirnos a este elemento es por medio del nombre del puntero vfp, por ejemplo:
puntero-a-entero = 10;

Asigna el número 10 al elemento de tipo entero apuntado por puntero-a-entero. Otra manera de guardar
este dato es con la siguiente Instrucclón:
puntero-a-entero[O] = 1 O;
Dado que puntero-a-entero apunta a un solo elemento de tipo int, es como si se tratara de un arreglo
lineal de una casilla, por lo cual sus indices permitidos van de [O - (numero-de-casillas - I)], en este caso el
indice [O] es válido ya que es el indice inicial y también final del arreglo de 1 casilla. Si se hiciera referencia al
indice [I], esto provocaría un error.
Declaración de arreglo lineales
Para indicar al compilador que deseamos un arreglo lineal de elemento de tipo Tipo-de-dato, utilizamos
paréntesis seguido del nombre-del-puntero con la siguiente sintaxis:
vfp nombre-del-puntero(cuantos)
En este caso cuantos indica al compilador la cantidad de elementos de tipo Tipo-de-dato que se
guardarán en XMS y serán referenciados por nombre-de-puntero. Por ejemplo
#include "XMM.H"
typedef struct {
char nombre[30];
char dirección[50];
} registro;
void main()
{
vfp arreglo( 1000); // Arreglo de 1 O00 float's
vfp datos(300); //Arreglo de 300 registros
Hacemos una referencia a un elemento en particular del arreglo por medio de los indices encerrados entre
corchetes [I, por ejemplo:
arreglo[ 1001 = 12345.6789;
Guarda en la localidad 100 el número 12345 6789. Recordemos que en este caso los indices válidos van
de [O-9991, por Io que la siguiente instrucción causaria un error:
arreglo[1000] = 12345.6789; /I Error no hay casilla 1000

Declaración de arreqlos bidimensionales ( matrices)
vfp nombre_de_puntero(num-de-columnas,num_de-renglones)~
donde num-de-columnas es en numero de columnas de la matriz, y num-de-renglones es el numero de
renglones.
Por ejemplo:
#include "XMM.H"
void main()
{ vfp VIDEO_VGA(640,480); // Matriz de enteros de 640 x 480
vfp b( 1000,2000); // Matriz de float's de 1 O00 x 2000
...
1
Para accesar alguna de las casillas de la matriz debemos especificar la columna y el renglón entre
paréntesis, esto seguido del nombre-del-puntero, por ejemplo:
a(10,15) = 33;
guarda el número 33 en la casilla ubicada en la columna 10 y en el renglón 15. Para el caso de la matriz
'VIDEO-VGA los indices permitidos son [O-6391 y de [O4791 para las columnas y los renglones
respectivamente.
Operaciones permitidas sobre punteros vfp
Dadas las siguientes declaraciones de punteros vfp:
(a) vfp mi-char;
(b) vfp mi-arreglo-de-chars(4);
(c) vfp mi-matriz-de-chars(3,3)
En el caso de un solo elemento no tiene sentido incrementar o decrementar el puntero. pero en los otros
dos casos es posible no solo incrementar o decrementar al puntero vfp sino que también es posible sumar y
restar cierto desplazamiento al puntero a la colección de datos. Las siguientes instrucciones son válidas:
mi-arreglo-de-chars++;
++mi-arreglo-de-chars;
mi-arreglo-de-chars + 1 O;
mi-matriz-de-chars--;
--mi-matriz-de-chars;
mi-matriz-de-chars - 2;
Fixordemos que los indices para un arreglo lineal de 10 elemento por ejemplo, van de O - 9, por lo que
una referencia al 10 elemento causará un error que detendrá el programa y enviara un mensaje indicando el tipo
de error.

La función miembro actual() de la clase vfp
En la declaración de la clase vfp se ha incluido una función miembro llamada actual(), esta función se
emplea especialmente en la lectura de elementos apuntados por objetos vfp. Esta función es útil cuando
desconocemos el índice del arreglo en memoria o de la matriz utilizada, esto pudiera ocurrir después de emplear
las operadores ++ o -- por Io que el programador pudiera perder el índilce 'actual'. A continuación se muestra el
uso de esta función:
#include "XMM.H"
typedef struct {
int Re;
int Im;
} complejo;
void main()
c
int real, imaginaria;
vfp a( 100); /I Arreglo de 100 números complejos
a.malloc-vfp();
a++;
a + 33;
++a;
a - 12;
I/ Reservamos memoria
real = a.actual().Re; I/ Parte real del incide actual
Imaginaria = a.actual().lm; // Pzrte imaginaria del índice actual
a.free-vfp();
...
}
I/ Liberamos memoria
Observe como al punteo 'a' ha sido afectado por operaciones de incremento y adición, por lo que resulta
ittil tomar el contenido del índice actual sin importar cual sea éste.

A continuación se presenta el listado completo del archivo XMM.H:
Proyecto en la ingenieria Electronica II
Asesor: M. en C. Miguel Angel Pizaña Lopez
Alumno: Carlos Arias Mendoza
* ******* Librerias para el uso de memoria extendida **"****
I**********U**************~~****H***** I
#include
#include
#include

static struct copia {
unsigned long size;
unsigned int Handle-Fuente:
unsigned long Offset-Fuente;
unsigned int Handle-Destino;
unsigned long Offset-Destino;
} x;
/**************t*************************************************************
.............................................................................
template
class vfp
{
public:
VfPO;
vfp(unsigned int valor);
vfp(unsigned int renglon,unsigned int columna);
vfpcT> operator=(T info);
T& operator=(vfp);
vfp operator++(int);
vfp operator++();
vfp operator--(kt);
vfpcT> operator--();
vfpcT> operator+(unsigned int incremento);
vfp operator-(unsigned int decremento);
T& operator[](unsigned int finger):
T& operator()(unsigned int renglon,unsigned int columna);
T& actual();
unsigned int XPAS-Libre();
unsigned int malloc-vfp();
void free-vfpo;
void Error(unsigned char code):
private:
unsigned int Check-for-XMS();
void (far *X")();
T *buffer;
unsigned int Presente-XMM;
unsigned int XMS-handle;
unsigned int indice;
unsigned int buffer-size;
unsigned int size-of-type;
unsigned int indice-izq;
unsigned int indice-der;
unsigned int num-renglones;
unsigned int num-columnas;
unsigned int extend-izq;
unsigned int extend-der;
unsigned long limite;
unsigned long size-of-block;
1; .............................................................................
I
/
I

..............................................................................
I
template vfp.:vfp()
{
if ( Check-for-XMS() )
Presente-XMM = 1;
size-of-type = sizeof(T);
size-of-block = 1:
buffer-size = buffer-tamkize-of-type;
indice = O;
indice-izq = O;
indice-der = buffer-size - 1;
extend-izq = 1:
extend-der = buffer-tam;
limite = O;
buffer = (T *)calloc(buffer-size,size-of-type);
I
..............................................................................
I
..............................................................................
I
template vfp::vfp(unsigned int valor)
{
if ( Check-for-XMS() )
Presente-XMM = 1;
size-of-type = sizeof(T);
size-of-block = valor;
buffer-size = buffer-tamlsize-of-type;
indice = O:
indice-izq = O;
indice-der = buffer-size - 1;
extend-izq = 1;
extend-der = buffer-tam;
limite = valor - 1;
buffer = (T *)calloc(buffer-size,size-of-type);
Y
................................................................................. I
..............................................................................
I
template vfp::vfp(unsigned int renglon,unsigned int columna)
{
if ( Check-for-XMS() )
Presente-XMM = 1;
size-of-type = sizeof(T);
size-of-block = renglon*columna;
buffer-size = buffer-tam/size-of-type;
indice = O;
indice-izq = O;
indice-der = buffer-size - 1;
num-renglones = renglon;
num-columnas = columna;
extend-izq = 1;
extend-der = buffer-tam;
limite = (renglon * columna) - 1;
buffer = (T *)calloc(buffer-size,size-of-type);
1
.............................................................................
I

template vfp vfp::operator=(T info)
{
buffer[indice] = info;
return(*this);
I
.............................................................................
.............................................................................
template T& vfp::actual()
{
return(buffer[indice]);
I
.............................................................................
template vfp vfp::operator++(int)
{
int new-index;
new-index = indice;
new-index++;
if ( new-index = O )
indice--;
else
Error(Ox71);
return(*this);
.............................................................................
I
I
I
I

eturn(*this);
template vfp vfp::operator+(unslgned int incremento)
{
int new-index;
new-index = indice + incremento;
if ( new-index = O )
indice = new-index;
else
Error(Ox71);
return(*this);
}
.............................................................................
I
.............................................................................
I
template T& vfp::operator[](unsigned int finger)
{
unsigned int indice-temporal;
indice-temporal = finger:
indice-temporal %= buffer-size ;
if ( finger > limite )
Error(Ox71);
if ( finger >= Indice-izq && finger

indice-temporal *= buffer-size;
indice-izq = indice-temporal;
indice-der = indice-izq + buffer-size - 1 ;
copy-XMS-to-RAM(XMM, 1024.buffer,XMS-handle,extend-1zc~);
1
return(buffer[indice-temporal]);
I
.............................................................................
I
.............................................................................
I
template = num-renglones )
Error(Ox72);
if ( columna >= num-columnas )
Error(Ox73);
finger = indice-temporal = reng1on*num~co1umnas + columna;
if ( finger > limite )
Error(Ox71);
indice-temporal %= buffer-size ;
if ( finger >= indice-izq && finger

mascara = reg.r-es;
mascara = mascara

if ( Presente-XMM )
{
tipo = size-of-type:
bloque = size-of-block;
bytes = tipo * bloque;
if ( bytes ::free-vfp()
I ’
unsigned char code;
unsigned int code-error;
unsigned int result;
- AX = OxOA00;
- DX = XMS-handle;
(*XMM)O;
result = - A X ;
code-error = -BX;
if ( result == 1 )
return:
else
{ code = (unsigned char)code-error;
Error(code);
I
1
............................................................................. I
I

.............................................................................
I
template void vfp.:Error(unsigned char code)
{
switch(code)
{
case 0x70 : printf(error-70h);break;
case 0x71 : printf(error-71 h);break;
case 0x72 : printf(error-72h);break;
case 0x73 : printf(error-73h);break;
case 0x80 : printf(error-80h);break;
case 0x81 : printf(error-81 h);break;
case 0x82 : printf(error-82h);break;
case Ox8E : printf(error-8Eh);break;
case Ox8F : printf(error-8Fh);break;
case Ox90 : printf(error-90h);break;
case Ox91 : printf(error-91 h);break;
case 0x92 : printf(error_92h),break;
case 0x93 : prmtf(error-93h);break;
case 0x94 : printf(error-94h);break;
case OxAO : printf(error-A0h);break;
case OxAl : printf(error-Al h);break;
case OxA2 : printf(error-A2h);break;
case OxA3 : printf(error-A3h);break;
case OxA4 : printf(error-A4h);break;
case OxA5 : printf(error-A5h);break;
case OxA6 : printf(error-A6h);break;
case OxA7.: ~rintf(error~A7h);break;
case OxA8 : printf(error-A8h);break;
case OxA9 : printf(error-Agh);break;
case OxAA : printf(error-AAh);break;
case OxAB : printf(error-ABh);break;
case OxAC : printf(error-ACh);break;
case OxAD : printf(error-ADh);break;
case OxBO : printf(error-B0h);break;
case OxBl : printfferror-B1 h);break;
case OxB2 1 printf(error-B2h):break;
I
exit(0);
1
.............................................................................
I
...............................................................................
I
unsigned int copy-RAM-to-XMS(void (far *ptr)(),unsigned long bytes,void far
*fuente - offset,unsigned int handle,unsigned long desplazamiento)
{
unsigned char code;
unsigned int code-error;
unsigned int result;
void (far *manejador-X")();
manejador-XMM = ptr;
X.size = bytes;
X.Handle-Fuente = O; I* O = RAM *I
X.Offset-Fuente = (unsigned 1ong)fuente-offset;
X.Handle-Destino = handle;
X.Offset-Destino = desplazamiento;

- SI = FP-OFF(&X);
- DS = FP-SEG(&X);
- AX = OxOBOO;
(*rnanejador"XMM)();
result = - A X ;
code-error = -BX;
if ( result == 1 )
return( 1);
else
{
code = (unsigned char)code-error;
cprintf('lr\n\a Error! (%X) No se pudo realizar la copia de RAM a XMS ...", code);
1
return(0);
1 ............................................................................. I
............................................................................. I
unsigned int copy-XMS-to-RAM(void (far *ptr)(),unsigned long bytes,void far
*fuente-offset,unsigned int handle,unsigned long desplazamiento)
{
unsigned char code;
unsigned int code-error;
unsigned int result;
void (far *manejador-X")();
qanejador-XMM = ptr;
X.size = bytes;
X.Handle-Fuente = handle;
X.Offset-Fuente = desplazamiento;
X.Handlz-Destino = O; I* O RAM *I
X.Offset-Destino = (unsigned 1ong)fuente-offset;
- SI = FP-OFF(&X);
- DS = FP-SEG(&X);
- AX = OxOB00;
(*manejador-X")();
result = - A X ;
code-error = -BX;
if ( result == 1 )
{
return(1);
I
else
{
code = (unsigned char)code-error;
cprintf("\r\n\a Error! (%X) No se pudo realizar la copia de XMS a RAM...",code);
1
return(0);
I

Bibliografia
Borland C++ Handbook
Chris H. Pappas &William H. Murray Ill
Editorial McGraw Hill
Graficas por Computadora
Segunda Edición
Donald Hearn & M. Pauline Baker
Editorial Prentice Hall
Gráficos Animados por Computadora
David Fox & Mitchell Waite
Editorial McGraw Hill