- Timestamp:
- Jan 29, 2009, 7:12:27 PM (15 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
code/branches/buildsystem2/src/ogreceguirenderer/OgreCEGUIRenderer.cpp
r2569 r2602 1 1 /************************************************************************ 2 3 4 5 6 2 filename: OgreCEGUIRenderer.cpp 3 created: 11/5/2004 4 author: Paul D Turner 5 6 purpose: Implementation of Renderer class for Ogre engine 7 7 *************************************************************************/ 8 8 /************************************************************************* … … 44 44 { 45 45 /************************************************************************* 46 46 Constants definitions 47 47 *************************************************************************/ 48 48 const size_t OgreCEGUIRenderer::VERTEX_PER_QUAD = 6; … … 52 52 53 53 /************************************************************************* 54 54 Utility function to create a render operation and vertex buffer to render quads 55 55 *************************************************************************/ 56 56 static void createQuadRenderOp(Ogre::RenderOperation &d_render_op, … … 59 59 using namespace Ogre; 60 60 // Create and initialise the Ogre specific parts required for use in rendering later. 61 62 63 64 65 66 67 68 69 70 71 72 73 74 61 d_render_op.vertexData = new VertexData; 62 d_render_op.vertexData->vertexStart = 0; 63 64 // setup vertex declaration for the vertex format we use 65 VertexDeclaration* vd = d_render_op.vertexData->vertexDeclaration; 66 size_t vd_offset = 0; 67 vd->addElement(0, vd_offset, VET_FLOAT3, VES_POSITION); 68 vd_offset += VertexElement::getTypeSize(VET_FLOAT3); 69 vd->addElement(0, vd_offset, VET_COLOUR, VES_DIFFUSE); 70 vd_offset += VertexElement::getTypeSize(VET_COLOUR); 71 vd->addElement(0, vd_offset, VET_FLOAT2, VES_TEXTURE_COORDINATES); 72 73 // create hardware vertex buffer 74 d_buffer = HardwareBufferManager::getSingleton().createVertexBuffer(vd->getVertexSize(0), nquads, 75 75 HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE, false); 76 76 77 78 79 80 81 82 77 // bind vertex buffer 78 d_render_op.vertexData->vertexBufferBinding->setBinding(0, d_buffer); 79 80 // complete render operation basic initialisation 81 d_render_op.operationType = RenderOperation::OT_TRIANGLE_LIST; 82 d_render_op.useIndexes = false; 83 83 } 84 84 … … 92 92 93 93 /************************************************************************* 94 94 Constructor 95 95 *************************************************************************/ 96 96 OgreCEGUIRenderer::OgreCEGUIRenderer(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads) 97 97 { 98 99 } 100 101 102 /************************************************************************* 103 98 constructor_impl(window, queue_id, post_queue, max_quads); 99 } 100 101 102 /************************************************************************* 103 Constructor (specifying scene manager) 104 104 *************************************************************************/ 105 105 OgreCEGUIRenderer::OgreCEGUIRenderer(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads, Ogre::SceneManager* scene_manager) 106 106 { 107 108 109 110 111 } 112 113 114 /************************************************************************* 115 107 constructor_impl(window, queue_id, post_queue, max_quads); 108 109 // hook into ogre rendering system 110 setTargetSceneManager(scene_manager); 111 } 112 113 114 /************************************************************************* 115 Destructor 116 116 *************************************************************************/ 117 117 OgreCEGUIRenderer::~OgreCEGUIRenderer(void) 118 118 { 119 120 121 122 123 124 125 126 127 119 setTargetSceneManager(NULL); 120 121 if (d_ourlistener) 122 { 123 delete d_ourlistener; 124 } 125 126 // cleanup vertex data we allocated in constructor 127 destroyQuadRenderOp(d_render_op, d_buffer); 128 128 destroyQuadRenderOp(d_direct_render_op, d_direct_buffer); 129 129 130 131 } 132 133 134 /************************************************************************* 135 130 destroyAllTextures(); 131 } 132 133 134 /************************************************************************* 135 add's a quad to the list to be rendered 136 136 *************************************************************************/ 137 137 void OgreCEGUIRenderer::addQuad(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode) 138 138 { 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 139 // if not queueing, render directly (as in, right now!). This is used for the mouse cursor. 140 if (!d_queueing) 141 { 142 renderQuadDirect(dest_rect, z, tex, texture_rect, colours, quad_split_mode); 143 } 144 else 145 { 146 d_sorted = false; 147 QuadInfo quad; 148 149 // set quad position, flipping y co-ordinates, and applying appropriate texel origin offset 150 quad.position.d_left = dest_rect.d_left; 151 quad.position.d_right = dest_rect.d_right; 152 quad.position.d_top = d_display_area.getHeight() - dest_rect.d_top; 153 quad.position.d_bottom = d_display_area.getHeight() - dest_rect.d_bottom; 154 quad.position.offset(d_texelOffset); 155 156 // convert quad co-ordinates for a -1 to 1 co-ordinate system. 157 quad.position.d_left /= (d_display_area.getWidth() * 0.5f); 158 quad.position.d_right /= (d_display_area.getWidth() * 0.5f); 159 quad.position.d_top /= (d_display_area.getHeight() * 0.5f); 160 quad.position.d_bottom /= (d_display_area.getHeight() * 0.5f); 161 quad.position.offset(Point(-1.0f, -1.0f)); 162 163 quad.z = -1 + z; 164 quad.texture = ((OgreCEGUITexture*)tex)->getOgreTexture(); 165 quad.texPosition = texture_rect; 166 167 // covert colours for ogre, note that top / bottom are switched. 168 quad.topLeftCol = colourToOgre(colours.d_bottom_left); 169 quad.topRightCol = colourToOgre(colours.d_bottom_right); 170 quad.bottomLeftCol = colourToOgre(colours.d_top_left); 171 quad.bottomRightCol = colourToOgre(colours.d_top_right); 172 173 // set quad split mode 174 quad.splitMode = quad_split_mode; 175 176 d_quadlist.insert(quad); 177 } 178 178 } 179 179 … … 186 186 { 187 187 // Render if overlays enabled and the quad list is not empty 188 189 // ORXONOX CHANGE: Even render when OverlaysEnabled is deactivated 190 // The reason is that we don't want the HUD to be shown in the viewport of the 191 // GUI (uses its own viewport to be able render on top of all viewports). 192 // But since we don't use overlays in the GUI, it doesn't matter. 193 // ORXONOX REVERT: Changes are not in place anymore, but might be in the future! 194 if (d_render_sys->_getViewport()->getOverlaysEnabled() && !d_quadlist.empty()) 195 //if (!d_quadlist.empty()) 196 { 188 if (d_render_sys->_getViewport()->getOverlaysEnabled() && !d_quadlist.empty()) 189 { 197 190 /// Quad list needs to be sorted and thus the vertex buffer rebuilt. If not, we can 198 191 /// reuse the vertex buffer resulting in a nice speed gain. … … 319 312 /// Render the buffer 320 313 d_bufferPos = 0; 321 314 bool first = true; 322 315 323 316 // Iterate over each quad in the list and render it … … 332 325 const QuadInfo& quad = (*i); 333 326 if (d_currTexture != quad.texture) 334 327 { 335 328 /// If it has a different texture, render this quad in next operation 336 337 338 339 329 /// also need to reset render states 330 first = true; 331 break; 332 } 340 333 d_bufferPos += VERTEX_PER_QUAD; 341 334 } … … 343 336 /// Set texture, and do the render 344 337 d_render_sys->_setTexture(0, true, d_currTexture); 345 346 347 348 349 338 if (first) 339 { 340 initRenderStates(); 341 first = false; 342 } 350 343 d_render_sys->_render(d_render_op); 351 344 } 352 345 353 346 } 354 347 /// Count frames to check if utilization of vertex buffer was below half the capacity for 500,000 frames 355 348 if(d_bufferPos < d_buffer->getNumVertices()/2) … … 361 354 362 355 /************************************************************************* 363 356 clear the queue 364 357 *************************************************************************/ 365 358 void OgreCEGUIRenderer::clearRenderList(void) 366 359 { 367 368 369 } 370 371 372 /************************************************************************* 373 360 d_sorted = true; 361 d_quadlist.clear(); 362 } 363 364 365 /************************************************************************* 366 create an empty texture 374 367 *************************************************************************/ 375 368 Texture* OgreCEGUIRenderer::createTexture(void) 376 369 { 377 378 379 380 } 381 382 383 /************************************************************************* 384 370 OgreCEGUITexture* tex = new OgreCEGUITexture(this); 371 d_texturelist.push_back(tex); 372 return tex; 373 } 374 375 376 /************************************************************************* 377 create a texture and load it with the specified file. 385 378 *************************************************************************/ 386 379 Texture* OgreCEGUIRenderer::createTexture(const String& filename, const String& resourceGroup) 387 380 { 388 389 390 391 392 } 393 394 395 /************************************************************************* 396 381 OgreCEGUITexture* tex = (OgreCEGUITexture*)createTexture(); 382 tex->loadFromFile(filename, resourceGroup); 383 384 return tex; 385 } 386 387 388 /************************************************************************* 389 create a texture and set it to the specified size 397 390 *************************************************************************/ 398 391 Texture* OgreCEGUIRenderer::createTexture(float size) 399 392 { 400 401 402 403 404 } 405 406 407 /************************************************************************* 408 393 OgreCEGUITexture* tex = (OgreCEGUITexture*)createTexture(); 394 tex->setOgreTextureSize((uint)size); 395 396 return tex; 397 } 398 399 400 /************************************************************************* 401 destroy the given texture 409 402 *************************************************************************/ 410 403 void OgreCEGUIRenderer::destroyTexture(Texture* texture) 411 404 { 412 413 414 415 416 417 418 419 } 420 421 422 /************************************************************************* 423 405 if (texture != NULL) 406 { 407 OgreCEGUITexture* tex = (OgreCEGUITexture*)texture; 408 409 d_texturelist.remove(tex); 410 delete tex; 411 } 412 } 413 414 415 /************************************************************************* 416 destroy all textures still active 424 417 *************************************************************************/ 425 418 void OgreCEGUIRenderer::destroyAllTextures(void) 426 419 { 427 428 429 430 431 } 432 433 434 /************************************************************************* 435 420 while (!d_texturelist.empty()) 421 { 422 destroyTexture(*(d_texturelist.begin())); 423 } 424 } 425 426 427 /************************************************************************* 428 setup states etc 436 429 *************************************************************************/ 437 430 void OgreCEGUIRenderer::initRenderStates(void) 438 431 { 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 432 using namespace Ogre; 433 434 // set-up matrices 435 d_render_sys->_setWorldMatrix(Matrix4::IDENTITY); 436 d_render_sys->_setViewMatrix(Matrix4::IDENTITY); 437 d_render_sys->_setProjectionMatrix(Matrix4::IDENTITY); 438 439 // initialise render settings 440 d_render_sys->setLightingEnabled(false); 441 d_render_sys->_setDepthBufferParams(false, false); 442 d_render_sys->_setDepthBias(0, 0); 443 d_render_sys->_setCullingMode(CULL_NONE); 444 d_render_sys->_setFog(FOG_NONE); 445 d_render_sys->_setColourBufferWriteEnabled(true, true, true, true); 446 d_render_sys->unbindGpuProgram(GPT_FRAGMENT_PROGRAM); 447 d_render_sys->unbindGpuProgram(GPT_VERTEX_PROGRAM); 448 d_render_sys->setShadingType(SO_GOURAUD); 449 d_render_sys->_setPolygonMode(PM_SOLID); 450 451 // initialise texture settings 452 d_render_sys->_setTextureCoordCalculation(0, TEXCALC_NONE); 453 d_render_sys->_setTextureCoordSet(0, 0); 454 d_render_sys->_setTextureUnitFiltering(0, FO_LINEAR, FO_LINEAR, FO_POINT); 455 d_render_sys->_setTextureAddressingMode(0, d_uvwAddressMode); 456 d_render_sys->_setTextureMatrix(0, Matrix4::IDENTITY); 457 d_render_sys->_setAlphaRejectSettings(CMPF_ALWAYS_PASS, 0); 458 d_render_sys->_setTextureBlendMode(0, d_colourBlendMode); 459 d_render_sys->_setTextureBlendMode(0, d_alphaBlendMode); 460 d_render_sys->_disableTextureUnitsFrom(1); 461 462 // enable alpha blending 463 d_render_sys->_setSceneBlending(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA); 471 464 } 472 465 … … 474 467 475 468 /************************************************************************* 476 469 sort quads list according to texture 477 470 *************************************************************************/ 478 471 void OgreCEGUIRenderer::sortQuads(void) 479 472 { 480 481 482 483 473 if (!d_sorted) 474 { 475 d_sorted = true; 476 } 484 477 485 478 } … … 490 483 void OgreCEGUIRenderer::renderQuadDirect(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode) 491 484 { 492 // ORXONOX CHANGE: Even render when OverlaysEnabled is deactivated 493 // The reason is that we don't want the HUD to be shown in the viewport of the 494 // GUI (uses its own viewport to be able render on top of all viewports). 495 // But since we don't use overlays in the GUI, it doesn't matter. 496 // ORXONOX REVERT: Changes are not in place anymore, but might be in the future! 497 if (d_render_sys->_getViewport()->getOverlaysEnabled()) 498 //if (true) 499 { 500 z = -1 + z; 501 502 Rect final_rect; 503 504 // set quad position, flipping y co-ordinates, and applying appropriate texel origin offset 505 final_rect.d_left = dest_rect.d_left; 506 final_rect.d_right = dest_rect.d_right; 507 final_rect.d_top = d_display_area.getHeight() - dest_rect.d_top; 508 final_rect.d_bottom = d_display_area.getHeight() - dest_rect.d_bottom; 509 final_rect.offset(d_texelOffset); 510 511 // convert quad co-ordinates for a -1 to 1 co-ordinate system. 512 final_rect.d_left /= (d_display_area.getWidth() * 0.5f); 513 final_rect.d_right /= (d_display_area.getWidth() * 0.5f); 514 final_rect.d_top /= (d_display_area.getHeight() * 0.5f); 515 final_rect.d_bottom /= (d_display_area.getHeight() * 0.5f); 516 final_rect.offset(Point(-1.0f, -1.0f)); 517 518 // convert colours for ogre, note that top / bottom are switched. 485 if (d_render_sys->_getViewport()->getOverlaysEnabled()) 486 { 487 z = -1 + z; 488 489 Rect final_rect; 490 491 // set quad position, flipping y co-ordinates, and applying appropriate texel origin offset 492 final_rect.d_left = dest_rect.d_left; 493 final_rect.d_right = dest_rect.d_right; 494 final_rect.d_top = d_display_area.getHeight() - dest_rect.d_top; 495 final_rect.d_bottom = d_display_area.getHeight() - dest_rect.d_bottom; 496 final_rect.offset(d_texelOffset); 497 498 // convert quad co-ordinates for a -1 to 1 co-ordinate system. 499 final_rect.d_left /= (d_display_area.getWidth() * 0.5f); 500 final_rect.d_right /= (d_display_area.getWidth() * 0.5f); 501 final_rect.d_top /= (d_display_area.getHeight() * 0.5f); 502 final_rect.d_bottom /= (d_display_area.getHeight() * 0.5f); 503 final_rect.offset(Point(-1.0f, -1.0f)); 504 505 // convert colours for ogre, note that top / bottom are switched. 519 506 uint32 topLeftCol = colourToOgre(colours.d_bottom_left); 520 507 uint32 topRightCol = colourToOgre(colours.d_bottom_right); … … 522 509 uint32 bottomRightCol= colourToOgre(colours.d_top_right); 523 510 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 511 QuadVertex* buffmem = (QuadVertex*)d_direct_buffer->lock(Ogre::HardwareVertexBuffer::HBL_DISCARD); 512 513 // setup Vertex 1... 514 buffmem->x = final_rect.d_left; 515 buffmem->y = final_rect. d_bottom; 516 buffmem->z = z; 517 buffmem->diffuse = topLeftCol; 518 buffmem->tu1 = texture_rect.d_left; 519 buffmem->tv1 = texture_rect.d_bottom; 520 ++buffmem; 521 522 // setup Vertex 2... 523 524 // top-left to bottom-right diagonal 525 if (quad_split_mode == TopLeftToBottomRight) 526 { 527 buffmem->x = final_rect.d_right; 528 buffmem->y = final_rect.d_bottom; 529 buffmem->z = z; 530 buffmem->diffuse = topRightCol; 531 buffmem->tu1 = texture_rect.d_right; 532 buffmem->tv1 = texture_rect.d_bottom; 533 ++buffmem; 534 } 535 // bottom-left to top-right diagonal 536 else 537 { 538 buffmem->x = final_rect.d_right; 539 buffmem->y = final_rect.d_top; 540 buffmem->z = z; 541 buffmem->diffuse = bottomRightCol; 542 buffmem->tu1 = texture_rect.d_right; 543 buffmem->tv1 = texture_rect.d_top; 544 ++buffmem; 545 } 546 547 // setup Vertex 3... 548 buffmem->x = final_rect.d_left; 549 buffmem->y = final_rect.d_top; 550 buffmem->z = z; 551 buffmem->diffuse = bottomLeftCol; 552 buffmem->tu1 = texture_rect.d_left; 553 buffmem->tv1 = texture_rect.d_top; 554 ++buffmem; 555 556 // setup Vertex 4... 557 buffmem->x = final_rect.d_right; 558 buffmem->y = final_rect.d_bottom; 559 buffmem->z = z; 560 buffmem->diffuse = topRightCol; 561 buffmem->tu1 = texture_rect.d_right; 562 buffmem->tv1 = texture_rect.d_bottom; 563 ++buffmem; 564 565 // setup Vertex 5... 566 buffmem->x = final_rect.d_right; 567 buffmem->y = final_rect.d_top; 568 buffmem->z = z; 569 buffmem->diffuse = bottomRightCol; 570 buffmem->tu1 = texture_rect.d_right; 571 buffmem->tv1 = texture_rect.d_top; 572 ++buffmem; 573 574 // setup Vertex 6... 575 576 // top-left to bottom-right diagonal 577 if (quad_split_mode == TopLeftToBottomRight) 578 { 579 buffmem->x = final_rect.d_left; 580 buffmem->y = final_rect.d_top; 581 buffmem->z = z; 582 buffmem->diffuse = bottomLeftCol; 583 buffmem->tu1 = texture_rect.d_left; 584 buffmem->tv1 = texture_rect.d_top; 585 } 586 // bottom-left to top-right diagonal 587 else 588 { 589 buffmem->x = final_rect.d_left; 590 buffmem->y = final_rect.d_bottom; 591 buffmem->z = z; 592 buffmem->diffuse = topLeftCol; 593 buffmem->tu1 = texture_rect.d_left; 594 buffmem->tv1 = texture_rect.d_bottom; 595 } 596 597 d_direct_buffer->unlock(); 611 598 612 599 // 613 614 615 616 617 618 619 620 621 } 622 623 /************************************************************************* 624 625 600 // perform rendering... 601 // 602 d_render_sys->_setTexture(0, true, ((OgreCEGUITexture*)tex)->getOgreTexture()->getName()); 603 initRenderStates(); 604 d_direct_render_op.vertexData->vertexCount = VERTEX_PER_QUAD; 605 d_render_sys->_render(d_direct_render_op); 606 } 607 608 } 609 610 /************************************************************************* 611 convert ARGB colour value to whatever the Ogre render system is 612 expecting. 626 613 *************************************************************************/ 627 614 uint32 OgreCEGUIRenderer::colourToOgre(const colour& col) const 628 615 { 629 616 Ogre::ColourValue cv(col.getRed(), col.getGreen(), col.getBlue(), col.getAlpha()); 630 617 631 618 uint32 final; 632 633 634 635 } 636 637 638 /************************************************************************* 639 619 d_render_sys->convertColourValue(cv, &final); 620 621 return final; 622 } 623 624 625 /************************************************************************* 626 Set the scene manager to be used for rendering the GUI. 640 627 *************************************************************************/ 641 628 void OgreCEGUIRenderer::setTargetSceneManager(Ogre::SceneManager* scene_manager) 642 629 { 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 } 658 659 660 /************************************************************************* 661 630 // unhook from current scene manager. 631 if (d_sceneMngr != NULL) 632 { 633 d_sceneMngr->removeRenderQueueListener(d_ourlistener); 634 d_sceneMngr = NULL; 635 } 636 637 // hook new scene manager if that is not NULL 638 if (scene_manager != NULL) 639 { 640 d_sceneMngr = scene_manager; 641 d_sceneMngr->addRenderQueueListener(d_ourlistener); 642 } 643 644 } 645 646 647 /************************************************************************* 648 Set the target render queue for GUI rendering. 662 649 *************************************************************************/ 663 650 void OgreCEGUIRenderer::setTargetRenderQueue(Ogre::uint8 queue_id, bool post_queue) 664 651 { 665 666 667 668 669 670 671 672 673 674 } 675 676 677 /************************************************************************* 678 652 d_queue_id = queue_id; 653 d_post_queue = post_queue; 654 655 if (d_ourlistener != NULL) 656 { 657 d_ourlistener->setTargetRenderQueue(queue_id); 658 d_ourlistener->setPostRenderQueue(post_queue); 659 } 660 661 } 662 663 664 /************************************************************************* 665 perform main work of the constructor 679 666 *************************************************************************/ 680 667 void OgreCEGUIRenderer::constructor_impl(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads) 681 668 { 682 683 684 685 686 687 688 689 690 691 692 693 669 using namespace Ogre; 670 671 // initialise the renderer fields 672 d_queueing = true; 673 d_queue_id = queue_id; 674 d_currTexture.isNull(); 675 d_post_queue = post_queue; 676 d_sceneMngr = NULL; 677 d_bufferPos = 0; 678 d_sorted = true; 679 d_ogre_root = Root::getSingletonPtr(); 680 d_render_sys = d_ogre_root->getRenderSystem(); 694 681 // set ID string 695 682 d_identifierString = "CEGUI::OgreRenderer - Official Ogre based renderer module for CEGUI"; 696 683 697 684 // Create and initialise the Ogre specific parts required for use in rendering later. 698 685 // Main GUI 699 686 createQuadRenderOp(d_render_op, d_buffer, VERTEXBUFFER_INITIAL_CAPACITY); … … 703 690 createQuadRenderOp(d_direct_render_op, d_direct_buffer, VERTEX_PER_QUAD); 704 691 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 } 732 733 734 /************************************************************************* 735 692 // Discover display settings and setup d_display_area 693 d_display_area.d_left = 0; 694 d_display_area.d_top = 0; 695 d_display_area.d_right = window->getWidth(); 696 d_display_area.d_bottom = window->getHeight(); 697 698 // initialise required texel offset 699 d_texelOffset = Point((float)d_render_sys->getHorizontalTexelOffset(), -(float)d_render_sys->getVerticalTexelOffset()); 700 701 // create listener which will handler the rendering side of things for us. 702 d_ourlistener = new CEGUIRQListener(this, queue_id, post_queue); 703 704 // Initialise blending modes to be used. 705 d_colourBlendMode.blendType = Ogre::LBT_COLOUR; 706 d_colourBlendMode.source1 = Ogre::LBS_TEXTURE; 707 d_colourBlendMode.source2 = Ogre::LBS_DIFFUSE; 708 d_colourBlendMode.operation = Ogre::LBX_MODULATE; 709 710 d_alphaBlendMode.blendType = Ogre::LBT_ALPHA; 711 d_alphaBlendMode.source1 = Ogre::LBS_TEXTURE; 712 d_alphaBlendMode.source2 = Ogre::LBS_DIFFUSE; 713 d_alphaBlendMode.operation = Ogre::LBX_MODULATE; 714 715 d_uvwAddressMode.u = Ogre::TextureUnitState::TAM_CLAMP; 716 d_uvwAddressMode.v = Ogre::TextureUnitState::TAM_CLAMP; 717 d_uvwAddressMode.w = Ogre::TextureUnitState::TAM_CLAMP; 718 } 719 720 721 /************************************************************************* 722 Create a texture from an existing Ogre::TexturePtr object 736 723 *************************************************************************/ 737 724 Texture* OgreCEGUIRenderer::createTexture(Ogre::TexturePtr& texture) 738 725 { 739 740 741 742 743 744 745 746 747 748 } 749 750 /************************************************************************* 751 726 OgreCEGUITexture* t = (OgreCEGUITexture*)createTexture(); 727 728 if (!texture.isNull()) 729 { 730 t->setOgreTexture(texture); 731 } 732 733 return t; 734 735 } 736 737 /************************************************************************* 738 Create a resource provider object 752 739 *************************************************************************/ 753 740 ResourceProvider* OgreCEGUIRenderer::createResourceProvider(void) … … 762 749 void OgreCEGUIRenderer::setDisplaySize(const Size& sz) 763 750 { 764 765 766 767 768 769 770 771 772 } 773 774 /************************************************************************* 775 776 751 if (d_display_area.getSize() != sz) 752 { 753 d_display_area.setSize(sz); 754 755 EventArgs args; 756 fireEvent(EventDisplaySizeChanged, args, EventNamespace); 757 } 758 759 } 760 761 /************************************************************************* 762 Callback from Ogre invoked before other stuff in our target queue 763 is rendered 777 764 *************************************************************************/ 778 765 void CEGUIRQListener::renderQueueStarted(Ogre::uint8 id, const Ogre::String& invocation, 779 780 { 781 782 783 784 766 bool& skipThisQueue) 767 { 768 if ((!d_post_queue) && (d_queue_id == id)) 769 { 770 CEGUI::System::getSingleton().renderGUI(); 771 } 785 772 786 773 } … … 793 780 void CEGUIRQListener::renderQueueEnded(Ogre::uint8 id, const Ogre::String& invocation, bool& repeatThisQueue) 794 781 { 795 796 797 798 782 if ((d_post_queue) && (d_queue_id == id)) 783 { 784 CEGUI::System::getSingleton().renderGUI(); 785 } 799 786 800 787 }
Note: See TracChangeset
for help on using the changeset viewer.