Ignore:
Timestamp:
02/20/06 19:06:03 (19 years ago)
Author:
mattausch
Message:

added ogre dependencies and patched ogre sources

Location:
OGRE/trunk/ogre_changes/RenderSystems
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • OGRE/trunk/ogre_changes/RenderSystems/Direct3D7/include/OgreD3D7RenderWindow.h

    r153 r657  
    119119        */ 
    120120        void writeContentsToFile(const String& filename); 
    121  
     121        // DirectDraw Methods 
     122                void createDDSurfaces(void); 
     123                void releaseDDSurfaces(void); 
     124                void restoreDDSurfaces(void); 
     125                void createDepthBuffer(void); 
    122126#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    123127                uchar *getBufferContents(int &dimx, int &dimy); 
    … …  
    159163        LPDIRECT3DDEVICE7 mlpD3DDevice; 
    160164 
    161         // DirectDraw Methods 
    162         void createDDSurfaces(void); 
    163         void releaseDDSurfaces(void); 
    164         void restoreDDSurfaces(void); 
    165         void createDepthBuffer(void); 
    166165 
    167166        // Method for dealing with resize / move & 3d library 

  • OGRE/trunk/ogre_changes/RenderSystems/Direct3D7/include/OgreD3D7Texture.h

    r154 r657  
    5353        LPDIRECTDRAWSURFACE7 getDDSurface(void); 
    5454 
    55         /// @copydoc Texture::createInternalResources 
    56         void createInternalResources(void); 
    57  
    5855                /// @copydoc Texture::getBuffer 
    5956                HardwarePixelBufferSharedPtr getBuffer(size_t face, size_t mipmap); 
    … …  
    6360                static PixelFormat closestD3DXFormat( PixelFormat format ); 
    6461                static bool OgreFormat_to_DDPixelFormat( PixelFormat format, DDPIXELFORMAT & out ); 
     62 
     63                /// Restore this texture from a lost device 
     64                void restoreFromLostDevice(void); 
     65 
    6566    protected: 
    6667        IDirect3DDevice7 * mD3DDevice;       ///< A pointer to the Direct3D device. 
    … …  
    7172                typedef std::vector<HardwarePixelBufferSharedPtr> SurfaceList; 
    7273                SurfaceList                                             mSurfaceList; 
     74                /// Are we restoring from a lost device? 
     75                bool mRestoring; 
     76 
    7377         
    7478 
    7579        /// @copydoc Resource::loadImpl 
    7680        void loadImpl(void); 
    77         /// @copydoc Resource::unloadImpl 
    78         void unloadImpl(void); 
     81                /// @copydoc Texture::createInternalResourcesImpl 
     82                void createInternalResourcesImpl(void); 
     83        /// @copydoc Resource::freeInternalResourcesImpl 
     84        void freeInternalResourcesImpl(void); 
    7985                 
    8086                void createSurface2D(void); 

  • OGRE/trunk/ogre_changes/RenderSystems/Direct3D7/src/OgreD3D7RenderWindow.cpp

    r153 r657  
    9696                break; 
    9797 
    98             case WM_MOVE: 
    99                 // Move messages need to be tracked to update the screen rects 
    100                 // used for blitting the backbuffer to the primary. 
    101                 if(win->mActive && win->mReady) 
    102                     win->windowMovedOrResized(); 
    103                 break; 
    104  
    10598            case WM_ENTERSIZEMOVE: 
    10699                // Prevent rendering while moving / sizing 
    … …  
    113106                break; 
    114107 
     108            case WM_MOVE: 
    115109            case WM_SIZE: 
    116110                // Check to see if we are losing or gaining our window. Set the 
    … …  
    391385    void D3D7RenderWindow::swapBuffers(bool waitForVSync) 
    392386    { 
     387                if (!mlpDDSFront) 
     388                        return; 
     389 
    393390        HRESULT hr; 
    394391        DWORD flags; 
    … …  
    423420            { 
    424421                // Restore surfaces 
    425                 restoreDDSurfaces(); 
     422                //restoreDDSurfaces(); 
    426423            } 
    427424            else if (FAILED(hr)) 
    … …  
    539536        ddscaps.dwCaps = DDSCAPS_ZBUFFER; 
    540537 
     538                if (!mlpDDSBack->IsLost()) 
     539                { 
    541540        LPDIRECTDRAWSURFACE7 zBufSurface; 
    542541 
    … …  
    546545        zBufSurface->Release(); 
    547546        zBufSurface->Release(); 
     547                } 
    548548 
    549549        // Release std buffers 
    … …  
    563563 
    564564            if( FAILED( hr ) ) 
     565                        { 
     566                                if (hr == DDERR_WRONGMODE) 
     567                                { 
     568                                        // Fullscreen exclusive mode problem 
     569                                        // Need to release & recreate 
     570                                        releaseDDSurfaces(); 
     571                                        createDDSurfaces(); 
     572                                        createDepthBuffer(); 
     573                                        return; 
     574                                } 
     575                                else 
     576                                { 
     577                                        char szBuffer[512]; 
     578                                        D3DXGetErrorString( hr, 512, szBuffer ); 
    565579                OGRE_EXCEPT(  
    566580                    Exception::ERR_INTERNAL_ERROR,  
    567                     "Error restoring lost primary surface.",  
     581                                                "Error restoring lost primary surface." + String(szBuffer),  
    568582                    "D3D7RenderWindow - restoreDDSurfaces" ); 
    569583        } 
     584                        } 
     585        } 
    570586 
    571587        if( mlpDDSBack->IsLost() ) 
    … …  
    574590 
    575591            if( FAILED( hr ) ) 
     592                        { 
     593                                char szBuffer[512]; 
     594                                D3DXGetErrorString( hr, 512, szBuffer ); 
    576595                OGRE_EXCEPT(  
    577596                    Exception::ERR_INTERNAL_ERROR,  
    578                     "Error restoring lost back buffer surface.",  
     597                    "Error restoring lost back buffer surface." + String(szBuffer),  
    579598                    "D3D7RenderWindow - restoreDDSurfaces" ); 
    580599        } 
     600    } 
    581601    } 
    582602 
    … …  
    592612        ClientToScreen( mHWnd, (POINT*)&rcCheck.left ); 
    593613        ClientToScreen( mHWnd, (POINT*)&rcCheck.right ); 
     614 
     615                if ((rcCheck.right - rcCheck.left) == 0 || 
     616                        (rcCheck.bottom - rcCheck.top) == 0) 
     617                { 
     618                        return; 
     619                } 
    594620 
    595621        // Has the window resized? If so, we need to recreate surfaces 

  • OGRE/trunk/ogre_changes/RenderSystems/Direct3D9/include/OgreD3D9HardwareOcclusionQuery.h

    r115 r657  
    3434 
    3535// If you use multiple rendering passes you can test only the first pass and all other passes don't have to be rendered  
    36         // if the first pass resultet has too few pixels visible. 
     36        // if the first pass results has too few pixels visible. 
    3737 
    38 // Be sure to render all occlluder first and whats out so the RenderQue don't switch places on  
     38        // Be sure to render all occluder first and whats out so the RenderQue don't switch places on  
    3939// the occluding objects and the tested objects because it thinks it's more effective.. 
    4040 
    … …  
    4646        * 
    4747        * Updated on 12/7/2004 by Chris McGuirk 
     48        * Updated on 4/8/2005 by Tuan Kuranes email: tuan.kuranes@free.fr 
    4849  */ 
    4950class D3D9HardwareOcclusionQuery : public HardwareOcclusionQuery 
    … …  
    7374                bool pullOcclusionQuery( unsigned int* NumOfFragments, const HW_OCCLUSIONQUERY flag = HWOCCLUSIONQUERY_FLUSH); 
    7475                unsigned int getLastQuerysPixelcount() { return mPixelCount; } 
     76        bool isStillOutstanding(void); 
    7577 
    7678                // These functions are optional, it's a simple filter that simply skips some hardware occlusion tests on visible objects only 
    … …  
    8284          *    
    8385                * Remarks This function allows you to set how often the hardware occlusion query is sent to the driver 
    84           * if you set it to 0 every hw occlusion test is acctually made. If you set it to 1 only the half of your queries are sent  
    85                 * 2 will result in 25% of all queries to acctualy be sent.  
     86                * if you set it to 0 every hardware occlusion test is actually made. If you set it to 1 only the half of your queries are sent  
     87                * 2 will result in 25% of all queries to factually be sent.  
    8688                * This functionality is here because this class can keep track on visible and none visible objects for you. 
    8789          * Once you you set the SkipRate for any hardware occlusion instance it effects all others. 
    8890          */ 
    8991 
    90                 void setSkipRate( int skip ) { mSkipInterval = skip; }                  // Using 2 only 50 % of the tests are actully made and 3 results in only 33% of the tests. So on. 
     92                void setSkipRate( int skip ) { mSkipInterval = skip; }                  // Using 2 only 50 % of the tests are actually made and 3 results in only 33% of the tests. So on. 
    9193                int      getSkipRate() { return mSkipInterval; }  
    9294 
    … …  
    105107                int                                     mSkipInterval; 
    106108                bool                            mHasOcclusionSupport; 
     109                bool                            mIsQueryResultStillOutstanding; 
    107110}; 
    108111 

  • OGRE/trunk/ogre_changes/RenderSystems/Direct3D9/include/OgreD3D9Texture.h

    r193 r657  
    6868                /// device capabilities pointer 
    6969                D3DCAPS9                                                mDevCaps; 
    70         // Auto-generated mipmaps? 
    71         bool                            mAutoGenMipmaps; 
    7270                // Dynamic textures? 
    7371                bool                            mDynamicTextures; 
    … …  
    9593                D3DFORMAT _chooseD3DFormat(); 
    9694 
    97                 /// internal method, free D3D9 resources 
    98                 void _freeResources(); 
     95                /// @copydoc Texture::createInternalResourcesImpl 
     96                void createInternalResourcesImpl(void); 
     97                /// free internal resources 
     98                void freeInternalResourcesImpl(void); 
    9999                /// internal method, set Texture class source image protected attributes 
    100100                void _setSrcAttributes(unsigned long width, unsigned long height, unsigned long depth, PixelFormat format); 
    … …  
    116116                /// internal method, create D3D9HardwarePixelBuffers for every face and 
    117117                /// mipmap level. This method must be called after the D3D texture object was created 
    118                 void _createSurfaceList(bool updateOldList=false); 
     118                void _createSurfaceList(void); 
    119119 
    120120        /// overriden from Resource 
    121121        void loadImpl(); 
    122         /// overriden from Resource 
    123         void unloadImpl(); 
    124122        public: 
    125123                /// constructor  
    … …  
    135133                void loadImage( const Image &img ); 
    136134 
    137         /// @copydoc Texture::createInternalResources 
    138         void createInternalResources(void); 
    139135 
    140136                /// @copydoc Texture::getBuffer 

  • OGRE/trunk/ogre_changes/RenderSystems/Direct3D9/src/OgreD3D9HardwareOcclusionQuery.cpp

    r193 r657  
    113113        // This version of pullOcclusionQuery causes the DX9 API/Driver to not flush all commands to the 3D card 
    114114// to allow a fast result from the query, but the batching of API calls to the card will be normal.  
    115         // But the query wont be processed until the card recives the query in the next batch. 
     115        // But the query wont be processed until the card receives the query in the next batch. 
    116116// Note: OpenGL dosn't use this flag at all so the application running OpenGL won't display any different behaviour. 
    117117//-- 

  • OGRE/trunk/ogre_changes/RenderSystems/Direct3D9/src/OgreD3D9RenderWindow.cpp

    r193 r657  
    110110        D3D9RenderWindow::~D3D9RenderWindow() 
    111111        { 
    112                 // access and update device through driver, realse only primary 
    113                 if (!mIsSwapChain)  
    114                 { 
    115                         LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice(); 
    116                         SAFE_RELEASE( mpD3DDevice ); 
    117                         mDriver->setD3DDevice( NULL ); 
    118                 } 
     112                destroyD3DResources(); 
    119113        } 
    120114 
    … …  
    342336                md3dpp.BackBufferHeight                 = mHeight; 
    343337 
    344 #ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    345         //md3dpp.Flags |= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER; 
    346 #endif 
    347338                if (mVSync) 
    348339                        md3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; 
    … …  
    493484                        // ignore depth buffer, access device through driver 
    494485                        mpRenderZBuffer = 0; 
    495                         LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice(); 
    496                         SAFE_RELEASE(mpD3DDevice); 
    497                         mDriver->setD3DDevice(NULL); 
    498486                } 
    499487        } 
    … …  
    727715                } 
    728716 
    729                 if (!mIsFullScreen) 
    730                 { 
    731                         POINT pt={0, 0}; 
     717                D3DLOCKED_RECT lockedRect; 
     718                if(mIsFullScreen) 
     719                { 
     720                        if (FAILED(hr = pTempSurf->LockRect(&lockedRect, NULL,  
     721                        D3DLOCK_READONLY | D3DLOCK_NOSYSLOCK))) 
     722                        { 
     723                                OGRE_EXCEPT(hr, "can't lock rect!", "D3D9RenderWindow::writeContentsToFile"); 
     724                        }  
     725                } 
     726                else 
     727                { 
    732728                        RECT srcRect; 
    733729                        GetWindowRect(mHWnd, &srcRect); 
    … …  
    735731                        desc.Width = srcRect.right - srcRect.left; 
    736732                        desc.Height = srcRect.bottom - srcRect.top; 
    737                         desc.Format = D3DFMT_A8R8G8B8;         // this is what we get from the screen, so stick with it 
    738  
    739                         // NB we can't lock the back buffer direct because it's no created that way 
    740                         // and to do so hits performance, so copy to another surface 
    741                         // Must be the same format as the source surface 
    742                         if (FAILED(hr = mpD3DDevice->CreateOffscreenPlainSurface( 
    743                                                         desc.Width,  
    744                                                         desc.Height,  
    745                                                         desc.Format,  
    746                                                         D3DPOOL_DEFAULT,  
    747                                                         &pSurf, 
    748                                                         NULL))) 
    749                         { 
    750                                 SAFE_RELEASE(pSurf); 
    751                                 OGRE_EXCEPT(hr, "Cannot create offscreen buffer 2!", "D3D9RenderWindow::writeContentsToFile"); 
    752                         } 
    753  
    754                         // Copy 
    755                         if (FAILED(hr = mpD3DDevice->UpdateSurface(pTempSurf, &srcRect, pSurf, &pt))) 
    756                         { 
    757                                 SAFE_RELEASE(pTempSurf); 
    758                                 SAFE_RELEASE(pSurf); 
    759                                 OGRE_EXCEPT(hr, "Cannot update surface!", "D3D9RenderWindow::writeContentsToFile"); 
    760                         } 
    761  
    762                         SAFE_RELEASE(pTempSurf); 
    763                         pTempSurf = pSurf; 
    764                         pSurf = NULL; 
    765                 } 
    766  
    767                 D3DLOCKED_RECT lockedRect; 
    768                 if (FAILED(hr = pTempSurf->LockRect(&lockedRect, NULL,  
     733 
     734                        if (FAILED(hr = pTempSurf->LockRect(&lockedRect, &srcRect,  
     735 
    769736                        D3DLOCK_READONLY | D3DLOCK_NOSYSLOCK))) 
    770737                { 
    771738                        OGRE_EXCEPT(hr, "can't lock rect!", "D3D9RenderWindow::writeContentsToFile"); 
    772739                }  
     740                } 
    773741 
    774742        ImageCodec::ImageData *imgData = new ImageCodec::ImageData(); 

  • OGRE/trunk/ogre_changes/RenderSystems/GL/include/OgreGLHardwareOcclusionQuery.h

    r343 r657  
    5353 
    5454// If you use multiple rendering passes you can test only the first pass and all other passes don't have to be rendered  
    55 // if the first pass resultet has too few pixels visable. 
     55// if the first pass result has too few pixels visible. 
    5656 
    57 // Be sure to render all occlluder first and whats out so the RenderQue don't switch places on  
     57// Be sure to render all occluder first and whats out so the RenderQue don't switch places on  
    5858// the occluding objects and the tested objects because it thinks it's more effective.. 
    5959 
    … …  
    6464  * 
    6565  * @author Lee Sandberg email: lee@abcmedia.se 
     66  * Updated on 4/8/2005 by Tuan Kuranes email: tuan.kuranes@free.fr 
    6667  */ 
    6768 
    … …  
    9192        unsigned int getLastQuerysPixelcount() { return mPixelCount; } 
    9293 
    93         // This functions are optional, it's a simple filter that simply skipps some hardware occlusion tests on visable objects only 
    94         // It's easy to use if you don't have to keep track on which objects are visable (can be skipped) and what objects arn't visable.. 
    95         // (None visable objects and object you introduce for the first time have allways to be tested allthough the cheepest possible  
    96         // LOD (Level Of Detail) mesh and material wize).  
     94        // This functions are optional, it's a simple filter that simply skips some hardware occlusion tests on visible objects only 
     95        // It's easy to use if you don't have to keep track on which objects are visible (can be skipped) and what objects arn't visible.. 
     96        // (None visible objects and object you introduce for the first time have always to be tested although the cheapest possible  
     97        // LOD (Level Of Detail) mesh and material wise).  
    9798 
    9899        /** 
    99100          *    
    100101          * Remarks This function allows you to set how often the hardware occlusion really sent to the driver 
    101           * if you set it to 0 every hw occlusion test is acctually made. If you set it to 2 only 50% of your queries are sent.  
    102           * for all visable objects. 3 will result in 33% of all queries to acctualy be sent and so on.  
    103           * New and none visable objects will be tested all the time. 
    104           * This functionality is here because this class can keep track on visable and none visable objects for you. 
     102          * if you set it to 0 every hardware occlusion test is actually made. If you set it to 2 only 50% of your queries are sent.  
     103          * for all visible objects. 3 will result in 33% of all queries to actually be sent and so on.  
     104          * New and none visible objects will be tested all the time. 
     105          * This functionality is here because this class can keep track on visible and none visible objects for you. 
    105106          * Once you you set the SkipRate for any hardware occlusion instance it effects all others. 
    106107          */ 
    107108 
    108         void setSkipRate( int skip ) { mSkipInterval = skip; }          // Using 2 only 50 % of the tests are actully made and 3 results in only 33% of the tests. So on. 
     109        void setSkipRate( int skip ) { mSkipInterval = skip; }          // Using 2 only 50 % of the tests are actually made and 3 results in only 33% of the tests. So on. 
    109110        int      getSkipRate() { return mSkipInterval; }  
    110111 

  • OGRE/trunk/ogre_changes/RenderSystems/GL/include/OgreGLTexture.h

    r153 r657  
    4646        virtual ~GLTexture();       
    4747 
    48         /// @copydoc Texture::createInternalResources 
    49         void createInternalResources(void); 
    5048                void loadImage( const Image& img ); 
    5149        void createRenderTexture(); 
    … …  
    6159 
    6260    protected: 
     61                /// @copydoc Texture::createInternalResourcesImpl 
     62                void createInternalResourcesImpl(void); 
    6363        /// @copydoc Resource::loadImpl 
    6464        void loadImpl(void); 
    65         /// @copydoc Resource::unloadImpl 
    66         void unloadImpl(void); 
     65        /// @copydoc Resource::freeInternalResourcesImpl 
     66        void freeInternalResourcesImpl(void); 
    6767 
    6868                /** internal method, create GLHardwarePixelBuffers for every face and 

  • OGRE/trunk/ogre_changes/RenderSystems/GL/src/OgreGLHardwareOcclusionQuery.cpp

    r343 r657  
    3838  * Updated on 12/7/2004 by Chris McGuirk 
    3939  * - Implemented ARB_occlusion_query 
     40  * Updated on 4/8/2005 by Tuan Kuranes email: tuan.kuranes@free.fr 
    4041  */ 
    4142 
    … …  
    154155#endif // GTP_VIBILITY_MODIFIED_OGRE 
    155156} 
     157 
     158 

  • OGRE/trunk/ogre_changes/RenderSystems/GL/src/OgreGLRenderSystem.cpp

    r350 r657  
    257257            delete mTextureManager; 
    258258 
    259         delete mCapabilities; 
    260259        delete mGLSupport; 
    261260    } 
    … …  
    894893            case Light::LT_SPOTLIGHT: 
    895894                glLightf( gl_index, GL_SPOT_CUTOFF, 0.5f * lt->getSpotlightOuterAngle().valueDegrees() ); 
     895                glLightf(gl_index, GL_SPOT_EXPONENT, lt->getSpotlightFalloff()); 
    896896                break; 
    897897            default: 
    … …  
    10901090                        if(!tex.isNull()) 
    10911091                                glBindTexture( mTextureTypes[stage], tex->getGLID() ); 
    1092  
     1092                        else 
     1093                                glBindTexture( mTextureTypes[stage], static_cast<GLTextureManager*>(mTextureManager)->getWarningTextureID() ); 
    10931094        } 
    10941095        else 
    … …  
    12381239 
    12391240            // Set scale and translation matrix for projective textures 
    1240             projectionBias = Matrix4::ZERO; 
    1241             projectionBias[0][0] = 0.5; projectionBias[1][1] = -0.5;  
    1242             projectionBias[2][2] = 1.0; projectionBias[0][3] = 0.5;  
    1243             projectionBias[1][3] = 0.5; projectionBias[3][3] = 1.0; 
     1241            projectionBias = Matrix4::CLIPSPACE2DTOIMAGESPACE; 
    12441242 
    12451243            projectionBias = projectionBias * frustum->getProjectionMatrix(); 
    … …  
    12601258        switch(tam) 
    12611259        { 
     1260        default: 
    12621261        case TextureUnitState::TAM_WRAP: 
    12631262            type = GL_REPEAT; 
    … …  
    12951294                        mat[12] = mat[8]; 
    12961295                        mat[13] = mat[9]; 
     1296            mat[8] = 0; 
     1297            mat[9] = 0; 
    12971298                } 
    12981299//        mat[14] = mat[10]; 
    … …  
    13121313        glMatrixMode(GL_TEXTURE); 
    13131314 
     1315        // Load this matrix in 
     1316        glLoadMatrixf(mat); 
     1317 
    13141318        if (mUseAutoTextureMatrix) 
    13151319        { 
    1316             // Load auto matrix in 
    1317             glLoadMatrixf(mAutoTextureMatrix); 
    1318             // Concat new matrix 
    1319             glMultMatrixf(mat); 
    1320  
    1321         } 
    1322         else 
    1323         { 
    1324             // Just load this matrix 
    1325             glLoadMatrixf(mat); 
     1320            // Concat auto matrix 
     1321            glMultMatrixf(mAutoTextureMatrix); 
    13261322        } 
    13271323 
    … …  
    14031399              h = vp->getActualHeight(); 
    14041400              x = vp->getActualLeft(); 
    1405               y = target->getHeight() - vp->getActualTop() - h; 
    1406    
     1401              y = vp->getActualTop(); 
     1402              if (!target->requiresTextureFlipping()) 
     1403              { 
     1404                  // Convert "upper-left" corner to "lower-left" 
     1405                  y = target->getHeight() - h - y; 
     1406              } 
    14071407              glViewport(x, y, w, h); 
    14081408   
    … …  
    23442344            glDisableVertexAttribArrayARB_ptr(1); // disable weights 
    23452345        } 
    2346  
     2346        glColor4f(1,1,1,1); 
    23472347        glSecondaryColor3fEXT_ptr(0.0f, 0.0f, 0.0f); 
    23482348 
    … …  
    24152415            const Plane& plane = clipPlanes[i]; 
    24162416 
    2417             if (i >= GL_MAX_CLIP_PLANES) 
     2417            if (i >= 6/*GL_MAX_CLIP_PLANES*/) 
    24182418            { 
    24192419                OGRE_EXCEPT(0, "Unable to set clip plane",  
    … …  
    24242424            clipPlane[1] = plane.normal.y; 
    24252425            clipPlane[2] = plane.normal.z; 
    2426             clipPlane[3] = -plane.d; 
     2426            clipPlane[3] = plane.d; 
    24272427 
    24282428            glClipPlane(clipPlaneId, clipPlane); 
    … …  
    24402440        size_t top, size_t right, size_t bottom) 
    24412441    { 
     2442        // If request texture flipping, use "upper-left", otherwise use "lower-left" 
     2443        bool flipping = mActiveRenderTarget->requiresTextureFlipping(); 
    24422444        //  GL measures from the bottom, not the top 
    24432445        size_t targetHeight = mActiveRenderTarget->getHeight(); 
    … …  
    24502452            // NB GL uses width / height rather than right / bottom 
    24512453            x = left; 
     2454            if (flipping) 
     2455                y = top; 
     2456            else 
    24522457            y = targetHeight - bottom; 
    24532458            w = right - left; 
    … …  
    24622467            h = mActiveViewport->getActualHeight(); 
    24632468            x = mActiveViewport->getActualLeft(); 
     2469            if (flipping) 
     2470                y = mActiveViewport->getActualTop(); 
     2471            else 
    24642472            y = targetHeight - mActiveViewport->getActualTop() - h; 
    24652473            glScissor(x, y, w, h); 
    … …  
    25752583    HardwareOcclusionQuery* GLRenderSystem::createHardwareOcclusionQuery(void) 
    25762584    { 
    2577         return new GLHardwareOcclusionQuery();  
     2585        GLHardwareOcclusionQuery* ret = new GLHardwareOcclusionQuery();  
     2586                mHwOcclusionQueries.push_back(ret); 
     2587                return ret; 
    25782588    } 
    25792589    //--------------------------------------------------------------------- 
    … …  
    26392649    } 
    26402650    //--------------------------------------------------------------------- 
     2651    void GLRenderSystem::_switchContext(GLContext *context) 
     2652    { 
     2653        // Unbind GPU programs and rebind to new context later, because 
     2654        // scene manager treat render system as ONE 'context' ONLY, and it 
     2655        // cached the GPU programs using state. 
     2656        if (mCurrentVertexProgram) 
     2657            mCurrentVertexProgram->unbindProgram(); 
     2658        if (mCurrentFragmentProgram) 
     2659            mCurrentFragmentProgram->unbindProgram(); 
     2660 
     2661        // It's ready to switching 
     2662            mCurrentContext->endCurrent(); 
     2663        mCurrentContext = context; 
     2664        mCurrentContext->setCurrent(); 
     2665         
     2666            // Check if the context has already done one-time initialisation 
     2667        if(!mCurrentContext->getInitialized())  
     2668        { 
     2669               _oneTimeContextInitialization(); 
     2670               mCurrentContext->setInitialized(); 
     2671            } 
     2672 
     2673        // Rebind GPU programs to new context 
     2674        if (mCurrentVertexProgram) 
     2675            mCurrentVertexProgram->bindProgram(); 
     2676        if (mCurrentFragmentProgram) 
     2677            mCurrentFragmentProgram->bindProgram(); 
     2678 
     2679        // Must reset depth/colour write mask to according with user desired, otherwise, 
     2680        // clearFrameBuffer would be wrong because the value we are recorded may be 
     2681        // difference with the really state stored in GL context. 
     2682        glDepthMask(mDepthWrite); 
     2683        glColorMask(mColourWrite[0], mColourWrite[1], mColourWrite[2], mColourWrite[3]); 
     2684 
     2685    } 
     2686    //--------------------------------------------------------------------- 
    26412687    void GLRenderSystem::_setRenderTarget(RenderTarget *target) 
    26422688    { 
    … …  
    26452691        ContextMap::iterator i = mContextMap.find(target); 
    26462692        if(i != mContextMap.end() && mCurrentContext != i->second) { 
    2647             mCurrentContext->endCurrent(); 
    2648             mCurrentContext = i->second; 
    2649             // Check if the context has already done one-time initialisation 
    2650             if(!mCurrentContext->getInitialized()) { 
    2651                _oneTimeContextInitialization(); 
    2652                mCurrentContext->setInitialized(); 
    2653             } 
    2654             mCurrentContext->setCurrent(); 
     2693            _switchContext(i->second); 
    26552694        } 
    26562695    } 
    … …  
    26692708            // we set the main context to 0. 
    26702709            if(mCurrentContext != mMainContext) { 
    2671                 mCurrentContext->endCurrent(); 
    2672                 mCurrentContext = mMainContext; 
    2673                 mCurrentContext->setCurrent(); 
     2710                _switchContext(mMainContext); 
    26742711            } else { 
    26752712                mMainContext = 0; 

  • OGRE/trunk/ogre_changes/RenderSystems/GL/src/OgreGLTexture.cpp

    r193 r657  
    6969        // have to call this here reather than in Resource destructor 
    7070        // since calling virtual methods in base destructors causes crash 
     71                if (mIsLoaded) 
     72                { 
    7173        unload();  
     74    } 
     75                else 
     76                { 
     77                        freeInternalResources(); 
     78                } 
    7279    } 
    7380 
    … …  
    9097 
    9198        //* Creation / loading methods ******************************************** 
    92         void GLTexture::createInternalResources(void) 
     99        void GLTexture::createInternalResourcesImpl(void) 
    93100    { 
    94101                // Adjust requested parameters to capabilities 
    … …  
    131138                // Zero means create mip levels until 1x1 
    132139                size_t maxMips = GLPixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat); 
     140                mNumMipmaps = mNumRequestedMipmaps; 
    133141                if(mNumMipmaps>maxMips) 
    134142                        mNumMipmaps = maxMips; 
    … …  
    144152                 
    145153                // If we can do automip generation and the user desires this, do so 
     154                mMipmapsHardwareGenerated =  
     155                        Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP); 
    146156                if((mUsage & TU_AUTOMIPMAP) && 
    147                     mNumMipmaps && 
    148                         Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP)) 
     157                    mNumRequestedMipmaps && mMipmapsHardwareGenerated) 
    149158        { 
    150159            glTexParameteri( getGLTextureTarget(), GL_GENERATE_MIPMAP, GL_TRUE ); 
    … …  
    242251                // Get final internal format 
    243252                mFormat = getBuffer(0,0)->getFormat(); 
    244                 mIsLoaded = true; 
    245253        } 
    246254         
    … …  
    326334        //************************************************************************* 
    327335     
    328     void GLTexture::unloadImpl() 
     336    void GLTexture::freeInternalResourcesImpl() 
    329337    { 
    330338                mSurfaceList.clear(); 
    … …  
    337345        { 
    338346                mSurfaceList.clear(); 
    339                 // Make our understanding of the number of mips matches the GL one 
    340                 glBindTexture( getGLTextureTarget(), mTextureID ); 
    341                 GLint value; 
    342                 glGetTexParameteriv( getGLTextureTarget(), GL_TEXTURE_MAX_LEVEL, &value ); 
    343                 mNumMipmaps = value; 
    344347                 
    345348                // For all faces and mipmaps, store surfaces as HardwarePixelBufferSharedPtr 
    346349                bool wantGeneratedMips = (mUsage & TU_AUTOMIPMAP)!=0; 
    347                 bool canMip = Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP); 
    348350                 
    349351                // Do mipmapping in software? (uses GLU) For some cards, this is still needed. Of course, 
    350352                // only when mipmap generation is desired. 
    351                 bool doSoftware = wantGeneratedMips && !canMip && getNumMipmaps();  
     353                bool doSoftware = wantGeneratedMips && !mMipmapsHardwareGenerated && getNumMipmaps();  
    352354                 
    353355                for(int face=0; face<getNumFaces(); face++) 

  • OGRE/trunk/ogre_changes/RenderSystems/GL/src/OgreWin32Window.cpp

    r193 r657  
    226226                    } 
    227227 
     228                HDC old_hdc = wglGetCurrentDC(); 
     229                HGLRC old_context = wglGetCurrentContext(); 
     230 
    228231                        RECT rc; 
    229232                // top and left represent outer window position 
    … …  
    255258                 
    256259                wglSwapIntervalEXT(vsync? 1 : 0); 
     260 
     261        if (old_context) 
     262        { 
     263            // Restore old context 
     264                    if (!wglMakeCurrent(old_hdc, old_context)) 
     265                            OGRE_EXCEPT(0, "wglMakeCurrent() failed", "Win32Window::create"); 
     266 
     267            // Share lists with old context 
     268                    if (!wglShareLists(old_context, mGlrc)) 
     269                            OGRE_EXCEPT(0, "wglShareLists() failed", " Win32Window::create"); 
     270        } 
    257271 
    258272        // Create RenderSystem context 
Note: See TracChangeset for help on using the changeset viewer.