CIV 2802 – Sistemas Gráficos para Engenharia – 2019.

1
Prof. Dr. Luiz Fernando Martha
6º trabalho – Programa para controle de visualização 3D
Implementação de transformações geométricas 3D em coordenadas homogêneas e de
mecanismos para controle de visualização com base em eixos da tela

Vinicius da Silva Costa Almada

Mat. 1913147
Mestrado em Engenharia de Estruturas
Pontifícia Universidade Católica do Rio

Rio de Janeiro – RJ
2019
Neste trabalho foi solicitado que o aluno completasse códigos faltantes nos arquivos
“t3d.cpp” e “glcanvas.cpp”.
No primeiro arquivo, referente ao cálculo das matrizes de transformações 3D, foi
detectado que os arrays de duas dimensões responsáveis por representar as matrizes
apresentavam valores diferentes quando não eram inicializados, para corrigir isso, estes
mesmos arrays foram inicializados com valor 0. Esta observação pode ser conferida
abaixo.
O trechos completados/editados do arquivo “t3d.cpp” foram os seguintes:

double scale[4][4] = { 0 };

/*** COMPLETE HERE - T3D: 01 ***/

scale[0][0] = sx;
scale[1][1] = sy;
scale[2][2] = sz;
scale[3][3] = 1.0;
/*** COMPLETE HERE - T3D: 01 ***/

double trans[4][4] = { 0 };

/*** COMPLETE HERE - T3D: 02 ***/

trans[0][3] = tx;
trans[1][3] = ty;
trans[2][3] = tz;
trans[0][0] = 1.0;
trans[1][1] = 1.0;
trans[2][2] = 1.0;
trans[3][3] = 1.0;
/*** COMPLETE HERE - T3D: 02 ***/

double rot[4][4] = { 0 };
/*** COMPLETE HERE - T3D: 03 ***/
rot[0][0] = v.getX()*v.getX() + cost*(1 - v.getX()*v.getX());
rot[0][1] = v.getX()*v.getY()*(1 - cost) - v.getZ()*sint;
rot[0][2] = v.getZ()*v.getX()*(1 - cost) + v.getY()*sint;
rot[1][0] = v.getX()*v.getY()*(1 - cost) + v.getZ()*sint;
rot[1][1] = v.getY()*v.getY() + cost*(1 - v.getY()*v.getY());
rot[1][2] = v.getY()*v.getZ()*(1 - cost) - v.getX()*sint;
rot[2][0] = v.getX()*v.getZ()*(1 - cost) - v.getY()*sint;
rot[2][1] = v.getY()*v.getZ()*(1 - cost) + v.getX()*sint;
rot[2][2] = v.getZ()*v.getZ() + cost*(1 - v.getZ()*v.getZ());
rot[3][3] = 1.0;
/*** COMPLETE HERE - T3D: 03 ***/

/* Translate to origin. */
/*** COMPLETE HERE - T3D: 04 ***/
translate(-px, -py, -pz);
/*** COMPLETE HERE - T3D: 04 ***/
/* Rotate about given vector direction. */
/*** COMPLETE HERE - T3D: 05 ***/
rotateVecOrg(angle, vx, vy, vz);
/*** COMPLETE HERE - T3D: 05 ***/

/* Translate back to original position. */

/*** COMPLETE HERE - T3D: 06 ***/
translate(px, py, pz);
/*** COMPLETE HERE - T3D: 06 ***/

double rot[4][4] = { 0 };

/*** COMPLETE HERE - T3D: 07 ***/

rot[0][0] = ux; rot[0][1] = uy; rot[0][2] = uz;
rot[1][0] = vx; rot[1][1] = vy; rot[1][2] = vz;
rot[2][0] = wx; rot[2][1] = wy; rot[2][2] = wz;
rot[3][3] = 1.0;
/*** COMPLETE HERE - T3D: 07 ***/

/* Define view vector (from ref to eye) and view up vector.*/

/*** COMPLETE HERE - T3D: 08 ***/
view = Point3d(refx, refy, refz) - Point3d(eyex, eyey, eyez);
upvec = Point3d(vupx, vupy, vupz);
/*** COMPLETE HERE - T3D: 08 ***/

/* Find the eye system unit vectors.*/

/*** COMPLETE HERE - T3D: 09 ***/
ze = normalize(view) * -1;
xe = normalize(crossprod(upvec, ze));
ye = crossprod(ze, xe);

/*** COMPLETE HERE - T3D: 09 ***/

/* Concatenate a translation of basis from origin to eye point.*/

/*** COMPLETE HERE - T3D: 10 ***/
translate(-eyex, -eyey, -eyez);
/*** COMPLETE HERE - T3D: 10 ***/

/* Concatenate a rotation of basis from world to eye system.*/

/*** COMPLETE HERE - T3D: 11 ***/
rotateBasis(
xe.getX(), xe.getY(), xe.getZ(),
ye.getX(), ye.getY(), ye.getZ(),
ze.getX(), ze.getY(), ze.getZ());
/*** COMPLETE HERE - T3D: 11 ***/

/* Define alpha and beta parameters from the front and back
* arguments.*/
/*** COMPLETE HERE - T3D: 12 ***/
alpha = -(back + front);
beta = -(back * front);
/*** COMPLETE HERE - T3D: 12 ***/
 double pers[4][4] = { 0 };
/* Create Perspective matrix.
*/
/*** COMPLETE HERE - T3D: 13 ***/
pers[0][0] = d; pers[1][1] = d;
pers[2][2] = -alpha;
pers[2][3] = -beta;
pers[3][2] = -1.0;
/*** COMPLETE HERE - T3D: 13 ***/

