API tools faq
paste
Advertisement
abraao

CPp

abraao
Jul 21st, 2015
205
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.00 KB | None | 0 0
raw download clone embed print report
  1.  
  2. #include "main.h"
  3. #include "Matrix.h"
  4. #include "Vertice.h"
  5. #include <stdio.h>
  6. #include "objLoader.h"
  7. using namespace std;
  8. // Ponteiro para o objeto que carregará o modelo 3D (formato OBJ).
  9. objLoader *objData;
  10.  
  11. Vertice V1[4];
  12.  
  13. /// home/abraao/Documentos/trabalho-CG/trabalho2/monkey_head2.obj
  14. //-----------------------------------------------------------------------------
  15. void MyGlDraw(void)
  16. {
  17.  
  18.  
  19.  
  20. Vertice V2[objData->faceCount][3];
  21.  
  22.  
  23. for(int i=0; i < objData->faceCount; i++){
  24.  
  25. obj_face* obj = objData->faceList[i];
  26.  
  27. for(int j=0; j < 3; j++){
  28. V2[i][j].m_V[0] = objData->vertexList[obj->vertex_index[j]]->e[0];
  29. V2[i][j].m_V[1] = objData->vertexList[obj->vertex_index[j]]->e[1];
  30. V2[i][j].m_V[2] = objData->vertexList[obj->vertex_index[j]]->e[2];
  31. V2[i][j].m_V[3] = 1;
  32. }
  33. }
  34.  
  35. //****************************************************************************************
  36.  
  37. Vertice V1[4];
  38.  
  39. V1[0].m_V[0] = 100; V1[1].m_V[0] = 200; V1[2].m_V[0] = 100; V1[3].m_V[0] = 200;
  40. V1[0].m_V[1] = 100; V1[1].m_V[1] = 100; V1[2].m_V[1] = 200; V1[3].m_V[1] = 200;
  41. V1[0].m_V[2] = 0; V1[1].m_V[2] = 0; V1[2].m_V[2] = 0; V1[3].m_V[2] = 0;
  42. V1[0].m_V[3] = 1; V1[1].m_V[3] = 1; V1[2].m_V[3] = 1; V1[3].m_V[3] = 1;
  43.  
  44.  
  45.  
  46.  
  47. //*******************************************************************************************************
  48. //*******************************************************************************************************
  49.  
  50.  
  51. //Matriz model******************************************
  52. Matrix m_Model, m_Identidade, m_Translacao, m_Escala;
  53.  
  54.  
  55. m_Identidade.m_M[0][0] = 1; m_Identidade.m_M[0][1] = 0; m_Identidade.m_M[0][2] = 0; m_Identidade.m_M[0][3] = 0;
  56. m_Identidade.m_M[1][0] = 0; m_Identidade.m_M[1][1] = 1; m_Identidade.m_M[1][2] = 0; m_Identidade.m_M[1][3] = 0;
  57. m_Identidade.m_M[2][0] = 0; m_Identidade.m_M[2][1] = 0; m_Identidade.m_M[2][2] = 1; m_Identidade.m_M[2][3] = 0;
  58. m_Identidade.m_M[3][0] = 0; m_Identidade.m_M[3][1] = 0; m_Identidade.m_M[3][2] = 0; m_Identidade.m_M[3][3] = 1;
  59.  
  60.  
  61. m_Translacao.m_M[0][0] = 1; m_Translacao.m_M[0][1] = 0; m_Translacao.m_M[0][2] = 0; m_Translacao.m_M[0][3] = 0;
  62. m_Translacao.m_M[1][0] = 0; m_Translacao.m_M[1][1] = 1; m_Translacao.m_M[1][2] = 0; m_Translacao.m_M[1][3] = 0;
  63. m_Translacao.m_M[2][0] = 0; m_Translacao.m_M[2][1] = 0; m_Translacao.m_M[2][2] = 1; m_Translacao.m_M[2][3] = 0;
  64. m_Translacao.m_M[3][0] = 0; m_Translacao.m_M[3][1] = 0; m_Translacao.m_M[3][2] = 0; m_Translacao.m_M[3][3] = 1;
  65.  
  66.  
  67. m_Escala.m_M[0][0] = 2; m_Escala.m_M[0][1] = 0; m_Escala.m_M[0][2] = 0; m_Escala.m_M[0][3] = 0;
  68. m_Escala.m_M[1][0] = 0; m_Escala.m_M[1][1] = 2; m_Escala.m_M[1][2] = 0; m_Escala.m_M[1][3] = 0;
  69. m_Escala.m_M[2][0] = 0; m_Escala.m_M[2][1] = 0; m_Escala.m_M[2][2] = 2; m_Escala.m_M[2][3] = 0;
  70. m_Escala.m_M[3][0] = 0; m_Escala.m_M[3][1] = 0; m_Escala.m_M[3][2] = 0; m_Escala.m_M[3][3] = 1;
  71.  
  72.  
  73. m_Model = m_Escala * m_Translacao;// * m_Escala * m_Translacao;
  74.  
  75.  
  76. //*******************************************************************************************************
  77. //*******************************************************************************************************
  78.  
  79. //M_view9procurar)
  80.  
  81. //Camera***********************************
  82. Vertice cam_Posicao(0, 0, 5);
  83. Vertice cam_LookAt(0, 0, 0);
  84. Vertice cam_Up(0, 1, 0);
  85.  
  86.  
  87. Vertice cam_Z = (cam_Posicao - cam_LookAt) / cam_Z.normaVetor(cam_Posicao - cam_LookAt);
  88. Vertice cam_X = cam_X.prodVetorial(cam_Up, cam_Z) / cam_X.normaVetor( cam_X.prodVetorial(cam_Up, cam_Z) );
  89. Vertice cam_Y = cam_Y.prodVetorial(cam_Z, cam_X) / cam_Y.normaVetor(cam_Y.prodVetorial(cam_Z, cam_X));
  90.  
  91.  
  92.  
  93.  
  94. //*******************************************************************************************************
  95. //*******************************************************************************************************
  96.  
  97.  
  98. //Matriz view***********
  99.  
  100. Matrix m_View, m_Bt, m_trans;
  101.  
  102.  
  103. m_Bt.m_M[0][0] = cam_X.m_V[0]; m_Bt.m_M[0][1] = cam_X.m_V[1]; m_Bt.m_M[0][2] = cam_X.m_V[2]; m_Bt.m_M[0][3] = 0;
  104. m_Bt.m_M[1][0] = cam_Y.m_V[0]; m_Bt.m_M[1][1] = cam_Y.m_V[1]; m_Bt.m_M[1][2] = cam_Y.m_V[2]; m_Bt.m_M[1][3] = 0;
  105. m_Bt.m_M[2][0] = cam_Z.m_V[0]; m_Bt.m_M[2][1] = cam_Z.m_V[1]; m_Bt.m_M[2][2] = cam_Z.m_V[2]; m_Bt.m_M[2][3] = 0;
  106. m_Bt.m_M[3][0] = 0 ; m_Bt.m_M[3][1] = 0 ; m_Bt.m_M[3][2] = 0 ; m_Bt.m_M[3][3] = 1;
  107.  
  108.  
  109. m_trans.m_M[0][0] = 1; m_trans.m_M[0][1] = 0; m_trans.m_M[0][2] = 0; m_trans.m_M[0][3] = -cam_Posicao.m_V[0];
  110. m_trans.m_M[1][0] = 0; m_trans.m_M[1][1] = 1; m_trans.m_M[1][2] = 0; m_trans.m_M[1][3] = -cam_Posicao.m_V[1];
  111. m_trans.m_M[2][0] = 0; m_trans.m_M[2][1] = 0; m_trans.m_M[2][2] = 1; m_trans.m_M[2][3] = -cam_Posicao.m_V[2];
  112. m_trans.m_M[3][0] = 0; m_trans.m_M[3][1] = 0; m_trans.m_M[3][2] = 0; m_trans.m_M[3][3] = 1 ;
  113.  
  114.  
  115. m_View = m_Bt * m_trans ;
  116.  
  117.  
  118. //*******************************************************************************************************
  119. //*******************************************************************************************************
  120.  
  121. //Matriz modelView******************
  122. Matrix m_model_view = m_View * m_Model;
  123.  
  124. //*******************************************************************************************************
  125. //*******************************************************************************************************
  126.  
  127. //Matriz projection***************
  128.  
  129. Matrix m_Projecao;
  130.  
  131. double d = 2.2;
  132.  
  133. m_Projecao.m_M[0][0] = 1; m_Projecao.m_M[0][1] = 0; m_Projecao.m_M[0][2] = 0 ; m_Projecao.m_M[0][3] = 0;
  134. m_Projecao.m_M[1][0] = 0; m_Projecao.m_M[1][1] = 1; m_Projecao.m_M[1][2] = 0 ; m_Projecao.m_M[1][3] = 0;
  135. m_Projecao.m_M[2][0] = 0; m_Projecao.m_M[2][1] = 0; m_Projecao.m_M[2][2] = 1 ; m_Projecao.m_M[2][3] = d;
  136. m_Projecao.m_M[3][0] = 0; m_Projecao.m_M[3][1] = 0; m_Projecao.m_M[3][2] =-1/d; m_Projecao.m_M[3][3] = 0;
  137. //*******************************************************************************************************
  138. //*******************************************************************************************************
  139.  
  140. //Matriz modelViewProjection***********************
  141.  
  142. Matrix m_ModelViewProjection = m_Projecao * m_model_view;
  143.  
  144.  
  145. //*******************************************************************************************************
  146. //*******************************************************************************************************
  147.  
  148. Vertice Vtransformado[4];
  149. Vertice V_Transf2[objData->faceCount][3];
  150. for(int i=0; i < objData->faceCount; i++)
  151. { for(int j=0; j < 3; j++)
  152. {
  153. V_Transf2[i][j] = m_ModelViewProjection * V2[i][j];
  154. }
  155. }
  156.  
  157.  
  158.  
  159. //Homegeinizaçao*******************************
  160. Cor *cor = new Cor(255,255,255,0);
  161. Cor *cor1 = new Cor(255,255,255,0);
  162.  
  163. for(int i=0; i < objData->faceCount; i++)
  164. {
  165. for(int j=0; j < 3; j++)
  166. {
  167. V_Transf2[i][j] = V_Transf2[i][j] / V_Transf2[i][j].m_V[3];
  168. }
  169. }
  170.  
  171.  
  172. //-----------------------------------------------------------------------------
  173. // Funcao que imprime as coordenadas de um vertice.
  174. // Pode ser utilizada para fazer debug de código.
  175.  
  176.  
  177. //-----------------------------------------------------------------------------
  178. // Esta funcao apenas imprime informacoes referentes ao modelo que foi carregado,
  179. // tais como numero de vertices, normais, fontes de luz, etc.
  180.  
  181. //-----------------------------------------------------------------------------
  182. // Libera a memoria do objeto responsavel por guardar dados do modelo.
  183.  
  184. ////////////////////////////////////////////////////////////////////////////////////////////////////////////
  185. ////////////// Mapeando pontos do espaço na tela
  186.  
  187. Matrix mT, mS, mI, mG;
  188. int xMax = 2, xMin = -2, yMax = 2, yMin = -2;
  189.  
  190. mT.m_M[0][3] = ((IMAGE_WIDTH-1) / xMax - xMin);
  191. mT.m_M[1][3] = ((IMAGE_HEIGHT-1) / yMax - yMin);
  192.  
  193. mS.m_M[0][0] = ((IMAGE_WIDTH-1)/(xMax - xMin));
  194. mS.m_M[1][1] = ((IMAGE_HEIGHT-1)/(yMax - yMin));
  195.  
  196. mI.m_M[1][1] = -1;
  197.  
  198. mG = mT * mS * mI;
  199.  
  200. for(int i=0; i < objData->faceCount; i++)
  201. for(int j=0; j < 3; j++)
  202. V_Transf2[i][j] = mG * V_Transf2[i][j];
  203.  
  204.  
  205.  
  206. for(int i=0; i < objData->faceCount; i++)
  207. {
  208. for(int j=0; j < 3; j++)
  209. for(int k=0; k < 3; k++)
  210. {
  211. //cout << round(facesTransf[i][j].V[k]) << endl;
  212. //system("pause");
  213. V_Transf2[i][j].m_V[k] = round( V_Transf2[i][j].m_V[k]);
  214. //cout<< i << j << k <<endl;
  215. }
  216. DrawTriangle( &V_Transf2[i][0], &V_Transf2[i][1], &V_Transf2[i][2], cor,cor);
  217.  
  218. }
  219.  
  220. //**************************************************************************************************************
  221. //**************************************************************************************************************
  222. }
  223. //-----------------------------------------------------------------------------
  224. // Programa principal
  225. int main(int argc, char **argv)
  226. {
  227.  
  228. objData = new objLoader(); // cria o objeto que carrega o modelo
  229. objData->load("/home/abraao/Imagens/monkey_head2.obj"); // a carga do modelo é indicada atraves do nome do arquivo.
  230. // Neste caso, deve ser sempre do tipo OBJ.
  231.  
  232. // Habilite esta função se você deseja imprimir na tela dados do modelo
  233. // gerados durante a sua carga.
  234. //PrintModelInfo(objData);
  235.  
  236. InitOpenGL(&argc, argv);
  237. InitCallBacks();
  238. InitDataStructures();
  239.  
  240. DrawFunc = MyGlDraw;
  241.  
  242. // atexit(FreeMemFunc);
  243.  
  244. glutMainLoop();
  245.  
  246.  
  247. return 0;
  248. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!