00001
00002
00003
00004
00005
00006
00007
00008
00009 #include "test_geom.h"
00010
00011
00012
00013 TestGeom::TestGeom(int _duration, int _type, TScene *s) : Test(_duration, _type, s)
00014 {
00015
00016 if(!GLEW_EXT_geometry_shader4 && !GLEW_EXT_gpu_shader4)
00017 {
00018 cout<<"No HW support for geometry shaders - skipping test\n";
00019 stopbit = true;
00020 return;
00021 }
00022
00023
00024 if(type == GEOM_TESSELATE)
00025 {
00026 testname = "geom_tesselate";
00027 weight = 0.15f;
00028 splits = 4;
00029 s->SetLoadList(8);
00030
00031 lpos.Set(500.0,100.0,-100.0);
00032
00033 try
00034 {
00035 s->AddObject("obj",STRIP_PLANE,100.0,300.0,25,125);
00036 s->AddObject("obj2",STRIP_PLANE,100.0,300.0,25,125);
00037 s->AddObject("sky", PLANE, 770.0,200.0);
00038 s->MoveObj("obj2",0.0,0.0,300.0);
00039 s->RotateObj("sky",90.0,A_X);
00040
00041 s->AddLight(0,silver,white,white,lpos);
00042
00043 s->AddMaterial("mat_tess",lgrey);
00044 s->AddTexture("mat_tess", "data/tex/snow2.tga",BASE);
00045 s->AddTexture("mat_tess", "data/tex/depth/terrain.tga",BUMP,MODULATE,1.0,1.0,1.0,false);
00046
00047
00048 s->AddMaterial("mat_sky",white,white,white,0.0,0.0,0.0,NONE);
00049 s->AddTexture("mat_sky", "data/tex/sky_glow.tga",BASE);
00050
00051 s->CustomShader("mat_tess","data/shaders/geometry/subd.vert","data/shaders/geometry/subd.geom","data/shaders/geometry/subd.frag");
00052
00053 s->SetMaterial("obj","mat_tess"); s->SetMaterial("obj2","mat_tess");
00054 s->SetMaterial("sky","mat_sky");
00055 }
00056 catch(int err)
00057 {
00058 stopbit = true;
00059 throw ERR;
00060 return;
00061 }
00062 }
00064 else if(type == GEOM_CUBEMAP)
00065 {
00066 testname = "geom_cubemap";
00067 weight = 0.15f;
00068 splits = 2;
00069 OBJECT_COUNT = 7;
00070 s->SetLoadList(11 + OBJECT_COUNT*OBJECT_COUNT);
00071
00072 lpos.Set(2.0,5.0,3.0);
00073 s->MoveCamera(0.0,0.0,-5.0);
00074 s->RotateCamera(15.0,A_Y);
00075 s->RotateCamera(15.0,A_X);
00076
00077 try
00078 {
00079
00080 s->AddObject("ref_sphere",SPHERE,1.0,1.0,32,32);
00081 s->AddObject("ref_sphere2",SPHERE,0.5,0.5,32,32);
00082 s->AddObject("sky",SPHERE,100.0,0.0,32,32);
00083
00084
00085 s->AddLight(0,silver,TVector(1.0f,0.9f,0.8f),white,lpos);
00086
00087
00088 s->AddMaterial("mat_sphere",dgrey,white,white,32.0,1.0,0.0, GOURAUD);
00089 s->AddMaterial("mat_sphere2",dgrey,dgrey,white,32.0,1.0,0.0, GOURAUD);
00090 s->AddMaterial("mat_fighter",black,white,white,64.0, 0.0, 0.0, GOURAUD);
00091 s->AddMaterial("mat_sky",white,white,white,1.0,0.0,0.0,NONE);
00092
00093
00094 s->AddTexture("mat_sky", "data/tex/stars.tga",BASE, MODULATE, 1.0, 4.0,4.0);
00095 s->AddTexture("mat_fighter", "data/tex/fighter.tga",BASE);
00096 s->AddTexture("mat_sphere", "data/tex/metal.tga",BASE, MODULATE, 0.5, 2.0, 2.0);
00097 s->AddTexture("mat_sphere2", "data/tex/metal.tga",BASE, MODULATE, 0.5, 2.0, 2.0);
00098
00099
00100 s->SetMaterial("ref_sphere", "mat_sphere");
00101 s->SetMaterial("ref_sphere2", "mat_sphere2");
00102 s->SetMaterial("sky", "mat_sky");
00103
00104
00105 float rnd1, rnd2, rnd3;
00106 s->AddObject("fighter0","data/obj/fighter.3ds");
00107 s->SetMaterial("fighter0", "mat_fighter");
00108 for(int i=0; i<OBJECT_COUNT; i++)
00109 {
00110 for(int j=0; j<OBJECT_COUNT; j++)
00111 {
00112 rnd1 = rand()%100 / 100.0f - 2.0f;
00113 rnd2 = rand()%100 / 100.0f - 2.0f;
00114 rnd3 = rand()%10 / 10.0f;
00115 obj_name = "fighter" + num2str(i*OBJECT_COUNT + j + 1);
00116 s->AddObjectInstance("fighter0",obj_name.c_str());
00117 s->MoveObj(obj_name.c_str(), 40.0f, (2.0f * i + rnd1) - (2.0f * OBJECT_COUNT/2), (5.0f * j + rnd2) - (5.0f * OBJECT_COUNT/2) );
00118 speeds.push_back(rnd3);
00119 }
00120 }
00121 s->SetReflectionSize("ref_sphere",512);
00122 s->SetReflectionSize("ref_sphere2",512);
00123 s->UseDynReflections(false);
00124 }
00125 catch(int err)
00126 {
00127 stopbit = true;
00128 throw ERR;
00129 return;
00130 }
00131
00132
00133 msg1 = "Using multi-pass cubemapping";
00134 }
00136 else if(type == GEOM_PARTICLES)
00137 {
00138 testname = "geom_particles";
00139 weight = 0.50;
00140 splits = 4;
00141 OBJECT_COUNT = 20;
00142 s->SetLoadList(12 + OBJECT_COUNT*OBJECT_COUNT);
00143
00144 s->MoveCamera(-4.0,0.0,-15.0);
00145 s->RotateCamera(35.0,A_X);
00146
00147 try
00148 {
00149 lpos.Set(0.0,10.0,10.0);
00150 s->AddLight(0,black,dgrey,white,lpos);
00151
00152
00153 s->AddObject("wet_plane",PLANE,50.0,50.0);
00154
00155 s->AddMaterial("mat_rain1",black,dgrey,white,64.0,0.0,1.0);
00156 s->AddTexture("mat_rain1","data/tex/alpha/raindrop.tga");
00157 s->AddMaterial("mat_rain2",black,dgrey,white,64.0,0.0,1.0);
00158 s->AddTexture("mat_rain2","data/tex/alpha/raindrop.tga");
00159 s->AddMaterial("mat_rain3",black,dgrey,white,64.0,0.0,1.0);
00160 s->AddTexture("mat_rain3","data/tex/alpha/raindrop.tga");
00161 s->AddMaterial("mat_rain4",black,dgrey,white,64.0,0.0,1.0);
00162 s->AddTexture("mat_rain4","data/tex/alpha/raindrop.tga");
00163
00164 s->AddMaterial("mat_wet",black,dgrey,white,8.0);
00165 s->AddTexture("mat_wet","data/tex/wall.tga");
00166 s->AddTexture("mat_wet","data/tex/normal/bump.tga",BUMP);
00167 s->AddTexture("mat_wet","data/tex/normal/raindrops.tga",BUMP);
00168 s->SetMaterial("wet_plane","mat_wet");
00169
00170
00171 float rnd;
00172 s->AddObject("emitter0",PLANE,10.0,10.0);
00173 s->SetMaterial("emitter0", "mat_rain1");
00174 for(int i=0; i<OBJECT_COUNT; i++)
00175 {
00176 for(int j=0; j<OBJECT_COUNT; j++)
00177 {
00178 rnd = (rand()%10)/5.0f - 1.0f;
00179 obj_name = "emitter" + num2str(i*OBJECT_COUNT + j + 1);
00180 s->AddObjectInstance("emitter0",obj_name.c_str());
00181 s->MoveObj(obj_name.c_str(), 1.5f*j + rnd - OBJECT_COUNT/2.0f, 10.0f - 10.0f*rnd, 1.5f*i - OBJECT_COUNT/2.0f);
00182 }
00183 }
00184
00185 s->CustomShader("mat_rain1","data/shaders/geometry/rain.vert","data/shaders/geometry/rain.geom","data/shaders/geometry/rain.frag",NULL,NULL,
00186 "#define PARTICLES 2\nlayout(max_vertices=16) out;");
00187 s->CustomShader("mat_rain2","data/shaders/geometry/rain.vert","data/shaders/geometry/rain.geom","data/shaders/geometry/rain.frag",NULL,NULL,
00188 "#define PARTICLES 4\nlayout(max_vertices=64) out;");
00189 s->CustomShader("mat_rain3","data/shaders/geometry/rain.vert","data/shaders/geometry/rain.geom","data/shaders/geometry/rain.frag",NULL,NULL,
00190 "#define PARTICLES 6\nlayout(max_vertices=144) out;");
00191 s->CustomShader("mat_rain4","data/shaders/geometry/rain.vert","data/shaders/geometry/rain.geom","data/shaders/geometry/rain.frag",NULL,NULL,
00192 "#define PARTICLES 8\nlayout(max_vertices=255) out;");
00193
00194 s->CustomShader("mat_wet","data/shaders/wet.vert",NULL,"data/shaders/wet.frag");
00195
00196
00197 s->SetUniform("mat_wet","rain_speed",20.0);
00198 msg1 = "1600 particles";
00199 }
00200 catch(int err)
00201 {
00202 stopbit = true;
00203 throw ERR;
00204 return;
00205 }
00206 }
00208 else if(type == GEOM_INSTANCING)
00209 {
00210 testname = "geom_instancing";
00211 weight = 0.20f;
00212 splits = 2;
00213 OBJECT_COUNT = 12;
00214 s->SetLoadList(14 + OBJECT_COUNT*OBJECT_COUNT);
00215
00216 s->MoveCamera(0.0,-2.0,0.0);
00217
00218 try
00219 {
00220 lpos.Set(0.0,15.0,50.0);
00221 s->AddLight(0,grey,white,white,lpos);
00222
00223
00224 s->AddMaterial("mat_rock",dgrey,grey,white,64.0,0.0,0.0,GOURAUD);
00225 s->AddMaterial("mat_rock_inst",dgrey,grey,white);
00226 s->AddTexture("mat_rock","data/tex/asteroid.tga",BASE,MODULATE,1.0,4.0,4.0);
00227 s->AddTexture("mat_rock_inst","data/tex/asteroid.tga");
00228
00229
00230 s->AddObject("rockA","data/obj/rock.3ds");
00231 s->AddObject("rockB","data/obj/rock.3ds");
00232 s->AddObject("rockC","data/obj/rock.3ds");
00233 s->AddObject("rockD","data/obj/rock.3ds");
00234 s->SetMaterial("rockA","mat_rock_inst");
00235 s->SetMaterial("rockB","mat_rock_inst");
00236 s->SetMaterial("rockC","mat_rock_inst");
00237 s->SetMaterial("rockD","mat_rock_inst");
00238 s->MoveObj("rockA", 0.0f, -3.0f, 0.0f);
00239 s->MoveObj("rockB", 5.9f, -3.2f, 5.1f);
00240 s->MoveObj("rockC", 0.5f, -3.2f, 5.2f);
00241 s->MoveObj("rockD", 5.1f, -3.0f, 0.4f);
00242
00243
00244 s->AddObject("sky",SPHERE,100.0,0.0,16,16);
00245 s->AddMaterial("mat_sky",white,white,white,64.0,0.0,0.0,NONE);
00246 s->AddTexture("mat_sky","data/tex/stars.tga",BASE,MODULATE,1.0,4.0,4.0);
00247 s->SetMaterial("sky","mat_sky");
00248
00249
00250 s->AddObject("star",PLANE,10.0,10.0);
00251 s->AddMaterial("mat_star",white,white,white,64.0,0.0,0.0,NONE);
00252 s->AddTexture("mat_star","data/tex/star.tga",BASE,MODULATE,2.0);
00253 s->SetMaterial("star","mat_star");
00254 s->MoveObj("star",lpos.x, lpos.y, lpos.z);
00255 s->RotateObj("star",90.0,A_X);
00256
00257
00258 s->CustomShader("mat_rock_inst","data/shaders/geometry/instanced.vert","data/shaders/geometry/instanced.geom","data/shaders/geometry/instanced.frag");
00259
00260
00261 float rnd;
00262 s->AddObject("rock0","data/obj/rock.3ds");
00263 s->SetMaterial("rock0", "mat_rock");
00264 for(int i=0; i<OBJECT_COUNT; i++)
00265 {
00266 for(int j=0; j<OBJECT_COUNT; j++)
00267 {
00268 rnd = rand()%100 / 25.0f - 2.0f;
00269 obj_name = "rock" + num2str(i*OBJECT_COUNT + j + 1);
00270 s->AddObjectInstance("rock0",obj_name.c_str());
00271 s->MoveObj(obj_name.c_str(), j*4.0f + rnd - 2.0f*OBJECT_COUNT, rnd/4.0f, i*4.0f - rnd -2.0f* OBJECT_COUNT);
00272 }
00273 }
00274
00275 for(int i=0; i<OBJECT_COUNT*OBJECT_COUNT; i++)
00276 {
00277 obj_name = "rock" + num2str(i);
00278 s->DrawObject(obj_name.c_str(),true);
00279 }
00280 s->DrawObject("rockA",false);
00281 s->DrawObject("rockB",false);
00282 s->DrawObject("rockC",false);
00283 s->DrawObject("rockD",false);
00284 msg1 = "Geometry instancing OFF - drawing 144 objects and 0 instances";
00285 }
00286 catch(int err)
00287 {
00288 stopbit = true;
00289 throw ERR;
00290 return;
00291 }
00292 }
00293
00294
00295 if(!s->PostInit())
00296 {
00297 stopbit = true;
00298 throw ERR;
00299 }
00300 InitTime();
00301 }
00302
00303
00304
00305 TestGeom::~TestGeom()
00306 {
00307
00308 int resx = s->GetResX();
00309 int resy = s->GetResY();
00310 s->Resize(resx,resy);
00311
00312 s->Destroy();
00313 }
00314
00315
00316
00317 void TestGeom::Run()
00318 {
00319 Test::Run();
00320 if(!draw_scene)
00321 return;
00322
00324
00325 if(type == GEOM_TESSELATE)
00326 {
00327 if(splitbit)
00328 {
00329 splitbit = false;
00330
00331
00332 switch(curr_setup)
00333 {
00334 case 1: s->SetUniform("mat_tess","TESS_LEVEL",0); break;
00335 case 2: s->SetUniform("mat_tess","TESS_LEVEL",1); break;
00336 case 3: s->SetUniform("mat_tess","TESS_LEVEL",2); break;
00337 case 4: s->SetUniform("mat_tess","TESS_LEVEL",3); break;
00338 default: break;
00339 }
00340
00341 msg = "Tesselation level " + num2str(curr_setup);
00342 }
00343
00344 s->MoveCameraAbs(-12.0f,-3.0f,-400.0f + anim);
00345 s->MoveObjAbs("sky",0.0f,75.0f, -anim);
00346
00347
00348 int resx = s->GetResX();
00349 int resy = s->GetResY();
00350
00351
00352 s->DrawObject("sky",true);
00353 glViewport(0,0,resx/2,resy);
00354 glMatrixMode(GL_PROJECTION);
00355 glLoadIdentity();
00356
00357 gluPerspective(45.0,(GLfloat)resx/resy,0.1,1000.0);
00358 glMatrixMode(GL_MODELVIEW);
00359 s->Redraw();
00360
00361
00362 s->DrawObject("sky",false);
00363 glViewport(resx/2,0,resx/2,resy);
00364 glMatrixMode(GL_PROJECTION);
00365 glLoadIdentity();
00366
00367 gluPerspective(45.0,(GLfloat)resx/resy,0.1,1000.0);
00368 glMatrixMode(GL_MODELVIEW);
00369
00370 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
00371 s->Redraw(false);
00372 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
00373
00374
00375 glViewport(0,0,resx,resy);
00376 s->DrawScreenText(msg.c_str(),50.0,95.0f,1.2f);
00377 }
00379 else if(type == GEOM_CUBEMAP)
00380 {
00381 if(splitbit)
00382 {
00383 splitbit = false;
00384
00385
00386 if(curr_setup > 1)
00387 {
00388 try
00389 {
00390 s->UseDynReflections(true);
00391 }
00392 catch(int err)
00393 {
00394 stopbit = true;
00395 return;
00396 }
00397 msg1 = "Using single-pass GS cubemapping";
00398 }
00399 }
00400
00401
00402 for(int i=0; i<OBJECT_COUNT*OBJECT_COUNT; i++)
00403 {
00404 obj_name = "fighter" + num2str(i);
00405 s->MoveObj(obj_name.c_str(), -speeds[i]/fps*30.0f,0.0f,0.0f);
00406 if(s->GetObjPosition(obj_name.c_str()).x < -40.0)
00407 s->MoveObj(obj_name.c_str(), 80.0, 0.0, 0.0);
00408 }
00409
00410 s->MoveObjAbs("ref_sphere2",sin(anim/5.0f + 4.0f) * 2.0f, 0.0f, cos(anim/5.0f + 4.0f) * 2.0f);
00411 s->Redraw();
00412
00413 s->DrawScreenText(msg1.c_str(),50.0f,95.0f,1.2f);
00414 }
00416 else if(type == GEOM_PARTICLES)
00417 {
00418 if(splitbit)
00419 {
00420 splitbit = false;
00421 int i;
00422
00423
00424 switch(curr_setup)
00425 {
00426 case 2:
00427 for(i=0; i<OBJECT_COUNT*OBJECT_COUNT; i++)
00428 {
00429 obj_name = "emitter" + num2str(i);
00430 s->SetMaterial(obj_name.c_str(), "mat_rain2");
00431 }
00432 s->SetUniform("mat_wet","rain_speed",25.0);
00433 msg1 = "6400 particles";
00434 break;
00435 case 3:
00436 for(i=0; i<OBJECT_COUNT*OBJECT_COUNT; i++)
00437 {
00438 obj_name = "emitter" + num2str(i);
00439 s->SetMaterial(obj_name.c_str(), "mat_rain3");
00440 }
00441 s->SetUniform("mat_wet","rain_speed",30.0);
00442 msg1 = "14400 particles";
00443 break;
00444 case 4:
00445 for(i=0; i<OBJECT_COUNT*OBJECT_COUNT; i++)
00446 {
00447 obj_name = "emitter" + num2str(i);
00448 s->SetMaterial(obj_name.c_str(), "mat_rain4");
00449 }
00450 s->SetUniform("mat_wet","rain_speed",40.0);
00451 msg1 = "25600 particles";
00452 break;
00453 default: break;
00454 }
00455 }
00456 s->SetUniform("mat_rain1","time",anim/2.0);
00457 s->SetUniform("mat_rain2","time",anim/2.0);
00458 s->SetUniform("mat_rain3","time",anim/2.0);
00459 s->SetUniform("mat_rain4","time",anim/2.0);
00460
00461 s->SetUniform("mat_wet","time",anim/2.0);
00462 s->Redraw();
00463 s->DrawScreenText(msg1.c_str(),50.0f,95.0f,1.2f);
00464 }
00466 else if(type == GEOM_INSTANCING)
00467 {
00468 if(splitbit)
00469 {
00470 splitbit = false;
00471
00472 if(curr_setup > 1)
00473 {
00474 for(int i=0; i<OBJECT_COUNT*OBJECT_COUNT; i++)
00475 {
00476 obj_name = "rock" + num2str(i);
00477 s->DrawObject(obj_name.c_str(),false);
00478 }
00479 s->DrawObject("rockA",true);
00480 s->DrawObject("rockB",true);
00481 s->DrawObject("rockC",true);
00482 s->DrawObject("rockD",true);
00483 msg1 = "Geometry instancing ON - drawing 4 objects and 140 instances";
00484 }
00485
00486 }
00487
00488 s->RotateCameraAbs(180.0f + anim*18.0f,A_Y);
00489 s->Redraw();
00490 s->DrawScreenText(msg1.c_str(),50.0f,95.0f,1.2f);
00491 }
00492 }
00493
00494
00495
00496 void TestGeom::Animate()
00497 {
00498 Test::Animate();
00499
00500
00501
00502
00503
00504
00505
00506 }
00507
00508
00509
00510
00511 void TestGeom::SaveResults()
00512 {
00513 Test::SaveResults();
00514
00515
00516 static float ati_bug[4];
00517
00518
00519 if(type == GEOM_TESSELATE)
00520 {
00521 int VERTICES = 3125;
00522
00523 switch(curr_setup)
00524 {
00525 case 1:
00526 results<<"<geometry>\n"<<
00527 "<"<<testname<<">\n"<<
00528 "<level0>\n<fps>"<<avg_fps<<"</fps>\n<vert_rate>"<<(9 * VERTICES * avg_fps)/1000000.0<<"</vert_rate>\n</level0>\n";
00529 test_score += avg_fps/5;
00530 ati_bug[0] = avg_fps;
00531 break;
00532 case 2:
00533 results<<"<level1>\n<fps>"<<avg_fps<<"</fps>\n<vert_rate>"<<(27 * VERTICES * avg_fps)/1000000.0<<"</vert_rate>\n</level1>\n";
00534 test_score += avg_fps/3;
00535 ati_bug[1] = avg_fps;
00536 break;
00537 case 3:
00538 results<<"<level2>\n<fps>"<<avg_fps<<"</fps>\n<vert_rate>"<<(81 * VERTICES * avg_fps)/1000000.0<<"</vert_rate>\n</level2>\n";
00539 test_score += avg_fps/2;
00540 ati_bug[2] = avg_fps;
00541 break;
00542 case 4:
00543 test_score += avg_fps;
00544
00545 if( !(ati_bug[0] > ati_bug[1] && ati_bug[1] > ati_bug[2] && ati_bug[2] > avg_fps) )
00546 test_score = 0;
00547
00548 cout<<"SCORE: "<<test_score<<endl;
00549 results<<"<level3>\n<fps>"<<avg_fps<<"</fps>\n<vert_rate>"<<(243 * VERTICES * avg_fps)/1000000.0<<"</vert_rate>\n</level3>\n"
00550 "<score>"<<test_score<<"</score>"
00551 "</"<<testname<<">\n";
00552 break;
00553 default: break;
00554 }
00555 }
00556 else if(type == GEOM_CUBEMAP)
00557 {
00558
00559 switch(curr_setup)
00560 {
00561 case 1:
00562 results<<"<"<<testname<<">\n"<<
00563 "<GS_off>\n<fps>"<<avg_fps<<"</fps>\n</GS_off>\n";
00564 break;
00565 case 2:
00566
00567 test_score = 0;
00568 cout<<"SCORE: "<<test_score<<endl;
00569 results<<"<GS_on>\n<fps>"<<avg_fps<<"</fps>\n</GS_on>\n"
00570 "<score>"<<test_score<<"</score>"
00571 "</"<<testname<<">\n";
00572 break;
00573 default: break;
00574 }
00575 }
00576 else if(type == GEOM_PARTICLES)
00577 {
00578
00579 switch(curr_setup)
00580 {
00581 case 1:
00582 results<<"<"<<testname<<">\n"<<
00583 "<part_1>\n<fps>"<<avg_fps<<"</fps>\n<part_rate>"<<1600 * avg_fps<<"</part_rate>\n</part_1>\n";
00584 test_score += avg_fps/10;
00585 break;
00586 case 2:
00587 results<<"<part_2>\n<fps>"<<avg_fps<<"</fps>\n<part_rate>"<<6400 * avg_fps<<"</part_rate>\n</part_2>\n";
00588 test_score += avg_fps/2.5f;
00589 break;
00590 case 3:
00591 results<<"<part_3>\n<fps>"<<avg_fps<<"</fps>\n<part_rate>"<<14400 * avg_fps<<"</part_rate>\n</part_3>\n";
00592 test_score += avg_fps*2.5f;
00593 break;
00594 case 4:
00595 test_score += avg_fps*4;
00596 cout<<"SCORE: "<<test_score<<endl;
00597 results<<"<part_4>\n<fps>"<<avg_fps<<"</fps>\n<part_rate>"<<25600 * avg_fps<<"</part_rate>\n</part_4>\n"
00598 "<score>"<<test_score<<"</score>"
00599 "</"<<testname<<">\n";
00600 break;
00601 default: break;
00602 }
00603 }
00604 else if(type == GEOM_INSTANCING)
00605 {
00606
00607 switch(curr_setup)
00608 {
00609 case 1:
00610 results<<"<"<<testname<<">\n"<<
00611 "<inst_off>\n<fps>"<<avg_fps<<"</fps>\n</inst_off>\n";
00612 break;
00613 case 2:
00614
00615 test_score = avg_fps/3;
00616 cout<<"SCORE: "<<test_score<<endl;
00617 results<<"<inst_on>\n<fps>"<<avg_fps<<"</fps>\n</inst_on>\n"
00618 "<score>"<<test_score<<"</score>"
00619 "</"<<testname<<">\n"
00620 "</geometry>\n";
00621 break;
00622 default: break;
00623 }
00624 }
00625 }