开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
newrender.c
资源名称：VC＋＋中Opengl实现建筑物虚拟漫游.rar　[点击查看]
上传用户：zbjingming
上传日期：2010-01-02
资源大小：2436k
文件大小：15k
源码类别：

OpenGL

开发平台：

Visual C++

newrender.c：源码内容
  1. #include "radio.h"
  2. #include <string.h>
  3. #include "math.h"
  4. #include "image.h"
  5. #include <time.h>
  8. int gWinWidth, gWinHeigth;
  11. TEXTURE_2D     **gTextureList;
  12. OBJECT        *gObjectList; /* ObjectList[0]:isolated surfaces*/
  14. INT4S          gObjectNum; 
  15. int         gTexnum;
  16. float gEx = 40.0, gEy = 1.0, gEz = 45.0,
  17.    gCx = -5.0, gCy = 1.0, gCz = 5.0;
  18.  
  19. char           gEnergyFile[30];
  20. char        gImageName[30];
  22. double   gMatrixVP[16]; 
  23. double   gMatrixC1[16];
  24. double   gProject[16];
  25. double   gModelview[16];
  26. double   gViewport[16];
  28. void  ReadData()
  29. { 
  31.     int     i,j,l;
  32.     FILE    *fp;
  33.     char    stemp[100];
  34.     POINT   *plist; 
  35.     INT4U   nAllVertexNum; 
  36.     INT4U   *pchlist; 
  37.  
  38.     fp = fopen( gEnergyFile, "r" );
  39.     if ( fp == NULL ) 
  40.     {  
  41.           printf( "n Can not open energy data file:%s", gEnergyFile);
  42.           exit(0);
  43.     }   
  45.     fseek( fp, 0, SEEK_SET);
  46.     
  47.     /******  read texture list   ******/
  48.     fscanf( fp, "%s", stemp);
  49.     while( strcmp( stemp,"texnum" ) != 0)  fscanf( fp, "%s", stemp);
  50.     fscanf( fp, "%d", &gTexnum );
  52.     gTextureList = (TEXTURE_2D **)malloc( sizeof(TEXTURE_2D)*(gTexnum+1));
  53.     for(i=1; i<=gTexnum; i++)
  54.     {
  55. gTextureList[i] = (TEXTURE_2D *)malloc( sizeof(TEXTURE_2D));
  56. fscanf( fp, "%s%s", gTextureList[i]->fname, stemp );
  57. if ( strcmp( stemp,"REPEAT_TEXTURE" ) == 0)
  58.       gTextureList[i]->type = 1;
  59. else  if ( strcmp( stemp,"CLAMP_TEXTURE" ) == 0)
  60.           gTextureList[i]->type = 0;
  61.     }
  63.     /******   Read object list   ******/
  64.     fscanf( fp, "%s", stemp);
  65.     while( strcmp( stemp,"ObjectNum" ) != 0) fscanf(fp,"%s",stemp);
  66.     fscanf( fp, "%ld", &gObjectNum);
  68.     gObjectList = (OBJECT *)malloc( sizeof(OBJECT ) * gObjectNum);
  69.     for(i = 0; i < gObjectNum; i ++ )
  70.     {
  71.      fscanf( fp, "%s", stemp);
  72.      while( strcmp( stemp,"SurfaceNum" ) != 0) fscanf(fp,"%s",stemp);
  73.      fscanf( fp, "%ld", &(gObjectList[i].SurfNum) );
  75. gObjectList[i].surflist = (SURFACE *)malloc( sizeof(SURFACE) * gObjectList[i].SurfNum); 
  76. for(j = 0; j < gObjectList[i].SurfNum; j ++ )
  77. {
  78. /******   Read surface infor   ******/
  79. fscanf( fp, "%s", stemp);
  80.      while( strcmp( stemp,"TextureId" ) != 0) fscanf(fp,"%s",stemp);
  81.      fscanf( fp, "%d", &(gObjectList[i].surflist[j].texId) );
  82. fscanf( fp, "%s", stemp);
  83.      while( strcmp( stemp,"pointnum" ) != 0) fscanf(fp,"%s",stemp);
  84.      fscanf( fp, "%d", &(gObjectList[i].surflist[j].pointn) );
  85. fscanf( fp, "%s", stemp);
  86.      while( strcmp( stemp,"triangle" ) != 0) fscanf(fp,"%s",stemp);
  87.      fscanf( fp, "%d", &(gObjectList[i].surflist[j].triangle) );
  88. fscanf( fp, "%s", stemp);
  89.      while( strcmp( stemp,"quadrangle" ) != 0) fscanf(fp,"%s",stemp);
  90.      fscanf( fp, "%d", &(gObjectList[i].surflist[j].quadric) );
  93. /******   Read point list    ******/
  94. gObjectList[i].surflist[j].pointlist = (POINT*)malloc(sizeof(POINT) * 
  95.                                      gObjectList[i].surflist[j].pointn);
  96. plist = gObjectList[i].surflist[j].pointlist;
  97. for( l = 0; l < gObjectList[i].surflist[j].pointn ; l ++ )
  98. fscanf( fp, "%f%f%f%f%f%f%f%f", 
  99.         &(plist[l].r), &(plist[l].g), &(plist[l].b),     
  100. &(plist[l].u), &(plist[l].v),
  101. &(plist[l].x), &(plist[l].y), &(plist[l].z) );
  103. /******    Read patchlist    ******/
  104. nAllVertexNum = gObjectList[i].surflist[j].triangle * 3 + 
  105. gObjectList[i].surflist[j].quadric *4 ;
  106. gObjectList[i].surflist[j].patchlist = (INT4U *)malloc( sizeof(INT4U) * nAllVertexNum);
  107. pchlist =  gObjectList[i].surflist[j].patchlist;
  108. for( l = 0; l <  nAllVertexNum; l ++ )
  109. fscanf( fp, "%ld", &(pchlist[l]) );
  111. }
  113.     }
  114.     
  115.     
  116.     fclose(fp);    
  118. }
  120. void InitRenderWin()
  121. {
  122.   static int  mark = 1;
  123.   FILE *fp;
  125. /*  fp = fopen(sLookAtFN, "rb");
  126.   if (fp == NULL)
  127.   {
  128. ex = ey = ez =1.0f;
  129. cx = cy = cz =0.0f;
  130. near = 0.1;
  131. angle = 30.0f;
  132.   }
  133.   else fscanf(fp, "%f%f%f%f%f%f%f%f", &angle, &near, &ex, &ey, &ez, &cx, &cy, &cz);
  134.   fclose(fp);*/
  136.   glShadeModel ( GL_SMOOTH );
  137.   glDepthFunc ( GL_LESS );
  138.   glEnable ( GL_DEPTH_TEST );
  139.   glViewport(0, 0, gWinWidth, gWinHeigth);
  140.   glMatrixMode ( GL_PROJECTION );
  141.   glLoadIdentity();
  142.   gluPerspective ( 30.0, (float)gWinWidth/(float)gWinHeigth, 10.0, 1000000000.0);
  144.   if (mark)
  145.   {
  146.    glGetDoublev( GL_PROJECTION_MATRIX, gProject );
  147.      gViewport[0] = gWinWidth / 2 ; gViewport[1] = 0.0;  gViewport[2] = 0.0; gViewport[3] = 0.0;
  148.      gViewport[4] = 0.0; gViewport[5] = gWinHeigth / 2 ;  gViewport[6] = 0.0; gViewport[7] = 0.0;
  149.      gViewport[8] = 0.0; gViewport[9] = 0.0; gViewport[10] = 1.0; gViewport[11] = 0.0;
  150.      gViewport[12] = gWinWidth / 2 ; gViewport[13] = gWinHeigth / 2; gViewport[14] = 0.0; gViewport[15] = 1.0;
  151.      glPushMatrix();
  152.      glLoadMatrixd(gViewport);
  153.      glMultMatrixd(gProject);
  154.      glGetDoublev( GL_PROJECTION_MATRIX , gMatrixVP );
  155.      glPopMatrix(); 
  156. mark = 0;
  157.   }
  158. }
  160. void Render(void)
  161. {
  162.   int      i, j, k, l, m, TexIndex;
  163.   POINT    *plist; 
  164.   INT4U    *pchlist;
  165.    
  166.    
  168.   glClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_ACCUM_BUFFER_BIT);
  169.    
  170.   for(i = 0; i < gObjectNum; i ++ )
  171. for(j = 0; j < gObjectList[i].SurfNum; j ++ )
  172. {
  173. TexIndex = gObjectList[i].surflist[j].texId;
  174. if( TexIndex > 0 )
  175. InitTex( TexIndex );
  177. plist = gObjectList[i].surflist[j].pointlist;
  178. pchlist =  gObjectList[i].surflist[j].patchlist;
  180. l = 0;
  181. for ( k = 0; k < gObjectList[i].surflist[j].triangle; k ++)
  182. {
  183. glBegin( GL_TRIANGLES );
  184. for( m = 0; m < 3; m ++ )
  185. {
  186.     glColor3f ( plist[pchlist[l]].r,
  187.      plist[pchlist[l]].g,
  188.      plist[pchlist[l]].b );
  189.     glTexCoord2f( plist[pchlist[l]].u,
  190.   plist[pchlist[l]].v );
  191.     glVertex3f( plist[pchlist[l]].x,
  192. plist[pchlist[l]].y,
  193. plist[pchlist[l]].z );
  194.     l ++;
  195. }/* m */
  196. glEnd();
  198. }/* k */
  200. for ( k = 0; k < gObjectList[i].surflist[j].quadric; k ++)
  201. {
  202. glBegin( GL_QUADS );
  203. for( m = 0; m < 4; m ++ )
  204. {
  205.     glColor3f ( plist[pchlist[l]].r,
  206.      plist[pchlist[l]].g,
  207.      plist[pchlist[l]].b );
  208.     glTexCoord2f( plist[pchlist[l]].u,
  209.   plist[pchlist[l]].v );
  210.     glVertex3f( plist[pchlist[l]].x,
  211. plist[pchlist[l]].y,
  212. plist[pchlist[l]].z );
  213.     l ++;
  214. }/* m */
  215. glEnd();
  216. }/* k */
  217. glFlush();
  218. CloseTex();
  220. }
  222. }
  224. void freelist()
  225. {
  226. int i, j;
  228. for( i=0; i<gObjectNum; i++)
  229. {
  230. for( j=0; j<gObjectList[i].SurfNum; j++)
  231. {
  232. free(gObjectList[i].surflist[j].pointlist);
  233. free(gObjectList[i].surflist[j].patchlist);
  234. }
  235. free( gObjectList[i].surflist );
  236. }
  238.      free(gObjectList);
  240.      for(i=1; i<=gTexnum; i++)
  241. free(gTextureList[i]);
  242. free(gTextureList);
  243.         
  244.         auxQuit();
  245. }
  246. void markDiscontinuous(short xlen, short ylen, float *depth, unsigned char **mark)
  247. {
  248. int   x,y,i,l,m, n;
  249. float  **buf, temp;
  250. static int index[]={1,0,1,1,0,1,-1,1};
  252. i = 0;
  253. buf = (float **) malloc (ylen * sizeof(float *));
  254. for( y=0; y<ylen; y++)
  255. {
  256. buf[y] = (float *) malloc (xlen * sizeof(float));
  257. for(x = 0; x < xlen; x ++)
  258. {
  259. buf[y][x] = depth[i];
  260. i ++;
  261.                       
  262. }
  263. /* if( y == 76) 
  264.   for(x = 0; x < xlen; x ++)
  265.   {
  266. if( x % 10 == 0) printf("n");
  267. printf("%f,", buf[y][x]);
  268.   }
  269. */ }
  270. for( y=0; y<ylen; y++)
  271. {
  272. for(x = 0; x < xlen; x ++)
  273. {
  274. for( i = 0; i < 4; i ++)
  275. {
  276. m = x + index[i << 1];
  277. n = y + index[(i << 1) + 1];
  278. if( (m >= 0) && (m < xlen) && (n >= 0) && (n < ylen) )
  279. { /*************/
  280. temp = buf[y][x] - buf[n][m]; /*  |3|2|1|  */
  281. if(temp > 0.007) /*  |4| |0|  */
  282. mark[y][x] = mark[y][x] |((char)1 << i) ; /*  |5|6|7|  */
  283. else if(temp < -0.007) /*************/
  284. mark[n][m] = mark[n][m] | ((char)1 << (4 + i)); 
  285. }
  286. }
  287. }
  288. }
  289. for(y=0; y<ylen; y++) free(buf[y]);
  290. free(buf);
  291. i = 0;
  292. for( y=0; y<ylen; y++)
  293.     for(x = 0; x < xlen; x ++)
  294. if(mark[y][x] )    
  295.   {
  296. if( i % 10 == 0) printf("n");
  297. printf("(%1d,%1d,%3x)",y, x, buf[y][x]);
  298. i ++;
  299.   }  
  300. }
  302. /****************************************/
  303. /* function :write_rgb */
  304. /****************************************/
  305. void write_rgb()
  306. {       
  307.   static int   num = 0;      
  308. short viewx,viewy;
  309.         short xx,y,x;
  310. int  i;
  311.         short Xlen, Ylen, colNum, rowNum;
  312. char    temp[4], imageFile[30], depthFile[30];
  313.         GLint port[4];
  314.         double begin, wx, wy, wz, w;
  315.         IMAGE *image;
  316. FILE    *fp;
  317.         unsigned short *rbuf;
  318.         unsigned short *gbuf;
  319.         unsigned short *bbuf;
  320.         short         *dbuf;
  321.         float    *depth;
  322. unsigned char *demo, **disMark;
  323. long     colNumAddress, rowNumAddress;
  325. num ++;
  326. temp[0] = '.';
  327. i = num / 10;
  328. temp[1] = (char)('0' + i);
  329. i = num % 10;
  330. temp[2] = (char)('0' + i);
  331.   temp[3] = '';
  332. strcpy(imageFile,gImageName);
  333. strcpy(&(imageFile[strlen(imageFile)]), temp);
  334. strcpy(depthFile,imageFile);
  335. strcpy(&(imageFile[strlen(imageFile)]), ".rgb");
  336. strcpy(&(depthFile[strlen(depthFile)]), ".depth");
  338.      glGetDoublev( GL_MODELVIEW_MATRIX, gModelview );
  339.      glPushMatrix();
  340.      glLoadMatrixd(gMatrixVP);
  341.      glMultMatrixd(gModelview);
  342.      glGetDoublev( GL_MODELVIEW_MATRIX, gMatrixC1 );
  343.      glPopMatrix();
  344.     gMatrixC1[2] = 0.0; gMatrixC1[6] = 0.0; gMatrixC1[10] = 1.0; gMatrixC1[14] = 14.737;
  346. glGetIntegerv(GL_VIEWPORT,port);
  347. viewx = port[2]-port[0];
  348. viewy = port[3]-port[1]; 
  349.         Xlen = viewx;
  350.         Ylen = viewy;
  352.   fp = fopen( depthFile, "wb");  /**************************************/
  353. fwrite( &colNumAddress, sizeof(long), 1, fp);
  354. fwrite( &Xlen, sizeof(short), 1, fp);                    /*   write viewx, viewy & matrix C^   */
  355. fwrite( &Ylen, sizeof(short), 1, fp);  /**************************************/
  356. fwrite(gMatrixC1, sizeof(double), 16, fp);
  357.         
  358.      depth  = (float *)malloc( viewx*viewy * sizeof(float) );
  359. demo = (unsigned char *)malloc(viewx*viewy*3);
  360. disMark = (unsigned char **)malloc(viewy * sizeof(unsigned char *));
  361. for(i = 0; i < viewy; i ++)
  362. {
  363. disMark[i] = (unsigned char *)malloc(viewx);
  364. for(x = 0 ; x < viewx; x ++)
  365. disMark[i][x] = 0; 
  366. }
  367. rbuf = (unsigned short*)malloc(Xlen*sizeof(short));
  368. gbuf = (unsigned short*)malloc(Xlen*sizeof(short));
  369. bbuf = (unsigned short*)malloc(Xlen*sizeof(short));
  370. dbuf = (short*)malloc(Xlen*sizeof(short));
  372. glReadPixels(0,0,viewx,viewy,GL_RGB,GL_UNSIGNED_BYTE,demo);
  373. glReadPixels( 0, 0, viewx, viewy, GL_DEPTH_COMPONENT, GL_FLOAT, depth );
  375. markDiscontinuous(viewx, viewy, depth, disMark);
  376. printf( "n end mark discontiniousn");
  378. colNum = 0;
  379. colNumAddress = ftell(fp);
  380. fwrite( &colNum, sizeof(short), 1, fp);     /*   Write length of colum    */
  381. for( y=0; y<Ylen; y++)
  382. {
  383. rowNum = 0;
  384. rowNumAddress = ftell(fp);
  385. fwrite( &rowNum, sizeof(short), 1, fp);    /*   Write length of row    */
  386. fwrite( &y, sizeof(short), 1, fp);      /*   Write row's No.    */  
  387. for(xx=0; xx<Xlen; xx++)
  388. {
  389. if(disMark[y][xx] != 0)
  390. {
  391. fwrite( &xx, sizeof(short), 1, fp); /*   Write col's No. and discontinuious Mark   */  
  392. fwrite( &disMark[y][xx], sizeof(char), 1, fp);
  393. rowNum ++;
  394. }
  395. }
  396. if( rowNum == 0)
  397. fseek(fp, rowNumAddress, SEEK_SET);
  398. else
  399. {
  400. fseek(fp, rowNumAddress, SEEK_SET);
  401. fwrite( &rowNum, sizeof(short), 1, fp);
  402. fseek(fp, 0, SEEK_END);
  403. colNum ++;
  404. }
  405. }
  406. fseek(fp, colNumAddress, SEEK_SET);
  407. fwrite( &colNum, sizeof(short), 1, fp);
  408. fseek(fp, 0, SEEK_END);
  409. printf( "n end Wriete discontinious mark ");
  410.  
  411. colNumAddress = ftell(fp);
  412. fseek(fp, 0, SEEK_SET);
  413. fwrite(&colNumAddress, sizeof(long), 1, fp);
  414. fseek(fp, 0, SEEK_END);
  415. i=0;
  416. for( y=0; y<Ylen; y++)
  417. {
  418. for(xx=0; xx<Xlen; xx++)
  419. {
  420. gluUnProject(xx ,y, depth[i+xx], gModelview, gProject, port, &wx, &wy, &wz);
  421.      w = gMatrixC1[3] * wx + gMatrixC1[7] * wy + gMatrixC1[11] * wz + gMatrixC1[15];
  422. depth[i+xx] = ( gMatrixC1[2] * wx + gMatrixC1[6] * wy
  423.  + gMatrixC1[10] * wz + gMatrixC1[14] ) / w;
  424. }
  425. i += Xlen;
  426. }
  428. image = iopen(imageFile , "w", RLE(1), 3, Xlen, Ylen, 3);
  430. i=0;
  431. for( y=0; y<Ylen; y++)
  432. {
  433. for(xx=0; xx<Xlen; xx++)
  434. {
  435. rbuf[xx] = (short)(demo[(i+xx)*3]);
  436. gbuf[xx] = (short)(demo[(i+xx)*3+1]);
  437. bbuf[xx] = (short)(demo[(i+xx)*3+2]);
  438. dbuf[xx] = (short)(depth[i+xx]*10000);
  439. }
  440. i += Xlen;
  441. putrow(image, rbuf,y,0);
  442. putrow(image, gbuf,y,1);
  443. putrow(image, bbuf,y,2);
  444. fwrite(dbuf, sizeof(short), Xlen, fp);
  445. }
  447. iclose(image);
  448. fclose(fp);
  449. printf( "n end write rgb ");
  451.   free(demo);
  452. for(i = 0; i < viewy; i ++) free(disMark[i]); 
  453. free(disMark);  
  454. free(depth);
  455. free(rbuf);
  456. free(gbuf);
  457. free(bbuf);
  458. free(dbuf); 
  459. }
  461. void    leftFunc(void)
  462. {
  463.   gEx -= 2.0;
  465. }
  467. void    rightFunc(void)
  468. {
  469.   gEx += 2.0;
  471. }
  473. void    upFunc(void)
  474. {
  475.   gEz -= 2.0;
  477. }
  479. void    downFunc(void)
  480. {
  481.   gEz += 2.0;
  483. }
  484. void    leftCFunc(void)
  485. {
  486.   gCx -= 2.0;
  488. }
  490. void    rightCFunc(void)
  491. {
  492.   gCx += 2.0;
  494. }
  496. void    upCFunc(void)
  497. {
  498.   gCz -= 2.0;
  500. }
  502. void    downCFunc(void)
  503. {
  504.   gEz += 2.0;
  506. }
  508. void inputEye(void)
  509. {
  510.   printf("nPlease input view point(x,y,z):");
  511.   scanf("%f%f%f",&gEx, &gEy, &gEz);
  512. }
  514. void inputCenter(void)
  515. {
  516.   printf("nPlease input center point(x,y,z):");
  517.   scanf("%f%f%f",&gCx, &gCy, &gCz);
  518. }
  520. void getXYZ(AUX_EVENTREC  *event)
  521. {
  522. GLint  i,j;
  523. double x,y,z;
  524.         GLint port[4];
  525. float  depth;
  527. i = event->data[AUX_MOUSEX];
  528. j = gWinHeigth - event->data[AUX_MOUSEY];
  529. glGetIntegerv(GL_VIEWPORT,port);
  530.      glGetDoublev( GL_MODELVIEW_MATRIX, gModelview );
  531. glReadPixels( i, j, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth );
  532. gluUnProject(i , j, depth, gModelview, gProject, port, &x, &y, &z); 
  534.         printf( "n the world coordination of (%1d, %1d, %f) is (%f, %f, %f)", i, j, depth, x, y, z);    
  536.  
  537. }
  539. /****************************************/
  540. /* function : Shoot */
  541. /* calculate the Fij, */
  542. /* (i=0,pindex-1; j=0,pindex-1) */
  543. /****************************************/
  544. void Shoot(void) 
  545. {    
  547.   system ("date");
  549.   glMatrixMode ( GL_MODELVIEW );
  550.   glLoadIdentity();
  551.   gluLookAt( gEx, gEy, gEz, gCx, gCy, gCz, 0.0, 1.0, 0.0); 
  552.   printf("Viewpoint(%3.1f, %3.1f, %3.1f), Centerpoint(%1.1f, %1.1f, %1.1f)",
  553.   gEx, gEy, gEz, gCx, gCy, gCz);
  554.   /*  DrawBkGroundPic();   */
  555.   Render();
  556.   printf("n****** Finish Render; Current time is:");
  557.   system ("date");
  559.  /* write_rgb(gImageName);  
  560.  /***************
  561.  PrintMessage(); 
  562.  ***************/ 
  563.  
  564. }
  566. /****************************************/
  567. /*   function: myReshape1 */
  568. /****************************************/
  569. void myReshape1(int w, int h)
  570. { 
  571. InitRenderWin();
  572. }
  574. /****************************************/
  575. /*   function: Hemi_mode */
  576. /****************************************/
  577. void Hemi_mode()
  578. {  
  579.   auxInitDisplayMode ( AUX_SINGLE | AUX_RGBA | AUX_DEPTH );
  580.   auxInitPosition (0, 0, gWinWidth, gWinHeigth);
  581.   auxInitWindow ( gImageName );
  583.   auxKeyFunc (AUX_LEFT, leftFunc);
  584.   auxKeyFunc (AUX_RIGHT, rightFunc);
  585.   auxKeyFunc (AUX_UP, upFunc);
  586.   auxKeyFunc (AUX_DOWN, downFunc);
  587.   auxKeyFunc (AUX_j, leftCFunc);
  588.   auxKeyFunc (AUX_l, rightCFunc);
  589.   auxKeyFunc (AUX_k, upCFunc);
  590.   auxKeyFunc (AUX_m, downCFunc);
  591.   auxKeyFunc (AUX_e, inputEye);
  592.   auxKeyFunc (AUX_c, inputCenter);
  593.   auxKeyFunc (AUX_ESCAPE, freelist);
  594.   auxKeyFunc (AUX_w, write_rgb);
  595.   auxMouseFunc( AUX_LEFTBUTTON, AUX_MOUSEDOWN, getXYZ);  
  597.   auxReshapeFunc (myReshape1);
  598.  
  599.   auxMainLoop(Shoot);
  600. }