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