vcl/opengl/texture.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21 #include <vcl/opengl/OpenGLContext.hxx>
  22 #include <vcl/opengl/OpenGLHelper.hxx>
  23
  24 #include "svdata.hxx"
  25
  26 #include <vcl/salbtype.hxx>
  27 #include <vcl/pngwrite.hxx>
  28
  29 #include "opengl/framebuffer.hxx"
  30 #include "opengl/texture.hxx"
  31 #include "opengl/zone.hxx"
  32 #include "opengl/RenderState.hxx"
  33
  34 namespace
  35 {
  36
  37 constexpr GLenum constInternalFormat = GL_RGBA8;
  38
  39 } // end anonymous namespace
  40
  41 // texture with allocated size
  42 ImplOpenGLTexture::ImplOpenGLTexture( int nWidth, int nHeight, bool bAllocate ) :
  43     mnTexture( 0 ),
  44     mnWidth( nWidth ),
  45     mnHeight( nHeight ),
  46     mnFilter( GL_NEAREST ),
  47     mnOptStencil( 0 )
  48 {
  49     OpenGLVCLContextZone aContextZone;
  50
  51     auto& rState = OpenGLContext::getVCLContext()->state();
  52     TextureState::generate(mnTexture);
  53     rState.texture().active(0);
  54     rState.texture().bind(mnTexture);
  55
  56     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
  57     CHECK_GL_ERROR();
  58     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
  59     CHECK_GL_ERROR();
  60     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
  61     CHECK_GL_ERROR();
  62     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
  63     CHECK_GL_ERROR();
  64     if( bAllocate )
  65     {
  66         glTexImage2D( GL_TEXTURE_2D, 0, constInternalFormat, nWidth, nHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr );
  67         CHECK_GL_ERROR();
  68     }
  69
  70     VCL_GL_INFO( "OpenGLTexture " << mnTexture << " " << nWidth << "x" << nHeight << " allocate" );
  71 }
  72
  73 // texture with content retrieved from FBO
  74 ImplOpenGLTexture::ImplOpenGLTexture( int nX, int nY, int nWidth, int nHeight ) :
  75     mnTexture( 0 ),
  76     mnWidth( nWidth ),
  77     mnHeight( nHeight ),
  78     mnFilter( GL_NEAREST ),
  79     mnOptStencil( 0 )
  80 {
  81     OpenGLVCLContextZone aContextZone;
  82
  83     // FIXME We need the window height here
  84     // nY = GetHeight() - nHeight - nY;
  85
  86     auto& rState = OpenGLContext::getVCLContext()->state();
  87     TextureState::generate(mnTexture);
  88     rState.texture().active(0);
  89     rState.texture().bind(mnTexture);
  90
  91     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
  92     CHECK_GL_ERROR();
  93     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
  94     CHECK_GL_ERROR();
  95     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
  96     CHECK_GL_ERROR();
  97     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
  98     CHECK_GL_ERROR();
  99     glCopyTexImage2D( GL_TEXTURE_2D, 0, constInternalFormat, nX, nY, nWidth, nHeight, 0 );
 100     CHECK_GL_ERROR();
 101
 102     VCL_GL_INFO( "OpenGLTexture " << mnTexture << " " << nWidth << "x" << nHeight << " from x" << nX << ", y" << nY );
 103 }
 104
 105 // texture from buffer data
 106 ImplOpenGLTexture::ImplOpenGLTexture( int nWidth, int nHeight, int nFormat, int nType, void const * pData ) :
 107     mnTexture( 0 ),
 108     mnWidth( nWidth ),
 109     mnHeight( nHeight ),
 110     mnFilter( GL_NEAREST ),
 111     mnOptStencil( 0 )
 112 {
 113     OpenGLVCLContextZone aContextZone;
 114
 115     auto& rState = OpenGLContext::getVCLContext()->state();
 116     TextureState::generate(mnTexture);
 117     rState.texture().active(0);
 118     rState.texture().bind(mnTexture);
 119
 120     glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
 121     CHECK_GL_ERROR();
 122     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
 123     CHECK_GL_ERROR();
 124     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
 125     CHECK_GL_ERROR();
 126     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
 127     CHECK_GL_ERROR();
 128     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
 129     CHECK_GL_ERROR();
 130     glTexImage2D( GL_TEXTURE_2D, 0, constInternalFormat, mnWidth, mnHeight, 0, nFormat, nType, pData );
 131     CHECK_GL_ERROR();
 132
 133     VCL_GL_INFO( "OpenGLTexture " << mnTexture << " " << nWidth << "x" << nHeight << " from data" );
 134 }
 135
 136 GLuint ImplOpenGLTexture::AddStencil()
 137 {
 138     assert( mnOptStencil == 0 );
 139
 140     glGenRenderbuffers( 1, &mnOptStencil );
 141     CHECK_GL_ERROR();
 142     glBindRenderbuffer( GL_RENDERBUFFER, mnOptStencil );
 143     CHECK_GL_ERROR();
 144     VCL_GL_INFO( "Allocate stencil " << mnWidth << " x " << mnHeight );
 145     glRenderbufferStorage( GL_RENDERBUFFER, GL_STENCIL_INDEX,
 146                            mnWidth, mnHeight );
 147     CHECK_GL_ERROR();
 148     glBindRenderbuffer(GL_RENDERBUFFER, 0);
 149     CHECK_GL_ERROR();
 150
 151     return mnOptStencil;
 152 }
 153
 154 ImplOpenGLTexture::~ImplOpenGLTexture()
 155 {
 156     VCL_GL_INFO( "~OpenGLTexture " << mnTexture );
 157     if( mnTexture != 0 )
 158     {
 159         // During shutdown GL is already de-initialized, so we should not try to create a new context.
 160         OpenGLZone aZone;
 161         rtl::Reference<OpenGLContext> xContext = OpenGLContext::getVCLContext(false);
 162         if( xContext.is() )
 163         {
 164             // FIXME: this is really not optimal performance-wise.
 165
 166             // Check we have been correctly un-bound from all framebuffers.
 167             ImplSVData* pSVData = ImplGetSVData();
 168             rtl::Reference<OpenGLContext> pContext = pSVData->maGDIData.mpLastContext;
 169
 170             if( pContext.is() )
 171             {
 172                 pContext->makeCurrent();
 173                 pContext->UnbindTextureFromFramebuffers( mnTexture );
 174             }
 175
 176             if( mnOptStencil != 0 )
 177             {
 178                 glDeleteRenderbuffers( 1, &mnOptStencil );
 179                 mnOptStencil = 0;
 180             }
 181             auto& rState = pContext->state();
 182             rState.texture().unbindAndDelete(mnTexture);
 183             mnTexture = 0;
 184         }
 185         else
 186         {
 187             mnOptStencil = 0;
 188             mnTexture = 0;
 189         }
 190     }
 191 }
 192
 193 bool ImplOpenGLTexture::InsertBuffer(int nX, int nY, int nWidth, int nHeight, int nFormat, int nType, sal_uInt8* pData)
 194 {
 195     if (!pData || mnTexture == 0)
 196         return false;
 197
 198     rtl::Reference<OpenGLContext> xContext = OpenGLContext::getVCLContext();
 199     xContext->state().texture().active(0);
 200     xContext->state().texture().bind(mnTexture);
 201
 202     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 203     CHECK_GL_ERROR();
 204     glTexSubImage2D(GL_TEXTURE_2D, 0, nX, mnHeight - nY - nHeight, nWidth, nHeight, nFormat, nType, pData);
 205     CHECK_GL_ERROR();
 206
 207     VCL_GL_INFO( "OpenGLTexture " << mnTexture << " Insert buff. to " << nX << " " << nY
 208                                              << " size " << nWidth << "x" << nHeight << " from data" );
 209
 210     return true;
 211 }
 212
 213 bool ImplOpenGLTexture::InitializeSlotMechanism(int nInitialSlotSize)
 214 {
 215     if (mpSlotReferences)
 216         return false;
 217
 218     mpSlotReferences.reset(new std::vector<int>(nInitialSlotSize, 0));
 219     return true;
 220 }
 221
 222 void ImplOpenGLTexture::IncreaseRefCount(int nSlotNumber)
 223 {
 224     if (mpSlotReferences && nSlotNumber >= 0)
 225     {
 226         if (nSlotNumber >= int(mpSlotReferences->size()))
 227             mpSlotReferences->resize(nSlotNumber + 1, 0);
 228
 229         mpSlotReferences->at(nSlotNumber)++;
 230     }
 231 }
 232
 233 void ImplOpenGLTexture::DecreaseRefCount(int nSlotNumber)
 234 {
 235     if (mpSlotReferences && nSlotNumber >= 0)
 236     {
 237         if (nSlotNumber >= int(mpSlotReferences->size()))
 238             mpSlotReferences->resize(nSlotNumber, 0);
 239
 240         mpSlotReferences->at(nSlotNumber)--;
 241
 242         if (mpSlotReferences->at(nSlotNumber) == 0 && mFunctSlotDeallocateCallback)
 243         {
 244             mFunctSlotDeallocateCallback(nSlotNumber);
 245         }
 246     }
 247 }
 248
 249 OpenGLTexture::OpenGLTexture() :
 250     maRect( 0, 0, 0, 0 ),
 251     mpImpl(),
 252     mnSlotNumber(-1)
 253 {
 254 }
 255
 256 OpenGLTexture::OpenGLTexture(const std::shared_ptr<ImplOpenGLTexture>& rpImpl, tools::Rectangle aRectangle, int nSlotNumber)
 257     : maRect(aRectangle)
 258     , mpImpl(rpImpl)
 259     , mnSlotNumber(nSlotNumber)
 260 {
 261     if (mpImpl)
 262         mpImpl->IncreaseRefCount(nSlotNumber);
 263 }
 264
 265 OpenGLTexture::OpenGLTexture( int nWidth, int nHeight, bool bAllocate )
 266     : maRect( Point( 0, 0 ), Size( nWidth, nHeight ) )
 267     , mpImpl(new ImplOpenGLTexture(nWidth, nHeight, bAllocate))
 268     , mnSlotNumber(-1)
 269 {
 270 }
 271
 272 OpenGLTexture::OpenGLTexture( int nX, int nY, int nWidth, int nHeight )
 273     : maRect( Point( 0, 0 ), Size( nWidth, nHeight ) )
 274     , mpImpl(new ImplOpenGLTexture(nX, nY, nWidth, nHeight))
 275     , mnSlotNumber(-1)
 276 {
 277 }
 278
 279 OpenGLTexture::OpenGLTexture( int nWidth, int nHeight, int nFormat, int nType, void const * pData )
 280     : maRect( Point( 0, 0 ), Size( nWidth, nHeight ) )
 281     , mpImpl(new ImplOpenGLTexture(nWidth, nHeight, nFormat, nType, pData))
 282     , mnSlotNumber(-1)
 283 {
 284
 285 }
 286
 287 OpenGLTexture::OpenGLTexture( const OpenGLTexture& rTexture )
 288 {
 289     maRect = rTexture.maRect;
 290     mpImpl = rTexture.mpImpl;
 291     mnSlotNumber = rTexture.mnSlotNumber;
 292
 293     if (mpImpl)
 294         mpImpl->IncreaseRefCount(mnSlotNumber);
 295 }
 296
 297 OpenGLTexture::OpenGLTexture( const OpenGLTexture& rTexture,
 298                               int nX, int nY, int nWidth, int nHeight )
 299 {
 300     maRect = tools::Rectangle( Point( rTexture.maRect.Left() + nX, rTexture.maRect.Top() + nY ),
 301                         Size( nWidth, nHeight ) );
 302     mpImpl = rTexture.mpImpl;
 303     mnSlotNumber = rTexture.mnSlotNumber;
 304     if (mpImpl)
 305         mpImpl->IncreaseRefCount(mnSlotNumber);
 306     VCL_GL_INFO( "Copying texture " << Id() << " [" << maRect.Left() << "," << maRect.Top() << "] " << GetWidth() << "x" << GetHeight() );
 307 }
 308
 309 OpenGLTexture::~OpenGLTexture()
 310 {
 311     if (mpImpl)
 312         mpImpl->DecreaseRefCount(mnSlotNumber);
 313 }
 314
 315 bool OpenGLTexture::IsUnique() const
 316 {
 317     return !mpImpl || mpImpl.unique();
 318 }
 319
 320 GLuint OpenGLTexture::Id() const
 321 {
 322     if (mpImpl)
 323         return mpImpl->mnTexture;
 324     return 0;
 325 }
 326
 327 int OpenGLTexture::GetWidth() const
 328 {
 329     return maRect.GetWidth();
 330 }
 331
 332 int OpenGLTexture::GetHeight() const
 333 {
 334     return maRect.GetHeight();
 335 }
 336
 337 GLuint OpenGLTexture::StencilId() const
 338 {
 339     return mpImpl ? mpImpl->mnOptStencil : 0;
 340 }
 341
 342 GLuint OpenGLTexture::AddStencil()
 343 {
 344     if (mpImpl)
 345         return mpImpl->AddStencil();
 346     else
 347         return 0;
 348 }
 349
 350 void OpenGLTexture::GetCoord( GLfloat* pCoord, const SalTwoRect& rPosAry, bool bInverted ) const
 351 {
 352     VCL_GL_INFO( "Getting coord " << Id() << " [" << maRect.Left() << "," << maRect.Top() << "] " << GetWidth() << "x" << GetHeight() );
 353
 354     if (!IsValid())
 355     {
 356         pCoord[0] = pCoord[1] = pCoord[2] = pCoord[3] = 0.0f;
 357         pCoord[4] = pCoord[5] = pCoord[6] = pCoord[7] = 0.0f;
 358         return;
 359     }
 360
 361     pCoord[0] = pCoord[2] = (maRect.Left() + rPosAry.mnSrcX) / (double) mpImpl->mnWidth;
 362     pCoord[4] = pCoord[6] = (maRect.Left() + rPosAry.mnSrcX + rPosAry.mnSrcWidth) / (double) mpImpl->mnWidth;
 363
 364     if( !bInverted )
 365     {
 366         pCoord[3] = pCoord[5] = 1.0f - (maRect.Top() + rPosAry.mnSrcY) / (double) mpImpl->mnHeight;
 367         pCoord[1] = pCoord[7] = 1.0f - (maRect.Top() + rPosAry.mnSrcY + rPosAry.mnSrcHeight) / (double) mpImpl->mnHeight;
 368     }
 369     else
 370     {
 371         pCoord[1] = pCoord[7] = 1.0f - (maRect.Top() + rPosAry.mnSrcY) / (double) mpImpl->mnHeight;
 372         pCoord[3] = pCoord[5] = 1.0f - (maRect.Top() + rPosAry.mnSrcY + rPosAry.mnSrcHeight) / (double) mpImpl->mnHeight;
 373     }
 374 }
 375
 376 bool OpenGLTexture::GetTextureRect(const SalTwoRect& rPosAry, bool bInverted, GLfloat& x1, GLfloat& x2, GLfloat& y1, GLfloat& y2) const
 377 {
 378     if (IsValid())
 379     {
 380         double fTextureWidth(mpImpl->mnWidth);
 381         double fTextureHeight(mpImpl->mnHeight);
 382
 383         x1 = (maRect.Left() + rPosAry.mnSrcX) / fTextureWidth;
 384         x2 = (maRect.Left() + rPosAry.mnSrcX + rPosAry.mnSrcWidth) / fTextureWidth;
 385
 386         if (bInverted)
 387         {
 388             y2 = 1.0f - (maRect.Top() + rPosAry.mnSrcY) / fTextureHeight;
 389             y1 = 1.0f - (maRect.Top() + rPosAry.mnSrcY + rPosAry.mnSrcHeight) / fTextureHeight;
 390         }
 391         else
 392         {
 393             y1 = 1.0f - (maRect.Top() + rPosAry.mnSrcY) / fTextureHeight;
 394             y2 = 1.0f - (maRect.Top() + rPosAry.mnSrcY + rPosAry.mnSrcHeight) / fTextureHeight;
 395         }
 396         return true;
 397     }
 398     return false;
 399 }
 400
 401 template <>
 402 void OpenGLTexture::FillCoords<GL_TRIANGLE_FAN>(std::vector<GLfloat>& rCoords, const SalTwoRect& rPosAry, bool bInverted) const
 403 {
 404     GLfloat x1 = 0.0f;
 405     GLfloat x2 = 0.0f;
 406     GLfloat y1 = 0.0f;
 407     GLfloat y2 = 0.0f;
 408
 409     GetTextureRect(rPosAry, bInverted, x1, x2, y1, y2);
 410
 411     rCoords.insert(rCoords.end(), {
 412         x1, y2, x1, y1,
 413         x2, y1, x2, y2
 414     });
 415 }
 416
 417 template <>
 418 void OpenGLTexture::FillCoords<GL_TRIANGLES>(std::vector<GLfloat>& rCoords, const SalTwoRect& rPosAry, bool bInverted) const
 419 {
 420     GLfloat x1 = 0.0f;
 421     GLfloat x2 = 0.0f;
 422     GLfloat y1 = 0.0f;
 423     GLfloat y2 = 0.0f;
 424
 425     GetTextureRect(rPosAry, bInverted, x1, x2, y1, y2);
 426
 427     rCoords.insert(rCoords.end(), {
 428         x1, y1, x2, y1, x1, y2,
 429         x1, y2, x2, y1, x2, y2
 430     });
 431 }
 432
 433 void OpenGLTexture::GetWholeCoord( GLfloat* pCoord ) const
 434 {
 435     if( GetWidth() != mpImpl->mnWidth || GetHeight() != mpImpl->mnHeight )
 436     {
 437         pCoord[0] = pCoord[2] = maRect.Left() / (double) mpImpl->mnWidth;
 438         pCoord[4] = pCoord[6] = maRect.Right() / (double) mpImpl->mnWidth;
 439         pCoord[3] = pCoord[5] = 1.0f - maRect.Top() / (double) mpImpl->mnHeight;
 440         pCoord[1] = pCoord[7] = 1.0f - maRect.Bottom() / (double) mpImpl->mnHeight;
 441     }
 442     else
 443     {
 444         pCoord[0] = pCoord[2] = 0;
 445         pCoord[4] = pCoord[6] = 1;
 446         pCoord[1] = pCoord[7] = 0;
 447         pCoord[3] = pCoord[5] = 1;
 448     }
 449 }
 450
 451 GLenum OpenGLTexture::GetFilter() const
 452 {
 453     if( mpImpl )
 454         return mpImpl->mnFilter;
 455     return GL_NEAREST;
 456 }
 457
 458 bool OpenGLTexture::CopyData(int nWidth, int nHeight, int nFormat, int nType, sal_uInt8* pData)
 459 {
 460     if (!pData || !IsValid())
 461         return false;
 462
 463     int nX = maRect.Left();
 464     int nY = maRect.Top();
 465
 466     return mpImpl->InsertBuffer(nX, nY, nWidth, nHeight, nFormat, nType, pData);
 467 }
 468
 469 void OpenGLTexture::SetFilter( GLenum nFilter )
 470 {
 471     if( mpImpl )
 472     {
 473         mpImpl->mnFilter = nFilter;
 474         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, nFilter );
 475         CHECK_GL_ERROR();
 476         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, nFilter );
 477         CHECK_GL_ERROR();
 478     }
 479 }
 480
 481 void OpenGLTexture::Bind()
 482 {
 483     if (IsValid())
 484     {
 485         OpenGLContext::getVCLContext()->state().texture().bind(mpImpl->mnTexture);
 486     }
 487     else
 488         VCL_GL_INFO( "OpenGLTexture::Binding invalid texture" );
 489
 490     CHECK_GL_ERROR();
 491 }
 492
 493 void OpenGLTexture::Unbind()
 494 {
 495     if (IsValid())
 496     {
 497         OpenGLContext::getVCLContext()->state().texture().unbind(mpImpl->mnTexture);
 498     }
 499 }
 500
 501 void OpenGLTexture::SaveToFile(const OUString& rFileName)
 502 {
 503     std::vector<sal_uInt8> aBuffer(GetWidth() * GetHeight() * 4);
 504     Read(GL_BGRA, GL_UNSIGNED_BYTE, aBuffer.data());
 505     BitmapEx aBitmap = OpenGLHelper::ConvertBGRABufferToBitmapEx(aBuffer.data(), GetWidth(), GetHeight());
 506     try
 507     {
 508         vcl::PNGWriter aWriter(aBitmap);
 509         SvFileStream sOutput(rFileName, StreamMode::WRITE);
 510         aWriter.Write(sOutput);
 511         sOutput.Close();
 512     }
 513     catch (...)
 514     {
 515         SAL_WARN("vcl.opengl", "Error writing png to " << rFileName);
 516     }
 517 }
 518
 519 void OpenGLTexture::Read( GLenum nFormat, GLenum nType, sal_uInt8* pData )
 520 {
 521     if (!IsValid())
 522     {
 523         SAL_WARN( "vcl.opengl", "Can't read invalid texture" );
 524         return;
 525     }
 526
 527     OpenGLVCLContextZone aContextZone;
 528
 529     VCL_GL_INFO( "Reading texture " << Id() << " " << GetWidth() << "x" << GetHeight() );
 530
 531     if( GetWidth() == mpImpl->mnWidth && GetHeight() == mpImpl->mnHeight )
 532     {
 533         Bind();
 534         glPixelStorei( GL_PACK_ALIGNMENT, 1 );
 535         CHECK_GL_ERROR();
 536         // XXX: Call not available with GLES 2.0
 537         glGetTexImage( GL_TEXTURE_2D, 0, nFormat, nType, pData );
 538         CHECK_GL_ERROR();
 539         Unbind();
 540     }
 541     else
 542     {
 543         long nWidth = maRect.GetWidth();
 544         long nHeight = maRect.GetHeight();
 545         long nX = maRect.Left();
 546         long nY = mpImpl->mnHeight - maRect.Top() - nHeight;
 547
 548         // Retrieve current context
 549         ImplSVData* pSVData = ImplGetSVData();
 550         rtl::Reference<OpenGLContext> pContext = pSVData->maGDIData.mpLastContext;
 551         OpenGLFramebuffer* pFramebuffer = pContext->AcquireFramebuffer(*this);
 552         glPixelStorei(GL_PACK_ALIGNMENT, 1);
 553         CHECK_GL_ERROR();
 554         glReadPixels(nX, nY, nWidth, nHeight, nFormat, nType, pData);
 555         CHECK_GL_ERROR();
 556         OpenGLContext::ReleaseFramebuffer(pFramebuffer);
 557     }
 558 }
 559
 560 OpenGLTexture::operator bool() const
 561 {
 562     return IsValid();
 563 }
 564
 565 OpenGLTexture& OpenGLTexture::operator=( const OpenGLTexture& rTexture )
 566 {
 567     if (rTexture.mpImpl)
 568     {
 569         rTexture.mpImpl->IncreaseRefCount(rTexture.mnSlotNumber);
 570     }
 571
 572     if (mpImpl)
 573         mpImpl->DecreaseRefCount(mnSlotNumber);
 574
 575     maRect = rTexture.maRect;
 576     mpImpl = rTexture.mpImpl;
 577     mnSlotNumber = rTexture.mnSlotNumber;
 578
 579     return *this;
 580 }
 581
 582 bool OpenGLTexture::operator==( const OpenGLTexture& rTexture ) const
 583 {
 584     return (mpImpl == rTexture.mpImpl
 585          && maRect == rTexture.maRect
 586          && mnSlotNumber == rTexture.mnSlotNumber);
 587 }
 588
 589 bool OpenGLTexture::operator!=( const OpenGLTexture& rTexture ) const
 590 {
 591     return !( *this == rTexture );
 592 }
 593
 594 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */