vcl/opengl/PackedTextureAtlas.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  */
  10
  11 #include <sal/config.h>
  12 #include <vcl/opengl/OpenGLContext.hxx>
  13 #include <vcl/opengl/OpenGLHelper.hxx>
  14
  15 #include "opengl/framebuffer.hxx"
  16 #include "opengl/texture.hxx"
  17
  18 #include "opengl/PackedTextureAtlas.hxx"
  19
  20 struct Node
  21 {
  22     Rectangle mRectangle;
  23     std::unique_ptr<Node> mLeftNode;
  24     std::unique_ptr<Node> mRightNode;
  25     bool mOccupied;
  26
  27     explicit Node(int nWidth, int nHeight);
  28     explicit Node(Rectangle& aRectangle);
  29
  30     bool isLeaf();
  31     Node* insert(int nWidth, int nHeight, int nPadding);
  32 };
  33
  34 Node::Node(int nWidth, int nHeight)
  35     : mRectangle(Rectangle(Point(), Size(nWidth, nHeight)))
  36     , mLeftNode()
  37     , mRightNode()
  38     , mOccupied(false)
  39 {}
  40
  41 Node::Node(Rectangle& aRectangle)
  42     : mRectangle(aRectangle)
  43     , mLeftNode()
  44     , mRightNode()
  45     , mOccupied(false)
  46 {}
  47
  48 bool Node::isLeaf()
  49 {
  50     return mLeftNode.get()  == nullptr &&
  51            mRightNode.get() == nullptr;
  52 }
  53
  54 Node* Node::insert(int nWidth, int nHeight, int nPadding)
  55 {
  56     if (!isLeaf())
  57     {
  58         Node* pNewNode = mLeftNode->insert(nWidth, nHeight, nPadding);
  59
  60         if (pNewNode != nullptr)
  61             return pNewNode;
  62
  63         return mRightNode->insert(nWidth, nHeight, nPadding);
  64     }
  65     else
  66     {
  67         if (mOccupied)
  68         {
  69             return nullptr;
  70         }
  71
  72         if (nWidth > mRectangle.GetWidth() || nHeight > mRectangle.GetHeight())
  73         {   // does not fit
  74             return nullptr;
  75         }
  76
  77         if (nWidth == mRectangle.GetWidth() && nHeight == mRectangle.GetHeight())
  78         {   // perfect fit
  79             mOccupied = true;
  80             return this;
  81         }
  82
  83         int dw = mRectangle.GetWidth() - nWidth;
  84         int dh = mRectangle.GetHeight() - nHeight;
  85
  86         Rectangle aLeftRect;
  87         Rectangle aRightRect;
  88         if (dw > dh)
  89         {
  90             aLeftRect = Rectangle(Point(mRectangle.Left(), mRectangle.Top()),
  91                                   Size(nWidth, mRectangle.GetHeight()));
  92             aRightRect = Rectangle(Point(nPadding + mRectangle.Left() + nWidth, mRectangle.Top()),
  93                                    Size(mRectangle.GetWidth() - nWidth - nPadding, mRectangle.GetHeight()));
  94         }
  95         else
  96         {
  97             aLeftRect = Rectangle(Point(mRectangle.Left(), mRectangle.Top()),
  98                                   Size(mRectangle.GetWidth(), nHeight));
  99             aRightRect = Rectangle(Point(mRectangle.Left(), nPadding + mRectangle.Top() + nHeight),
 100                                    Size(mRectangle.GetWidth(), mRectangle.GetHeight() - nHeight - nPadding));
 101         }
 102
 103         mLeftNode.reset(new Node(aLeftRect));
 104         mRightNode.reset(new Node(aRightRect));
 105
 106         return mLeftNode->insert(nWidth, nHeight, nPadding);
 107     }
 108 }
 109
 110 struct PackedTexture
 111 {
 112     std::unique_ptr<ImplOpenGLTexture> mpTexture;
 113     std::unique_ptr<Node> mpRootNode;
 114     int mnDeallocatedArea;
 115
 116     PackedTexture(int nWidth, int nHeight)
 117         : mpTexture(new ImplOpenGLTexture(nWidth, nHeight, true))
 118         , mpRootNode(new Node(nWidth, nHeight))
 119         , mnDeallocatedArea(0)
 120     {}
 121 };
 122
 123 PackedTextureAtlasManager::PackedTextureAtlasManager(int nTextureWidth, int nTextureHeight)
 124     : mnTextureWidth(nTextureWidth)
 125     , mnTextureHeight(nTextureHeight)
 126 {
 127 }
 128
 129 PackedTextureAtlasManager::~PackedTextureAtlasManager()
 130 {
 131     for (std::unique_ptr<PackedTexture>& pPackedTexture : maPackedTextures)
 132     {
 133         // Free texture early in VCL shutdown while we have a context.
 134         pPackedTexture->mpTexture.reset();
 135     }
 136 }
 137
 138 void PackedTextureAtlasManager::CreateNewTexture()
 139 {
 140     std::unique_ptr<PackedTexture> pPackedTexture(new PackedTexture(mnTextureWidth, mnTextureHeight));
 141     GLuint nTextureID = pPackedTexture->mpTexture->mnTexture;
 142     maPackedTextures.push_back(std::move(pPackedTexture));
 143     VCL_GL_INFO("PackedTextureAtlas::CreateNewTexture adding texture: " << nTextureID <<
 144                 " atlases: " << maPackedTextures.size());
 145 }
 146
 147 OpenGLTexture PackedTextureAtlasManager::Reserve(int nWidth, int nHeight)
 148 {
 149     for (std::unique_ptr<PackedTexture>& pPackedTexture : maPackedTextures)
 150     {
 151         Node* pNode = pPackedTexture->mpRootNode->insert(nWidth, nHeight, 1);
 152         if (pNode != nullptr)
 153         {
 154             return OpenGLTexture(pPackedTexture->mpTexture.get(), pNode->mRectangle, -1);
 155         }
 156     }
 157     CreateNewTexture();
 158     std::unique_ptr<PackedTexture>& pPackedTexture = maPackedTextures.back();
 159     Node* pNode = pPackedTexture->mpRootNode->insert(nWidth, nHeight, 1);
 160     if (pNode != nullptr)
 161     {
 162         return OpenGLTexture(pPackedTexture->mpTexture.get(), pNode->mRectangle, -1);
 163     }
 164     return OpenGLTexture();
 165 }
 166
 167 OpenGLTexture PackedTextureAtlasManager::InsertBuffer(int nWidth, int nHeight, int nFormat, int nType, sal_uInt8* pData)
 168 {
 169     OpenGLTexture aTexture = Reserve(nWidth, nHeight);
 170     if (aTexture && pData == nullptr)
 171         return aTexture;
 172
 173     aTexture.CopyData(nWidth, nHeight, nFormat, nType, pData);
 174
 175     return aTexture;
 176 }
 177
 178 std::vector<GLuint> PackedTextureAtlasManager::ReduceTextureNumber(int nMaxNumberOfTextures)
 179 {
 180     std::vector<GLuint> aTextureIDs;
 181     while (int(maPackedTextures.size()) > nMaxNumberOfTextures)
 182     {
 183         // Remove oldest created texture
 184         GLuint nTextureID = maPackedTextures[0]->mpTexture->mnTexture;
 185         aTextureIDs.push_back(nTextureID);
 186         maPackedTextures.erase(maPackedTextures.begin());
 187         VCL_GL_INFO("PackedTextureAtlas::ReduceTextureNumber removing texture: " << nTextureID <<
 188                     " atlases: " << maPackedTextures.size());
 189     }
 190     return aTextureIDs;
 191 }
 192
 193 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */