source/renderer/backend/gl/Texture.cpp

   1 /* Copyright (C) 2022 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "precompiled.h"
  19
  20 #include "Texture.h"
  21
  22 #include "lib/code_annotation.h"
  23 #include "lib/config2.h"
  24 #include "lib/res/graphics/ogl_tex.h"
  25 #include "renderer/backend/gl/Device.h"
  26
  27 namespace Renderer
  28 {
  29
  30 namespace Backend
  31 {
  32
  33 namespace GL
  34 {
  35
  36 namespace
  37 {
  38
  39 GLint CalculateMinFilter(const Sampler::Desc& defaultSamplerDesc, const uint32_t mipCount)
  40 {
  41         if (mipCount == 1)
  42                 return defaultSamplerDesc.minFilter == Sampler::Filter::LINEAR ? GL_LINEAR : GL_NEAREST;
  43
  44         if (defaultSamplerDesc.minFilter == Sampler::Filter::LINEAR)
  45                 return defaultSamplerDesc.mipFilter == Sampler::Filter::LINEAR ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR_MIPMAP_NEAREST;
  46
  47         return defaultSamplerDesc.mipFilter == Sampler::Filter::LINEAR ? GL_NEAREST_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST;
  48 }
  49
  50 GLint AddressModeToGLEnum(Sampler::AddressMode addressMode)
  51 {
  52         switch (addressMode)
  53         {
  54         case Sampler::AddressMode::REPEAT: return GL_REPEAT;
  55         case Sampler::AddressMode::MIRRORED_REPEAT: return GL_MIRRORED_REPEAT;
  56         case Sampler::AddressMode::CLAMP_TO_EDGE: return GL_CLAMP_TO_EDGE;
  57         case Sampler::AddressMode::CLAMP_TO_BORDER: return GL_CLAMP_TO_BORDER;
  58         }
  59         return GL_REPEAT;
  60 }
  61
  62 GLenum TypeToGLEnum(CTexture::Type type)
  63 {
  64         GLenum target = GL_TEXTURE_2D;
  65         switch (type)
  66         {
  67         case CTexture::Type::TEXTURE_2D:
  68                 target = GL_TEXTURE_2D;
  69                 break;
  70         case CTexture::Type::TEXTURE_2D_MULTISAMPLE:
  71 #if CONFIG2_GLES
  72                 ENSURE(false && "Multisample textures are unsupported on GLES");
  73 #else
  74                 target = GL_TEXTURE_2D_MULTISAMPLE;
  75 #endif
  76                 break;
  77         case CTexture::Type::TEXTURE_CUBE:
  78                 target = GL_TEXTURE_CUBE_MAP;
  79                 break;
  80         }
  81         return target;
  82 }
  83
  84 } // anonymous namespace
  85
  86 // static
  87 std::unique_ptr<CTexture> CTexture::Create2D(const Format format,
  88         const uint32_t width, const uint32_t height,
  89         const Sampler::Desc& defaultSamplerDesc, const uint32_t mipCount, const uint32_t sampleCount)
  90 {
  91         return Create(Type::TEXTURE_2D, format, width, height, defaultSamplerDesc, mipCount, sampleCount);
  92 }
  93
  94 // static
  95 std::unique_ptr<CTexture> CTexture::Create(const Type type, const Format format,
  96         const uint32_t width, const uint32_t height,
  97         const Sampler::Desc& defaultSamplerDesc, const uint32_t mipCount, const uint32_t sampleCount)
  98 {
  99         std::unique_ptr<CTexture> texture(new CTexture());
 100
 101         ENSURE(format != Format::UNDEFINED);
 102         ENSURE(width > 0 && height > 0 && mipCount > 0);
 103         ENSURE((type == Type::TEXTURE_2D_MULTISAMPLE && sampleCount > 1) || sampleCount == 1);
 104
 105         texture->m_Format = format;
 106         texture->m_Width = width;
 107         texture->m_Height = height;
 108         texture->m_MipCount = mipCount;
 109
 110         glGenTextures(1, &texture->m_Handle);
 111
 112         ogl_WarnIfError();
 113
 114         glActiveTextureARB(GL_TEXTURE0);
 115
 116         const GLenum target = TypeToGLEnum(type);
 117
 118         glBindTexture(target, texture->m_Handle);
 119
 120         // It's forbidden to set sampler state for multisample textures.
 121         if (type != Type::TEXTURE_2D_MULTISAMPLE)
 122         {
 123                 glTexParameteri(target, GL_TEXTURE_MIN_FILTER, CalculateMinFilter(defaultSamplerDesc, mipCount));
 124                 glTexParameteri(target, GL_TEXTURE_MAG_FILTER, defaultSamplerDesc.magFilter == Sampler::Filter::LINEAR ? GL_LINEAR : GL_NEAREST);
 125
 126                 ogl_WarnIfError();
 127
 128                 glTexParameteri(target, GL_TEXTURE_WRAP_S, AddressModeToGLEnum(defaultSamplerDesc.addressModeU));
 129                 glTexParameteri(target, GL_TEXTURE_WRAP_T, AddressModeToGLEnum(defaultSamplerDesc.addressModeV));
 130         }
 131
 132 #if !CONFIG2_GLES
 133         if (type == Type::TEXTURE_CUBE)
 134                 glTexParameteri(target, GL_TEXTURE_WRAP_R, AddressModeToGLEnum(defaultSamplerDesc.addressModeW));
 135 #endif
 136
 137         ogl_WarnIfError();
 138
 139 #if !CONFIG2_GLES
 140         glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0);
 141         glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, mipCount - 1);
 142
 143         if (defaultSamplerDesc.mipLODBias != 0.0f)
 144                 glTexParameteri(target, GL_TEXTURE_LOD_BIAS, defaultSamplerDesc.mipLODBias);
 145 #endif // !CONFIG2_GLES
 146
 147         if (type == Type::TEXTURE_2D && defaultSamplerDesc.anisotropyEnabled && ogl_tex_has_anisotropy())
 148                 glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, defaultSamplerDesc.maxAnisotropy);
 149
 150         if (defaultSamplerDesc.addressModeU == Sampler::AddressMode::CLAMP_TO_BORDER ||
 151                 defaultSamplerDesc.addressModeV == Sampler::AddressMode::CLAMP_TO_BORDER ||
 152                 defaultSamplerDesc.addressModeW == Sampler::AddressMode::CLAMP_TO_BORDER)
 153         {
 154                 glTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, defaultSamplerDesc.borderColor.AsFloatArray());
 155         }
 156
 157         ogl_WarnIfError();
 158
 159         ENSURE(mipCount == 1);
 160
 161         if (type == CTexture::Type::TEXTURE_2D)
 162         {
 163                 GLint internalFormat = GL_RGBA;
 164                 // Actually pixel data is nullptr so it doesn't make sense to account
 165                 // it, but in theory some buggy drivers might complain about invalid
 166                 // pixel format.
 167                 GLenum pixelFormat = GL_RGBA;
 168                 GLenum pixelType = GL_UNSIGNED_BYTE;
 169                 switch (format)
 170                 {
 171                 case Format::UNDEFINED:
 172                         debug_warn("Texture should defined format");
 173                         break;
 174                 case Format::R8G8B8A8:
 175                         break;
 176                 case Format::A8:
 177                         internalFormat = GL_ALPHA;
 178                         pixelFormat = GL_ALPHA;
 179                         pixelType = GL_UNSIGNED_BYTE;
 180                         break;
 181 #if CONFIG2_GLES
 182                 // GLES requires pixel type == UNSIGNED_SHORT or UNSIGNED_INT for depth.
 183                 case Format::D16: FALLTHROUGH;
 184                 case Format::D24: FALLTHROUGH;
 185                 case Format::D32:
 186                         internalFormat = GL_DEPTH_COMPONENT;
 187                         pixelFormat = GL_DEPTH_COMPONENT;
 188                         pixelType = GL_UNSIGNED_SHORT;
 189                         break;
 190                 case Format::D24_S8:
 191                         debug_warn("Unsupported format");
 192                         break;
 193 #else
 194                 case Format::D16:
 195                         internalFormat = GL_DEPTH_COMPONENT16;
 196                         pixelFormat = GL_DEPTH_COMPONENT;
 197                         pixelType = GL_UNSIGNED_SHORT;
 198                         break;
 199                 case Format::D24:
 200                         internalFormat = GL_DEPTH_COMPONENT24;
 201                         pixelFormat = GL_DEPTH_COMPONENT;
 202                         pixelType = GL_UNSIGNED_SHORT;
 203                         break;
 204                 case Format::D32:
 205                         internalFormat = GL_DEPTH_COMPONENT32;
 206                         pixelFormat = GL_DEPTH_COMPONENT;
 207                         pixelType = GL_UNSIGNED_SHORT;
 208                         break;
 209                 case Format::D24_S8:
 210                         internalFormat = GL_DEPTH24_STENCIL8_EXT;
 211                         pixelFormat = GL_DEPTH_STENCIL_EXT;
 212                         pixelType = GL_UNSIGNED_INT_24_8_EXT;
 213                         break;
 214 #endif
 215                 }
 216                 glTexImage2D(target, 0, internalFormat, width, height, 0, pixelFormat, pixelType, nullptr);
 217         }
 218         else if (type == CTexture::Type::TEXTURE_2D_MULTISAMPLE)
 219         {
 220 #if !CONFIG2_GLES
 221                 if (format == Format::R8G8B8A8)
 222                 {
 223                         glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, sampleCount, GL_RGBA8, width, height, GL_TRUE);
 224                 }
 225                 else if (format == Format::D24_S8)
 226                 {
 227                         glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, sampleCount, GL_DEPTH24_STENCIL8_EXT, width, height, GL_TRUE);
 228                 }
 229                 else
 230 #endif // !CONFIG2_GLES
 231                 {
 232                         debug_warn("Unsupported format");
 233                 }
 234         }
 235
 236         ogl_WarnIfError();
 237
 238         glBindTexture(target, 0);
 239
 240         return texture;
 241 }
 242
 243 CTexture::CTexture() = default;
 244
 245 CTexture::~CTexture()
 246 {
 247         if (m_Handle)
 248                 glDeleteTextures(1, &m_Handle);
 249 }
 250
 251 } // namespace GL
 252
 253 } // namespace Backend
 254
 255 } // namespace Renderer