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