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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
engine.cpp
资源名称：Engine_v0.2.tar.gz　[点击查看]
上传用户：qccn516
上传日期：2013-05-02
资源大小：3382k
文件大小：38k
源码类别：

游戏引擎

开发平台：

Visual C++

engine.cpp：源码内容
  1. /* 3D Engine
  2.  *
  3.  * Copyright (C) 2003-2004, Alexander Zaprjagaev <frustum@frustum.org>
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  */
  20. #include "pbuffer.h"
  21. #include "console.h"
  22. #include "frustum.h"
  23. #include "meshvbo.h"
  24. #include "bsp.h"
  25. #include "position.h"
  26. #include "object.h"
  27. #include "light.h"
  28. #include "fog.h"
  29. #include "mirror.h"
  30. #include "shader.h"
  31. #include "texture.h"
  32. #include "material.h"
  33. #include "physic.h"
  34. #include "map.h"
  35. #include "engine.h"
  37. char *Engine::vendor;
  38. char *Engine::renderer;
  39. char *Engine::version;
  40. char *Engine::extensions;
  42. int Engine::screen_width = 1024;
  43. int Engine::screen_height = 512;
  44. int Engine::screen_multisample = 0;
  45. PBuffer *Engine::screen;
  46. Texture *Engine::screen_texture;
  47. Material *Engine::screen_material;
  49. Console *Engine::console;
  51. Position Engine::camera;
  52. Frustum *Engine::frustum;
  54. Bsp *Engine::bsp;
  56. int Engine::num_objects;
  57. Object **Engine::objects;
  59. int Engine::num_lights;
  60. Light **Engine::lights;
  61. int Engine::num_visible_lights;
  62. Light **Engine::visible_lights;
  63. Light *Engine::current_light;
  65. int Engine::num_fogs;
  66. Fog **Engine::fogs;
  67. int Engine::num_visible_fogs;
  68. Fog **Engine::visible_fogs;
  69. Fog *Engine::current_fog;
  71. int Engine::num_mirrors;
  72. Mirror **Engine::mirrors;
  73. int Engine::num_visible_mirrors;
  74. Mirror **Engine::visible_mirrors;
  75. Mirror *Engine::current_mirror;
  77. GLuint Engine::query_id;
  78. Mesh *Engine::sphere_mesh;
  80. Shader *Engine::shadow_volume_shader;
  82. float Engine::time;
  83. vec4 Engine::light;
  84. vec4 Engine::light_color;
  85. vec4 Engine::fog_color;
  86. int Engine::viewport[4];
  87. mat4 Engine::projection;
  88. mat4 Engine::modelview;
  89. mat4 Engine::imodelview;
  90. mat4 Engine::transform;
  91. mat4 Engine::itransform;
  93. float Engine::ifps;
  95. int Engine::frame;
  97. int Engine::num_triangles;
  99. int Engine::have_occlusion;
  100. int Engine::have_stencil_two_side;
  102. int Engine::wareframe_toggle;
  103. int Engine::scissor_toggle;
  104. int Engine::shadows_toggle;
  105. int Engine::show_shadows_toggle;
  106. int Engine::fog_toggle;
  107. int Engine::mirror_toggle;
  108. int Engine::physic_toggle;
  110. std::vector<char*> Engine::path;
  111. std::vector<char*> Engine::defines;
  113. int Engine::texture_filter = Texture::LINEAR_MIPMAP_LINEAR;
  115. std::map<std::string,Shader*> Engine::shaders;
  116. std::map<std::string,Texture*> Engine::textures;
  117. std::map<std::string,Material*> Engine::materials;
  118. std::map<std::string,Mesh*> Engine::meshes;
  120. void (*Engine::extern_load)(void*) = NULL;
  121. void *Engine::extern_load_data;
  123. int Engine::stderr_fd;
  125. /*****************************************************************************/
  126. /*                                                                           */
  127. /* console commands                                                          */
  128. /*                                                                           */
  129. /*****************************************************************************/
  131. static void define(int argc,char **argv,void*) {
  132. if(argc == 1) {
  133. Engine::console->printf("defines: ");
  134. for(int i = 0; i < (int)Engine::defines.size(); i++) {
  135. Engine::console->printf("%s%s",Engine::defines[i],i == (int)Engine::defines.size() - 1 ? "" : ", ");
  136. }
  137. Engine::console->printf("n");
  138. } else {
  139. for(int i = 1; i < argc; i++) Engine::define(argv[i]);
  140. }
  141. }
  143. static void undef(int argc,char **argv,void*) {
  144. if(argc == 1) Engine::console->printf("undef: missing argumentn");
  145. else {
  146. for(int i = 1; i < argc; i++) Engine::undef(argv[i]);
  147. }
  148. }
  150. static void load(int argc,char **argv,void*) {
  151. if(argc == 1) Engine::console->printf("load: missing argumentn");
  152. else Engine::load(argv[1]);
  153. }
  155. static void reload(int argc,char **argv,void*) {
  156. if(argc == 1) Engine::reload();
  157. else {
  158. if(!strcmp(argv[1],"shaders")) Engine::reload_shaders();
  159. else if(!strcmp(argv[1],"textures")) Engine::reload_textures();
  160. else if(!strcmp(argv[1],"materials")) Engine::reload_materials();
  161. else Engine::console->printf("reload: unknown argument (shaders, textures, materials)n");
  162. }
  163. }
  165. static void status(int,char**,void*) {
  166. Engine::console->printf("lights: %dnfogs: %dnmirrors: %dnobjects: %dn",
  167. Engine::num_lights,Engine::num_fogs,Engine::num_mirrors,Engine::num_objects);
  168. }
  170. static void extensions(int,char**,void*) {
  171. Engine::console->printf("%sn",Engine::extensions);
  172. }
  174. /*****************************************************************************/
  175. /*                                                                           */
  176. /* Engine                                                                    */
  177. /*                                                                           */
  178. /*****************************************************************************/
  180. /*
  181.  */
  182. int Engine::init(const char *config) {
  184. // bind system stderr to Engine::console
  185. #ifndef _WIN32
  186. int fd[2];
  187. pipe(fd);
  188. stderr_fd = fd[0];
  189. fcntl(stderr_fd,F_SETFL,O_NONBLOCK);
  190. stderr = fdopen(fd[1],"w");
  191. setbuf(stderr,NULL);
  192. #else
  193. HANDLE read,write;
  194. SECURITY_ATTRIBUTES security;
  196. security.nLength = sizeof(security);
  197. security.bInheritHandle = TRUE;
  198. security.lpSecurityDescriptor = NULL;
  200. CreatePipe(&read,&write,&security,1024 - 1);
  202. DWORD mode = PIPE_READMODE_BYTE | PIPE_NOWAIT;
  203. SetNamedPipeHandleState(read,&mode,NULL,NULL);
  204. SetNamedPipeHandleState(write,&mode,NULL,NULL);
  206. stderr_fd = _open_osfhandle((long)read,O_RDONLY | O_BINARY);
  207. FILE *file = fdopen(_open_osfhandle((long)write,O_WRONLY | O_BINARY),"w");
  208. *stderr = *file;
  209. setbuf(stderr,NULL);
  210. #endif
  212. // load config
  213. if(config) {
  214. FILE *file = fopen(config,"rb");
  215. if(!file) fprintf(stderr,"Engine::init(): error open "%s" filen",config);
  216. else {
  217. char buf[1024];
  218. while(fscanf(file,"%s",buf) == 1) {
  219. if(buf[0] == '#' || (buf[0] == '/' && buf[1] == '/')) while(fread(buf,1,1,file) == 1 && buf[0] != 'n');
  220. else if(!strcmp(buf,"screen_width")) fscanf(file,"%d",&screen_width);
  221. else if(!strcmp(buf,"screen_height")) fscanf(file,"%d",&screen_height);
  222. else if(!strcmp(buf,"screen_multisample")) fscanf(file,"%d",&screen_multisample);
  223. else if(!strcmp(buf,"texture_filter")) {
  224. texture_filter = 0;
  225. fgets(buf,sizeof(buf),file);
  226. char *s = buf;
  227. while(*s) {
  228. if(isalpha(*s)) {
  229. char *d = s;
  230. while(*d && !strchr(" tn",*d)) d++;
  231. if(*d) *d++ = '';
  232. if(!strcmp(s,"nearest")) texture_filter |= Texture::NEAREST;
  233. else if(!strcmp(s,"linear")) texture_filter |= Texture::LINEAR;
  234. else if(!strcmp(s,"nearest_mipmap_nearest")) texture_filter |= Texture::NEAREST_MIPMAP_NEAREST;
  235. else if(!strcmp(s,"linear_mipmap_nearest")) texture_filter |= Texture::LINEAR_MIPMAP_NEAREST;
  236. else if(!strcmp(s,"linear_mipmap_linear")) texture_filter |= Texture::LINEAR_MIPMAP_LINEAR;
  237. else if(!strcmp(s,"anisotropy_1")) texture_filter |= Texture::ANISOTROPY_1;
  238. else if(!strcmp(s,"anisotropy_2")) texture_filter |= Texture::ANISOTROPY_2;
  239. else if(!strcmp(s,"anisotropy_4")) texture_filter |= Texture::ANISOTROPY_4;
  240. else if(!strcmp(s,"anisotropy_8")) texture_filter |= Texture::ANISOTROPY_8;
  241. else if(!strcmp(s,"anisotropy_16")) texture_filter |= Texture::ANISOTROPY_16;
  242. s = d;
  243. }
  244. else if(strchr(" t",*s)) s++;
  245. else {
  246. fprintf(stderr,"Engine::init(): unknown token "%s" in "%s" filen",s,config);
  247. break;
  248. }
  249. }
  250. }
  251. else fprintf(stderr,"Engine::init(): unknown token "%s" in "%s" filen",buf,config);
  252. }
  253. }
  254. }
  256. // init OpenGL extensions win32 only
  257. #ifdef _WIN32
  258. glext_init();
  259. #endif
  261. // console
  262. FILE *log = fopen(ENGINE_LOG_NAME,"wb");
  263. console = new Console(findFile(ENGINE_FONT_NAME),log);
  265. console->printf(1,1,1,"3D Enginenhttp://frustum.orgnn");
  267. // renderer abilities
  268. vendor = (char*)glGetString(GL_VENDOR);
  269. renderer = (char*)glGetString(GL_RENDERER);
  270. version = (char*)glGetString(GL_VERSION);
  271. extensions = (char*)glGetString(GL_EXTENSIONS);
  273. console->printf("vendor: %snrenderer: %snversion: %snn",vendor,renderer,version);
  275. have_occlusion = 0;
  276. have_stencil_two_side = 0;
  278. wareframe_toggle = 0;
  279. scissor_toggle = 1;
  280. shadows_toggle = 1;
  281. show_shadows_toggle = 0;
  282. fog_toggle = 1;
  283. mirror_toggle = 1;
  284. physic_toggle = 1;
  286. if(!strstr(extensions,"GL_ARB_vertex_program")) { // fatal error
  287. console->printf("can`t find GL_ARB_vertex_program extension");
  288. return 0;
  289. }
  291. if(strstr(extensions,"GL_ARB_occlusion_query")) {
  292. have_occlusion = 1;
  293. console->printf("find GL_ARB_occlusion_query extensionn");
  294. }
  295. if(strstr(extensions,"GL_EXT_stencil_two_side")) {
  296. have_stencil_two_side = 1;
  297. console->printf("find GL_EXT_stencil_two_side extensionn");
  298. }
  299. if(strstr(extensions,"GL_NV_depth_clamp")) {
  300. define("DEPTH_CLAMP");
  301. console->printf("find GL_NV_depth_clamp extensionn");
  302. }
  304. if(strstr(extensions,"GL_NV_fragment_program")) { // nv3x cards
  305. define("NV3X");
  306. define("TEYLOR");
  307. define("OFFSET");
  308. define("HORIZON");
  309. console->printf("using GL_NV_fragment_program shaders coden");
  310. }
  311. else if(strstr(extensions,"GL_ARB_fragment_program")) { // radeons
  312. define("RADEON");
  313. define("TEYLOR");
  314. define("OFFSET");
  315. define("HORIZON");
  316. console->printf("using GL_ARB_fragment_program shaders coden");
  317. }
  318. else if(strstr(extensions,"GL_ARB_texture_env_combine")) { // hm
  319. define("VERTEX");
  320. if(!isDefine("DEPTH_CLAMP")) shadows_toggle = 0;
  321. fog_toggle = 0;
  322. mirror_toggle = 0;
  323. console->printf("using GL_ARB_texture_env_combine "shaders" coden");
  324. } else {
  325. console->printf("pls upgrade you video card...n");
  326. return 0;
  327. }
  329. console->addBool("wareframe",&wareframe_toggle);
  330. console->addBool("scissor",&scissor_toggle);
  331. console->addBool("shadows",&shadows_toggle);
  332. console->addBool("show_shadows",&show_shadows_toggle);
  333. console->addBool("fog",&fog_toggle);
  334. console->addBool("mirror",&mirror_toggle);
  335. console->addBool("physic",&physic_toggle);
  337. console->addCommand("define",::define,NULL);
  338. console->addCommand("undef",::undef,NULL);
  339. console->addCommand("load",::load,NULL);
  340. console->addCommand("reload",::reload,NULL);
  341. console->addCommand("extensions",::extensions,NULL);
  343. // screen
  344. if(screen_multisample == 1) screen = new PBuffer(screen_width,screen_height,PBuffer::RGB | PBuffer::DEPTH | PBuffer::STENCIL | PBuffer::MULTISAMPLE_2);
  345. else if(screen_multisample == 2) screen = new PBuffer(screen_width,screen_height,PBuffer::RGB | PBuffer::DEPTH | PBuffer::STENCIL | PBuffer::MULTISAMPLE_4);
  346. else screen = new PBuffer(screen_width,screen_height,PBuffer::RGB | PBuffer::DEPTH | PBuffer::STENCIL);
  347. screen->enable();
  348. glEnable(GL_DEPTH_TEST);
  349. glEnable(GL_CULL_FACE);
  350. screen->disable();
  351. screen_texture = new Texture(screen_width,screen_height,Texture::TEXTURE_2D,Texture::RGB | Texture::CLAMP | Texture::LINEAR);
  352. screen_material = loadMaterial(ENGINE_SCREEN_MATERIAL);
  354. // create new objects
  355. if(!frustum) frustum = new Frustum;
  357. bsp = NULL;
  359. num_objects = 0;
  360. objects = NULL;
  362. num_lights = 0;
  363. lights = NULL;
  364. num_visible_lights = 0;
  365. lights = NULL;
  367. num_fogs = 0;
  368. fogs = NULL;
  369. num_visible_fogs = 0;
  370. visible_fogs = NULL;
  372. num_mirrors = 0;
  373. mirrors = NULL;
  374. num_visible_mirrors = 0;
  375. visible_mirrors = NULL;
  377. glGenQueriesARB(1,&query_id);
  378. sphere_mesh = loadMesh(ENGINE_SPHERE_MESH);
  380. shadow_volume_shader = loadShader(ENGINE_SHADOW_VOLUME_SHADER);
  382. time = 0;
  383. frame = 0;
  385. console->printf("ninit okn");
  387. return 1;
  388. }
  390. /*
  391.  */
  392. void Engine::clear() {
  394. // objects
  395. if(num_objects) {
  396. for(int i = 0; i < num_objects; i++) delete objects[i];
  397. delete objects;
  398. objects = NULL;
  399. num_objects = 0;
  400. }
  402. // lights
  403. if(num_lights) {
  404. for(int i = 0; i < num_lights; i++) delete lights[i];
  405. delete lights;
  406. lights = NULL;
  407. num_lights = 0;
  408. delete visible_lights;
  409. visible_lights = NULL;
  410. num_visible_lights = 0;
  411. }
  413. // fogs
  414. if(num_fogs) {
  415. for(int i = 0; i < num_fogs; i++) delete fogs[i];
  416. delete fogs;
  417. fogs = NULL;
  418. num_fogs = 0;
  419. delete visible_fogs;
  420. visible_fogs = NULL;
  421. num_visible_fogs = 0;
  422. }
  424. // mirrors
  425. if(num_mirrors) {
  426. for(int i = 0; i < num_fogs; i++) delete mirrors[i];
  427. delete mirrors;
  428. mirrors = NULL;
  429. num_mirrors = 0;
  430. delete  visible_mirrors;
  431. visible_mirrors = NULL;
  432. num_visible_mirrors = 0;
  433. }
  435. // bsp at the end
  436. if(bsp) delete bsp;
  437. bsp = NULL;
  439. // shaders
  440. std::map<std::string,Shader*>::iterator shaders_it;
  441. for(shaders_it = shaders.begin(); shaders_it != shaders.end(); shaders_it++) delete shaders_it->second;
  442. shaders.clear();
  444. // textures
  445. std::map<std::string,Texture*>::iterator textures_it;
  446. for(textures_it = textures.begin(); textures_it != textures.end(); textures_it++) delete textures_it->second;
  447. textures.clear();
  449. // materials
  450. std::map<std::string,Material*>::iterator materials_it;
  451. for(materials_it = materials.begin(); materials_it != materials.end(); materials_it++) delete materials_it->second;
  452. materials.clear();
  454. // meshes
  455. std::map<std::string,Mesh*>::iterator meshes_it;
  456. for(meshes_it = meshes.begin(); meshes_it != meshes.end(); meshes_it++) delete meshes_it->second;
  457. meshes.clear();
  459. screen_material = loadMaterial(ENGINE_SCREEN_MATERIAL);
  460. sphere_mesh = loadMesh(ENGINE_SPHERE_MESH);
  461. shadow_volume_shader = loadShader(ENGINE_SHADOW_VOLUME_SHADER);
  462. }
  464. /*****************************************************************************/
  465. /*                                                                           */
  466. /* loaders                                                                   */
  467. /*                                                                           */
  468. /*****************************************************************************/
  470. /* support '|' as "OR" operation, '?' as ANY symbol and '*' as ANY string
  471.  */
  472. int Engine::match(const char *mask,const char *name) {
  473. char *m = (char*)mask;
  474. char *n = (char*)name;
  475. int match = 1;
  476. while(1) {
  477. if((match && *m == '*')|| *m == '') break;
  478. if(*m == '|') {
  479. if(match) break;
  480. m++;
  481. n = (char*)name;
  482. match = 1;
  483. } else {
  484. if(*m != '?' && *m != *n) match = 0;
  485. if(*n) n++;
  486. m++;
  487. }
  488. }
  489. return match;
  490. }
  492. /*
  493.  */
  494. void Engine::addPath(const char *path) {
  495. char *s = (char*)path;
  496. while(1) {
  497. char *p = new char[strlen(s) + 1];
  498. char *d = p;
  499. while(*s != '' && *s != ',') *d++ = *s++;
  500. *d = '';
  501. Engine::path.push_back(p);
  502. if(*s == '') break;
  503. else s++;
  504. }
  505. }
  507. const char *Engine::findFile(const char *name) {
  508. static char buf[1024];
  509. for(char *s = (char*)name; *s != ''; s++) {
  510. if(*s == '%' && *(s + 1) == 's') {
  511. static char complex_name[1024];
  512. sprintf(complex_name,name,"px");
  513. s = (char*)findFile(complex_name);
  514. if(strcmp(s,name)) {
  515. for(s = buf + strlen(buf); s > buf; s--) {
  516. if(*s == 'x' && *(s - 1) == 'p') {
  517. *s = 's';
  518. *(s - 1) = '%';
  519. break;
  520. }
  521. }
  522. return buf; // hm
  523. }
  524. break;
  525. }
  526. }
  527. for(int i = (int)path.size() - 1; i >= -1; i--) {
  528. if(i == -1) sprintf(buf,"%s",name);
  529. else sprintf(buf,"%s%s",path[i],name);
  530. FILE *file = fopen(buf,"rb");
  531. if(file) {
  532. fclose(file);
  533. return buf;
  534. }
  535. }
  536. fprintf(stderr,"Engine::findFile(): can`t find "%s" filen",name);
  537. return name;
  538. }
  540. /*
  541.  */
  542. void Engine::define(const char *define) {
  543. int i;
  544. for(i = 0; i < (int)defines.size(); i++) if(!strcmp(defines[i],define)) break;
  545. if(i == (int)defines.size()) {
  546. char *d = new char[strlen(define) + 1];
  547. strcpy(d,define);
  548. defines.push_back(d);
  549. }
  550. }
  552. void Engine::undef(const char *define) {
  553. for(int i = 0; i < (int)defines.size(); i++) {
  554. if(!strcmp(defines[i],define)) {
  555. delete defines[i];
  556. defines.erase(defines.begin() + i);
  557. }
  558. }
  559. }
  561. int Engine::isDefine(const char *define) {
  562. for(int i = 0; i < (int)defines.size(); i++) if(!strcmp(defines[i],define)) return 1;
  563. return 0;
  564. }
  566. /*
  567.  */
  568. void Engine::load(const char *name) {
  569. clear();
  570. Map::load(findFile(name));
  571. if(extern_load) extern_load(extern_load_data);
  572. console->printf("load "%s" okn",name);
  573. }
  575. /*
  576.  */
  577. Shader *Engine::loadShader(const char *name) {
  578. std::map<std::string,Shader*>::iterator it = shaders.find(name);
  579. if(it == shaders.end()) {
  580. Shader *shader = new Shader(findFile(name));
  581. shaders[name] = shader;
  582. return shader;
  583. }
  584. return it->second;
  585. }
  587. Texture *Engine::loadTexture(const char *name,GLuint target,int flag) {
  588. std::map<std::string,Texture*>::iterator it = textures.find(name);
  589. if(it == textures.end()) {
  590. Texture *texture = new Texture(findFile(name),target,flag);
  591. textures[name] = texture;
  592. return texture;
  593. }
  594. return it->second;
  595. }
  597. Material *Engine::loadMaterial(const char *name) {
  598. std::map<std::string,Material*>::iterator it = materials.find(name);
  599. if(it == materials.end()) {
  600. Material *material = new Material(findFile(name));
  601. materials[name] = material;
  602. return material;
  603. }
  604. return it->second;
  605. }
  607. Mesh *Engine::loadMesh(const char *name) {
  608. std::map<std::string,Mesh*>::iterator it = meshes.find(name);
  609. if(it == meshes.end()) {
  610. Mesh *mesh = new MeshVBO(findFile(name));
  611. meshes[name] = mesh;
  612. return mesh;
  613. }
  614. return it->second;
  615. }
  617. /* reload functions
  618.  */
  619. void Engine::reload() {
  620. reload_shaders();
  621. reload_textures();
  622. reload_materials();
  623. }
  625. void Engine::reload_shaders() {
  626. std::map<std::string,Shader*>::iterator it;
  627. for(it = shaders.begin(); it != shaders.end(); it++) {
  628. it->second->~Shader();
  629. it->second->load(findFile(it->first.c_str()));
  630. }
  631. }
  633. void Engine::reload_textures() {
  634. std::map<std::string,Texture*>::iterator it;
  635. for(it = textures.begin(); it != textures.end(); it++) {
  636. it->second->~Texture();
  637. it->second->load(findFile(it->first.c_str()),it->second->target,it->second->flag);
  638. }
  639. }
  641. void Engine::reload_materials() {
  642. std::map<std::string,Material*>::iterator it;
  643. for(it = materials.begin(); it != materials.end(); it++) {
  644. it->second->~Material();
  645. it->second->load(findFile(it->first.c_str()));
  646. }
  647. }
  649. void Engine::setExternLoad(void (*func)(void*),void *data) {
  650. extern_load = func;
  651. extern_load_data = data;
  652. }
  654. /* objects managment
  655.  */
  656. void Engine::addObject(Object *object) {
  657. if(num_objects % ENGINE_GAP_SIZE == 0) {
  658. Object **objects = new Object*[num_objects + ENGINE_GAP_SIZE];
  659. for(int i = 0; i < num_objects; i++) objects[i] = Engine::objects[i];
  660. if(Engine::objects) delete Engine::objects;
  661. Engine::objects = objects;
  662. }
  663. object->update(0.0);
  664. objects[num_objects++] = object;
  665. }
  667. void Engine::removeObject(Object *object) {
  668. if(object->pos.sector != -1) Bsp::sectors[object->pos.sector].removeObject(object);
  669. for(int i = 0; i < num_objects; i++) {
  670. if(objects[i] == object) {
  671. num_objects--;
  672. for(; i < num_objects; i++) objects[i] = objects[i + 1];
  673. return;
  674. }
  675. }
  676. }
  678. /*
  679.  */
  680. void Engine::addLight(Light *light) {
  681. if(num_lights % ENGINE_GAP_SIZE == 0) {
  682. Light **lights = new Light*[num_lights + ENGINE_GAP_SIZE];
  683. for(int i = 0; i < num_lights; i++) lights[i] = Engine::lights[i];
  684. if(Engine::lights) delete Engine::lights;
  685. Engine::lights = lights;
  686. if(visible_lights) delete visible_lights;
  687. visible_lights = new Light*[num_lights + ENGINE_GAP_SIZE];
  688. }
  689. light->update(0.0);
  690. lights[num_lights++] = light;
  691. }
  693. void Engine::removeLight(Light *light) {
  694. for(int i = 0; i < num_lights; i++) {
  695. if(lights[i] == light) {
  696. num_lights--;
  697. for(; i < num_lights; i++) lights[i] = lights[i + 1];
  698. return;
  699. }
  700. }
  701. }
  703. /*
  704.  */
  705. void Engine::addFog(Fog *fog) {
  706. if(num_fogs % ENGINE_GAP_SIZE == 0) {
  707. Fog **fogs = new Fog*[num_fogs + ENGINE_GAP_SIZE];
  708. for(int i = 0; i < num_fogs; i++) fogs[i] = Engine::fogs[i];
  709. if(Engine::fogs) delete Engine::fogs;
  710. Engine::fogs = fogs;
  711. if(visible_fogs) delete visible_fogs;
  712. visible_fogs = new Fog*[num_lights + ENGINE_GAP_SIZE];
  713. }
  714. fogs[num_fogs++] = fog;
  715. }
  717. void Engine::removeFog(Fog *fog) {
  718. for(int i = 0; i < num_fogs; i++) {
  719. if(fogs[i] == fog) {
  720. num_fogs--;
  721. for(; i < num_fogs; i++) fogs[i] = fogs[i + 1];
  722. return;
  723. }
  724. }
  725. }
  727. /*
  728.  */
  729. void Engine::addMirror(Mirror *mirror) {
  730. if(num_mirrors % ENGINE_GAP_SIZE == 0) {
  731. Mirror **mirrors = new Mirror*[num_mirrors + ENGINE_GAP_SIZE];
  732. for(int i = 0; i < num_mirrors; i++) mirrors[i] = Engine::mirrors[i];
  733. if(Engine::mirrors) delete Engine::mirrors;
  734. Engine::mirrors = mirrors;
  735. if(visible_mirrors) delete visible_mirrors;
  736. visible_mirrors = new Mirror*[num_mirrors + ENGINE_GAP_SIZE];
  737. }
  738. mirrors[num_mirrors++] = mirror;
  739. }
  741. void Engine::removeMirror(Mirror *mirror) {
  742. for(int i = 0; i < num_mirrors; i++) {
  743. if(mirrors[i] == mirror) {
  744. num_mirrors--;
  745. for(; i < num_mirrors; i++) mirrors[i] = mirrors[i + 1];
  746. return;
  747. }
  748. }
  749. }
  751. /*****************************************************************************/
  752. /*                                                                           */
  753. /* update                                                                    */
  754. /*                                                                           */
  755. /*****************************************************************************/
  757. void Engine::update(float ifps) {
  759. Engine::ifps = ifps;
  761. // new frame
  762. frame++;
  764. // read stderr
  765. char buf[1024];
  766. while(1) {
  767. int ret = read(stderr_fd,buf,sizeof(buf));
  768. if(ret > 0) {
  769. buf[ret] = '';
  770. console->printf(1,0,0,"%s",buf);
  771. if(console->getActivity() == 0) console->keyPress('`');
  772. } else break;
  773. }
  775. // update time
  776. time += ifps;
  778. // update lights
  779. for(int i = 0; i < num_visible_lights; i++) {
  780. visible_lights[i]->update(ifps);
  781. }
  783. // update objects
  784. Object *objects[Sector::NUM_OBJECTS];
  785. for(int i = 0; i < Bsp::num_visible_sectors; i++) {
  786. Sector *s = Bsp::visible_sectors[i];
  787. for(int j = 0; j < s->num_objects; j++) objects[j] = s->objects[j];
  788. int num_objects = s->num_objects;
  789. for(int j = 0; j < num_objects; j++) {
  790. Object *o = objects[j];
  791. if(o->frame == -Engine::frame) continue;
  792. o->update(ifps);
  793. o->frame = -Engine::frame;
  794. }
  795. }
  796. }
  798. /*****************************************************************************/
  799. /*                                                                           */
  800. /* renderers                                                                 */
  801. /*                                                                           */
  802. /*****************************************************************************/
  804. /* main bottleneck :)
  805.  */
  806. void Engine::render_light() {
  808. glDepthMask(GL_FALSE);
  810. if(have_occlusion) {
  811. glDisable(GL_CULL_FACE);
  812. glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
  813. }
  815. // find visible lights
  816. num_visible_lights = 0;
  817. for(int i = 0; i < num_lights; i++) {
  818. Light *l = lights[i];
  819. for(int j = 0; j < l->pos.num_sectors; j++) {
  820. if(Bsp::sectors[l->pos.sectors[j]].frame != frame) continue;
  822. if(frustum->inside(l->pos,l->radius) == 0) continue;
  824. if(have_occlusion && (l->pos - camera).length() > l->radius) {
  825. glPushMatrix();
  826. glTranslatef(l->pos.x,l->pos.y,l->pos.z);
  827. glScalef(l->radius,l->radius,l->radius);
  828. glBeginQueryARB(GL_SAMPLES_PASSED_ARB,query_id);
  829. sphere_mesh->render();
  830. glEndQueryARB(GL_SAMPLES_PASSED_ARB);
  831. glPopMatrix();
  833. GLuint samples;
  834. glGetQueryObjectuivARB(query_id,GL_QUERY_RESULT_ARB,&samples);
  835. if(samples == 0) continue;
  836. }
  838. visible_lights[num_visible_lights++] = l;
  839. break;
  840. }
  841. }
  843. // find visible fogs
  844. num_visible_fogs = 0;
  845. if(fog_toggle) {
  846. for(int i = 0; i < num_fogs; i++) {
  847. Fog *fog = fogs[i];
  848. for(int j = 0; j < fog->pos.num_sectors; j++) {
  849. if(Bsp::sectors[fog->pos.sectors[j]].frame != frame) continue;
  851. if(frustum->inside(fog->getMin(),fog->getMax()) == 0) continue;
  853. if(have_occlusion && !fog->inside(camera)) {
  854. glBeginQueryARB(GL_SAMPLES_PASSED_ARB,query_id);
  855. fog->mesh->render();
  856. glEndQueryARB(GL_SAMPLES_PASSED_ARB);
  858. GLuint samples;
  859. glGetQueryObjectuivARB(query_id,GL_QUERY_RESULT_ARB,&samples);
  860. if(samples == 0) continue;
  861. }
  863. visible_fogs[num_visible_fogs++] = fog;
  864. break;
  865. }
  866. }
  867. }
  869. if(have_occlusion) {
  870. glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
  871. glEnable(GL_CULL_FACE);
  872. }
  874. if(scissor_toggle) glEnable(GL_SCISSOR_TEST);
  876. if(shadows_toggle) glEnable(GL_STENCIL_TEST);
  878. // render lights
  879. for(int i = 0; i < num_visible_lights; i++) {
  881. Light *l = visible_lights[i];
  882. current_light = l;
  884. light = vec4(l->pos,1.0 / (l->radius * l->radius));
  885. light_color = l->color;
  887. int stencil_value = 0;
  889. // scissor
  890. int scissor[4];
  891. l->getScissor(scissor);
  892. if(scissor_toggle) glScissor(scissor[0],scissor[1],scissor[2],scissor[3]);
  894. // shadows
  895. if(shadows_toggle && l->shadows) {
  897. if(show_shadows_toggle) {
  898. glEnable(GL_BLEND);
  899. glBlendFunc(GL_ONE,GL_ONE);
  900. } else {
  901. glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
  902. }
  904. // shadow volume extrusion and depth clamp on ATI
  905. shadow_volume_shader->enable();
  906. shadow_volume_shader->bind();
  908. // depth clamp extension
  909. if(isDefine("NV3X")) glEnable(GL_DEPTH_CLAMP_NV);
  911. if(have_stencil_two_side) {
  912. glDisable(GL_CULL_FACE);
  913. glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
  915. glActiveStencilFaceEXT(GL_BACK);
  916. glStencilFunc(GL_ALWAYS,0,~0);
  917. glStencilOp(GL_KEEP,GL_KEEP,GL_INCR_WRAP);
  918. glActiveStencilFaceEXT(GL_FRONT);
  919. glStencilFunc(GL_ALWAYS,0,~0);
  920. glStencilOp(GL_KEEP,GL_KEEP,GL_DECR_WRAP);
  921. }
  923. // shadow volumes
  924. for(int i = 0; i < l->pos.num_sectors; i++) {
  925. Sector *s = &Bsp::sectors[l->pos.sectors[i]];
  926. if(s->portal) frustum->addPortal(camera,s->portal->points);
  928. // static objects
  929. for(int j = 0; j < s->num_node_objects; j++) {
  930. Object *o = s->node_objects[j];
  931. if(o->shadows == 0) continue;
  932. for(int i = 0; i < o->num_opacities; i++) {
  933. int j = o->opacities[i];
  934. if(o->materials[j]->alpha_test) continue;
  935. if(frustum->inside(light,l->radius,o->getCenter(j),o->getRadius(j)) == 0) continue;
  937. glFlush();
  939. o->findSilhouette(vec4(light,1),j);
  940. stencil_value += o->getNumIntersections(light,camera,j);
  942. if(have_stencil_two_side) {
  943. num_triangles += o->renderShadowVolume(j);
  944. } else {
  945. glCullFace(GL_FRONT);
  946. glStencilFunc(GL_ALWAYS,0,~0);
  947. glStencilOp(GL_KEEP,GL_KEEP,GL_INCR_WRAP);
  948. num_triangles += o->renderShadowVolume(j);
  950. glCullFace(GL_BACK);
  951. glStencilFunc(GL_ALWAYS,0,~0);
  952. glStencilOp(GL_KEEP,GL_KEEP,GL_DECR_WRAP);
  953. num_triangles += o->renderShadowVolume(j);
  954. }
  955. }
  956. }
  958. // dynamic objects
  959. for(int j = 0; j < s->num_objects; j++) {
  960. Object *o = s->objects[j];
  961. if(o->shadows == 0) continue;
  962. // object may be present in many sectors
  963. if(o->pos.sector != l->pos.sectors[i]) continue;
  964. o->enable();
  965. vec3 icamera = itransform * camera;
  966. vec3 ilight = itransform * vec3(light);
  967. for(int i = 0; i < o->num_opacities; i++) {
  968. int j = o->opacities[i];
  969. if(o->materials[j]->alpha_test) continue;
  970. if(frustum->inside(light,l->radius,o->pos + o->getCenter(j),o->getRadius(j)) == 0) continue;
  972. glFlush();
  974. o->findSilhouette(vec4(ilight,1),j);
  975. stencil_value += o->getNumIntersections(ilight,icamera,j);
  977. if(have_stencil_two_side) {
  978. num_triangles += o->renderShadowVolume(j);
  979. } else {
  980. glCullFace(GL_FRONT);
  981. glStencilFunc(GL_ALWAYS,0,~0);
  982. glStencilOp(GL_KEEP,GL_KEEP,GL_INCR_WRAP);
  983. num_triangles += o->renderShadowVolume(j);
  985. glCullFace(GL_BACK);
  986. glStencilFunc(GL_ALWAYS,0,~0);
  987. glStencilOp(GL_KEEP,GL_KEEP,GL_DECR_WRAP);
  988. num_triangles += o->renderShadowVolume(j);
  989. }
  990. }
  991. o->disable();
  992. }
  994. if(s->portal) frustum->removePortal();
  995. }
  997. if(have_stencil_two_side) {
  998. glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
  999. glEnable(GL_CULL_FACE);
  1000. }
  1002. if(isDefine("NV3X")) glDisable(GL_DEPTH_CLAMP_NV);
  1004. shadow_volume_shader->disable();
  1006. if(show_shadows_toggle) {
  1007. glDisable(GL_BLEND);
  1008. } else {
  1009. glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
  1010. }
  1012. if((camera.sector == -1 || Bsp::sectors[camera.sector].inside(camera) == 0) && --stencil_value < 0) stencil_value = 0;
  1014. glStencilOp(GL_KEEP,GL_KEEP,GL_KEEP);
  1015. glStencilFunc(GL_EQUAL,stencil_value,~0);
  1016. }
  1018. if(shadows_toggle && l->shadows == 0) glDisable(GL_STENCIL_TEST);
  1020. glDepthFunc(GL_EQUAL);
  1021. glEnable(GL_BLEND);
  1022. glBlendFunc(GL_ONE,GL_ONE);
  1024. // all visible opacitie objects
  1025. for(int i = 0; i < Bsp::num_visible_sectors; i++) {
  1026. Sector *s = Bsp::visible_sectors[i];
  1027. Portal *p = (s->frame == Engine::frame) ? s->portal : NULL;
  1028. if(p) {
  1029. int portal_scissor[4];
  1030. p->getScissor(portal_scissor);
  1031. portal_scissor[2] += portal_scissor[0];
  1032. portal_scissor[3] += portal_scissor[1];
  1033. if(portal_scissor[0] < scissor[0]) portal_scissor[0] = scissor[0];
  1034. if(portal_scissor[1] < scissor[1]) portal_scissor[1] = scissor[1];
  1035. if(portal_scissor[2] > scissor[0] + scissor[2]) portal_scissor[2] = scissor[0] + scissor[2];
  1036. if(portal_scissor[3] > scissor[1] + scissor[3]) portal_scissor[3] = scissor[1] + scissor[3];
  1037. portal_scissor[2] -= portal_scissor[0];
  1038. portal_scissor[3] -= portal_scissor[1];
  1039. if(portal_scissor[2] < 0 || portal_scissor[3] < 0) continue;
  1040. if(scissor_toggle) glScissor(portal_scissor[0],portal_scissor[1],portal_scissor[2],portal_scissor[3]);
  1041. } else {
  1042. if(scissor_toggle) glScissor(scissor[0],scissor[1],scissor[2],scissor[3]);
  1043. }
  1044. for(int j = 0; j < s->num_visible_objects; j++) {
  1045. Object *o = s->visible_objects[j];
  1046. if((o->pos + o->getCenter() - light).length() < o->getRadius() + l->radius) {
  1047. num_triangles += o->render(Object::RENDER_OPACITY);
  1048. }
  1049. }
  1050. }
  1052. if(scissor_toggle) glScissor(viewport[0],viewport[1],viewport[2],viewport[3]);
  1054. // mirrors
  1055. for(int i = 0; i < num_visible_mirrors; i++) {
  1056. if(visible_mirrors[i]->material && visible_mirrors[i]->material->blend == 0) {
  1057. visible_mirrors[i]->render();
  1058. }
  1059. }
  1061. // disable material
  1062. if(Material::old_material) Material::old_material->disable();
  1064. glDisable(GL_BLEND);
  1065. glDepthFunc(GL_LEQUAL);
  1067. if(shadows_toggle && l->shadows == 0) glEnable(GL_STENCIL_TEST);
  1069. // clear stensil only if it is needed
  1070. if(l != visible_lights[num_visible_lights - 1]) glClear(GL_STENCIL_BUFFER_BIT);
  1071. }
  1072. current_light = NULL;
  1074. if(shadows_toggle) glDisable(GL_STENCIL_TEST);
  1076. if(scissor_toggle) {
  1077. glScissor(viewport[0],viewport[1],viewport[2],viewport[3]);
  1078. glDisable(GL_SCISSOR_TEST);
  1079. }
  1081. glDepthMask(GL_TRUE);
  1082. }
  1084. /*
  1085.  */
  1086. void Engine::render_transparent() {
  1088. glDepthMask(GL_FALSE);
  1090. // volume fogs
  1091. if(fog_toggle) {
  1092. for(int i = 0; i < num_visible_fogs; i++) {
  1093. Fog *fog = visible_fogs[i];
  1094. current_fog = fog;
  1096. fog->enable();
  1097. // all visible objects
  1098. for(int i = 0; i < Bsp::num_visible_sectors; i++) {
  1099. Sector *s = Bsp::visible_sectors[i];
  1100. for(int j = 0; j < s->num_visible_objects; j++) {
  1101. Object *o = s->visible_objects[j];
  1102. if((o->pos + o->getCenter() - fog->getCenter()).length() < o->getRadius() + fog->getRadius()) {
  1103. num_triangles += o->render(Object::RENDER_ALL);
  1104. }
  1105. }
  1106. }
  1107. fog->disable();
  1109. num_triangles += fog->render();
  1110. }
  1111. }
  1112. current_fog = NULL;
  1114. glEnable(GL_BLEND);
  1115. glDisable(GL_CULL_FACE);
  1117. // transparent objects
  1118. // ambient shader
  1119. int save_num_visible_lights = num_visible_lights;
  1120. num_visible_lights = 0;
  1122. for(int i = 0; i < num_visible_mirrors; i++) {
  1123. if(visible_mirrors[i]->material && visible_mirrors[i]->material->blend == 1) {
  1124. visible_mirrors[i]->render();
  1125. }
  1126. }
  1128. for(int i = Bsp::num_visible_sectors - 1; i >= 0; i--) {
  1129. Sector *s = Bsp::visible_sectors[i];
  1130. for(int j = 0; j < s->num_visible_objects; j++) {
  1131. Object *o = s->visible_objects[j];
  1132. num_triangles += o->render(Object::RENDER_TRANSPARENT);
  1133. }
  1134. }
  1136. // light shader
  1137. num_visible_lights = save_num_visible_lights;
  1139. for(int i = 0; i < num_visible_mirrors; i++) {
  1140. if(visible_mirrors[i]->material && visible_mirrors[i]->material->blend == 1) {
  1141. visible_mirrors[i]->render();
  1142. }
  1143. }
  1145. for(int i = 0; i < num_visible_lights; i++) {
  1146. Light *l = visible_lights[i];
  1147. current_light = l;
  1149. light = vec4(l->pos,1.0 / (l->radius * l->radius));
  1150. light_color = l->color;
  1152. for(int i = Bsp::num_visible_sectors - 1; i >= 0; i--) {
  1153. Sector *s = Bsp::visible_sectors[i];
  1154. for(int j = 0; j < s->num_visible_objects; j++) {
  1155. Object *o = s->visible_objects[j];
  1156. if((o->pos + o->getCenter() - light).length() < o->getRadius() + l->radius) {
  1157. num_triangles += o->render(Object::RENDER_TRANSPARENT);
  1158. }
  1159. }
  1160. }
  1161. }
  1162. current_light = NULL;
  1164. // disable all materials
  1165. if(Material::old_material) Material::old_material->disable();
  1167. glEnable(GL_CULL_FACE);
  1168. glDisable(GL_BLEND);
  1170. glDepthMask(GL_TRUE);
  1171. }
  1173. /*
  1174.  */
  1175. void Engine::render(float ifps) {
  1177. // get matrixes
  1178. glGetFloatv(GL_PROJECTION_MATRIX,projection);
  1179. glGetFloatv(GL_MODELVIEW_MATRIX,modelview);
  1180. imodelview = modelview.inverse();
  1182. transform.identity();
  1183. itransform.identity();
  1185. // get camera
  1186. camera = imodelview * vec3(0,0,0);
  1188. // set frustum
  1189. frustum->set(projection * modelview);
  1191. // global triangle counter
  1192. num_triangles = 0;
  1194. /* render to pbuffer
  1195.  */
  1196. screen->enable();
  1198. // get viewport
  1199. glGetIntegerv(GL_VIEWPORT,viewport);
  1201. // set matrixes
  1202. glMatrixMode(GL_PROJECTION);
  1203. glLoadMatrixf(projection);
  1204. glMatrixMode(GL_MODELVIEW);
  1205. glLoadMatrixf(modelview);
  1207. // ambient pass
  1208. // clear depth buffer
  1209. glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
  1210. glDepthFunc(GL_LESS);
  1212. // number of visible lights
  1213. // zero - ambient shader
  1214. num_visible_lights = 0;
  1216. // render bsp
  1217. if(bsp) bsp->render();
  1219. // disable material
  1220. if(Material::old_material) Material::old_material->disable();
  1222. // find visible mirrors
  1223. num_visible_mirrors = 0;
  1224. if(mirror_toggle) {
  1226. if(have_occlusion) {
  1227. glDisable(GL_CULL_FACE);
  1228. glDepthMask(GL_FALSE);
  1229. glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
  1230. }
  1232. for(int i = 0; i < num_mirrors; i++) {
  1233. Mirror *mirror = mirrors[i];
  1234. if(mirror->pos.sector == -1 || Bsp::sectors[mirror->pos.sector].frame != frame) continue;
  1236. if(frustum->inside(mirror->getMin(),mirror->getMax()) == 0) continue;
  1238. if(have_occlusion) {
  1239. glBeginQueryARB(GL_SAMPLES_PASSED_ARB,query_id);
  1240. mirror->mesh->render();
  1241. glEndQueryARB(GL_SAMPLES_PASSED_ARB);
  1243. GLuint samples;
  1244. glGetQueryObjectuivARB(query_id,GL_QUERY_RESULT_ARB,&samples);
  1245. if(samples == 0) continue;
  1246. }
  1248. visible_mirrors[num_visible_mirrors++] = mirror;
  1249. break;
  1250. }
  1252. if(have_occlusion) {
  1253. glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
  1254. glDepthMask(GL_TRUE);
  1255. glEnable(GL_CULL_FACE);
  1256. }
  1257. }
  1259. // render mirrors
  1260. if(num_visible_mirrors) {
  1262. // save state
  1263. if(bsp) bsp->saveState();
  1265. // without any mirrors
  1266. int save_num_visible_mirrors = num_visible_mirrors;
  1267. num_visible_mirrors = 0;
  1269. for(int i = 0; i < save_num_visible_mirrors; i++) {
  1271. frame++; // new frame
  1273. Mirror *mirror = visible_mirrors[i];
  1274. current_mirror = mirror;
  1276. mirror->enable();
  1278. // clear
  1279. glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
  1280. glDepthFunc(GL_LESS);
  1282. // ambient mirror pass
  1283. num_visible_lights = 0;
  1284. if(bsp) bsp->render();
  1286. // light mirror pass
  1287. render_light();
  1289. // transparent mirror pass
  1290. render_transparent();
  1292. mirror->disable();
  1293. }
  1295. num_visible_mirrors = save_num_visible_mirrors;
  1297. // restore state
  1298. if(bsp) bsp->restoreState(++frame);
  1299. }
  1300. current_mirror = NULL;
  1302. // ambient mirror pass
  1303. num_visible_lights = 0;
  1304. for(int i = 0; i < num_visible_mirrors; i++) {
  1305. if(visible_mirrors[i]->material && visible_mirrors[i]->material->blend == 0) {
  1306. visible_mirrors[i]->render();
  1307. }
  1308. }
  1310. // light pass
  1311. render_light();
  1313. // transparent pass
  1314. render_transparent();
  1316. // disable material
  1317. if(Material::old_material) Material::old_material->disable();
  1319. // wareframe
  1320. if(wareframe_toggle) {
  1321. glColor3f(0,1,0);
  1322. glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
  1323. glEnable(GL_POLYGON_OFFSET_LINE);
  1324. glPolygonOffset(-0.5,0.0);
  1325. for(int i = 0; i < Bsp::num_visible_sectors; i++) {
  1326. Sector *s = Bsp::visible_sectors[i];
  1327. for(int j = 0; j < s->num_visible_objects; j++) {
  1328. Object *o = s->visible_objects[j];
  1329. num_triangles += o->render(Object::RENDER_ALL);
  1330. }
  1331. }
  1332. glDisable(GL_POLYGON_OFFSET_LINE);
  1333. glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
  1334. }
  1336. glFlush();
  1338. /* calculate physics
  1339.  */
  1340. if(physic_toggle) Physic::update(Engine::ifps);
  1342. /* render light flares
  1343.  */
  1344. for(int i = 0; i < num_visible_lights; i++) {
  1345. visible_lights[i]->renderFlare();
  1346. }
  1348. /* disable pbuffer
  1349.  */
  1350. screen_texture->bind();
  1351. screen_texture->copy();
  1352. screen->disable();
  1354. // get viewport
  1355. glGetIntegerv(GL_VIEWPORT,viewport);
  1357. // postprocessing
  1358. glMatrixMode(GL_PROJECTION);
  1359. glLoadIdentity();
  1360. glOrtho(-1,1,-1,1,-1,1);
  1361. glMatrixMode(GL_MODELVIEW);
  1362. glLoadIdentity();
  1364. glDisable(GL_DEPTH_TEST);
  1365. glDepthMask(GL_FALSE);
  1367. screen_material->enable();
  1368. screen_material->bind();
  1369. screen_material->bindTexture(0,screen_texture);
  1370. screen_texture->render();
  1371. screen_material->disable();
  1373. // console
  1374. console->enable(viewport[2],viewport[3]);
  1375. console->render(ifps,40);
  1376. console->disable();
  1377. }
  1379. /*****************************************************************************/
  1380. /*                                                                           */
  1381. /*                                                                           */
  1382. /*                                                                           */
  1383. /*****************************************************************************/
  1385. /*
  1386.  */
  1387. Object *Engine::intersection(const vec3 &line0,const vec3 &line1,vec3 &point,vec3 &normal) {
  1388. vec3 p,n;
  1389. point = line1;
  1390. Object *object = NULL;
  1391. for(int i = 0; i < Bsp::num_visible_sectors; i++) {
  1392. Sector *s = Bsp::visible_sectors[i];
  1393. for(int j = 0; j < s->num_visible_objects; j++) {
  1394. Object *o = s->visible_objects[j];
  1395. if(o->is_identity) {
  1396. if(o->intersection(line0,point,p,n)) {
  1397. point = p;
  1398. normal = n;
  1399. object = o;
  1400. }
  1401. } else {
  1402. vec3 l0 = o->itransform * line0;
  1403. vec3 l1 = o->itransform * point;
  1404. if(o->intersection(l0,l1,p,n)) {
  1405. point = o->transform * p;
  1406. normal = o->transform.rotation() * n;
  1407. object = o;
  1408. }
  1409. }
  1410. }
  1411. }
  1412. return object;
  1413. }