Texture.cpp

Go to the documentation of this file.

#include <filesystem>
#include <memory>
 
#include "graphics/Texture.h"
 
#include "Engine.h"
#include "Log.h"
#include "graphics/GraphicsAPI.h"
 
#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>
 
namespace mnd
{
 
Texture::Texture(int width, int height, int numChannels, unsigned char *data)
    : m_width(width)
    , m_height(height)
    , m_numChannels(numChannels)
{
    Init(width, height, numChannels, data);
}
 
Texture::~Texture()
{
    if (m_textureID > 0)
    {
        glDeleteTextures(1, &m_textureID);
    }
}
 
void Texture::Init(int width, int height, int numChannels, unsigned char *data)
{
    glGenTextures(1, &m_textureID);
    glBindTexture(GL_TEXTURE_2D, m_textureID);
 
    GLint  internalFormat = GL_RGB;
    GLenum format         = GL_RGB;
 
    if (numChannels == 4)
    {
        internalFormat = GL_RGBA;
        format         = GL_RGBA;
    }
 
    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, format, GL_UNSIGNED_BYTE, data);
 
    glGenerateMipmap(GL_TEXTURE_2D);
 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
    // PS1-style pixelated sampling: nearest-neighbor, no mip filtering.
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
 
std::shared_ptr<Texture> TextureManager::GetOrLoadTexture(const std::string &path)
{
    auto it = m_textures.find(path);
    if (it != m_textures.end())
    {
        return it->second;
    }
 
    auto texture     = Texture::Load(path);
    m_textures[path] = texture;
    return texture;
}
 
GLuint Texture::GetID() const
{
    return m_textureID;
}
 
std::shared_ptr<Texture> Texture::Load(const std::string &path)
{
    int width       = 0;
    int height      = 0;
    int numChannels = 0;
 
    auto &fs       = Engine::GetInstance().GetFileSystem();
    auto  fullPath = fs.GetAssetsFolder() / path;
 
    if (!std::filesystem::exists(fullPath))
    {
        return nullptr;
    }
 
    std::shared_ptr<Texture> result;
 
    unsigned char *data = stbi_load(fullPath.string().c_str(), &width, &height, &numChannels, 0);
 
    if (data != nullptr)
    {
        result = std::make_shared<Texture>(width, height, numChannels, data);
        LOG_INFO("Image loaded");
        stbi_image_free(data);
    }
 
    return result;
}
 
std::shared_ptr<Texture> Texture::LoadFromMemory(const unsigned char *data, int sizeBytes)
{
    if (data == nullptr || sizeBytes <= 0)
    {
        return nullptr;
    }
 
    int width       = 0;
    int height      = 0;
    int numChannels = 0;
 
    unsigned char *decoded = stbi_load_from_memory(data, sizeBytes, &width, &height, &numChannels, 0);
    if (decoded == nullptr)
    {
        return nullptr;
    }
 
    auto result = std::make_shared<Texture>(width, height, numChannels, decoded);
    stbi_image_free(decoded);
    return result;
}
 
}  // namespace mnd