/* Concatenate a translation of basis from origin to center

* of view volume.
*/
/*** COMPLETE HERE - T3D: 14 ***/
tx = -(right + left) / 2;
ty = -(top + bottom) / 2;
tz = (back + front) / 2;
translate(tx, ty, tz);
/*** COMPLETE HERE - T3D: 14 ***/

/* Concatenate a scaling transformation that scales the view

* volume to a cube ranging from -1 to +1 in the 3 directions,
* also reverting the z-axis direction.
*/
/*** COMPLETE HERE - T3D: 15 ***/
sx = 2 / (right - left);
sy = 2 / (top - bottom);
sz = -2 / (back - front);
scale(sx, sy, sz);
/*** COMPLETE HERE - T3D: 15 ***/

Os trechos completados do arquivo “glcanvas.cpp” foram:

// Define view vector (from ref to eye) and view up vector.

/*** COMPLETE HERE - GLCANVAS: 01 ***/
view = Point3d(m_refx, m_refy, m_refz) - Point3d(m_eyex, m_eyey,
m_eyez);
upvec = Point3d(m_vupx, m_vupy, m_vupz);
/*** COMPLETE HERE - GLCANVAS: 01 ***/

// Find the eye system unit vectors.

/*** COMPLETE HERE - GLCANVAS: 02 ***/
m_ze = normalize(view) * -1;
m_xe = normalize(crossprod(upvec, m_ze));
m_ye = crossprod(m_ze, m_xe);

/*** COMPLETE HERE - GLCANVAS: 02 ***/

/*** COMPLETE HERE - GLCANVAS: 03 ***/

t3d.camera(m_eyex, m_eyey, m_eyez,
m_refx, m_refy, m_refz,
m_vupx, m_vupy, m_vupz);

/*** COMPLETE HERE - GLCANVAS: 03 ***/

 /*** COMPLETE HERE - GLCANVAS: 04 ***/
t3d.perspective(m_front, m_front, m_back);
/*** COMPLETE HERE - GLCANVAS: 04 ***/

// Place reference point at center of bounding box.

/*** COMPLETE HERE - GLCANVAS: 05 ***/
m_refx = (xmin + xmax)*0.5;
m_refy = (ymin + ymax)*0.5;
m_refz = (zmin + zmax)*0.5;
/*** COMPLETE HERE - GLCANVAS: 05 ***/

// Place camera with same (x,y) coordinates of reference point,

// distant 4 "max_sizes" to reference point in z direction
/*** COMPLETE HERE - GLCANVAS: 06 ***/
m_eyex = m_refx;
m_eyey = m_refy;
m_eyez = m_refz + 4.0*max_size;
/*** COMPLETE HERE - GLCANVAS: 06 ***/

// Define camera vertical plane perpendicular to xz plane.

/*** COMPLETE HERE - GLCANVAS: 07 ***/
m_vupx = 0.0;
m_vupy = 1.0;
m_vupz = 0.0;
/*** COMPLETE HERE - GLCANVAS: 07 ***/

/*** COMPLETE HERE - GLCANVAS: 08 ***/

if (ratio < 1.0)
view_window_w = view_window_h / ratio;
else
view_window_h = view_window_w * ratio;
/*** COMPLETE HERE - GLCANVAS: 08 ***/

// Define view volume parameters such that:

// (1) view window center coincides with canvas center;
// (2) front clip plane is located at 3 "max_sizes" from camera;
// (3) back clip plane is located at 5 "max_sizes" from camera.
/*** COMPLETE HERE - GLCANVAS: 09 ***/
m_left = -view_window_w * 0.5;
m_right = view_window_w * 0.5;
m_bottom = -view_window_h * 0.5;
m_top = view_window_h * 0.5;
m_front = 3.0 * max_size;
m_back = 5.0 * max_size;
/*** COMPLETE HERE - GLCANVAS: 09 ***/
 // Pan current eye window without changing any other view
paramater
/*** COMPLETE HERE - GLCANVAS: 10 ***/
m_left += _panX;
m_right += _panX;
m_bottom += _panY;
m_top += _panY;
/*** COMPLETE HERE - GLCANVAS: 10 ***/

/*** COMPLETE HERE - GLCANVAS: 11 ***/

t3d.rotateVecPnt(angle, m_xe.getX(), m_xe.getY(),
m_xe.getZ(), m_refx, m_refy, m_refz);
/*** COMPLETE HERE - GLCANVAS: 11 ***/

/*** COMPLETE HERE - GLCANVAS: 12 ***/

t3d.rotateVecOrg(angle, m_xe.getX(), m_xe.getY(), m_xe.getZ());
/*** COMPLETE HERE - GLCANVAS: 12 ***/

/*** COMPLETE HERE - GLCANVAS: 13 ***/

t3d.rotateVecPnt(angle, m_ye.getX(), m_ye.getY(), m_ye.getZ(),
m_refx, m_refy, m_refz);
/*** COMPLETE HERE - GLCANVAS: 13 ***/

/*** COMPLETE HERE - GLCANVAS: 14 ***/

t3d.rotateVecOrg(angle, m_ye.getX(), m_ye.getY(), m_ye.getZ());
/*** COMPLETE HERE - GLCANVAS: 14 ***/

/*** COMPLETE HERE - GLCANVAS: 15 ***/

t3d.rotateVecOrg(angle, m_ze.getX(), m_ze.getY(), m_ze.getZ());
/*** COMPLETE HERE - GLCANVAS: 15 ***/