demotool/texture.cc
Emmanuel BENOîT aabf8949a8 Got rid of old texture binding code
Also this fixes the DoF texture wrapping bullshit
2017-10-02 14:48:16 +02:00

348 lines
7.8 KiB
C++

#include "externals.hh"
#include "utilities.hh"
#include "texture.hh"
/*==============================================================================*/
T_Texture::T_Texture(
__rd__ const uint32_t width ,
__rd__ const uint32_t height ,
__rd__ const E_TexType type ,
__rd__ const uint32_t levels )
: levels_( levels ) , width_( width ) , height_( height )
{
assert( levels > 0 );
glGenTextures( 1 , &id_ );
glBindTexture( GL_TEXTURE_2D , id_ );
GLenum ifmt , fmt , dt;
switch ( type ) {
case E_TexType::RGBA8:
ifmt = GL_RGBA8;
fmt = GL_RGBA;
dt = GL_UNSIGNED_BYTE;
break;
case E_TexType::RGBA16F:
ifmt = GL_RGBA16F;
fmt = GL_RGBA;
dt = GL_FLOAT;
break;
case E_TexType::RGB8:
ifmt = GL_RGB8;
fmt = GL_RGB;
dt = GL_UNSIGNED_BYTE;
break;
case E_TexType::RGB16F:
ifmt = GL_RGB16F;
fmt = GL_RGB;
dt = GL_FLOAT;
break;
case E_TexType::R8:
ifmt = GL_R8;
fmt = GL_RED;
dt = GL_UNSIGNED_BYTE;
break;
case E_TexType::R16F:
ifmt = GL_R16F;
fmt = GL_RED;
dt = GL_FLOAT;
break;
}
glTexParameteri( GL_TEXTURE_2D , GL_TEXTURE_BASE_LEVEL , 0 );
glTexParameteri( GL_TEXTURE_2D , GL_TEXTURE_MAX_LEVEL , levels - 1 );
glTexParameterf( GL_TEXTURE_2D , GL_TEXTURE_MIN_LOD , 0 );
glTexParameterf( GL_TEXTURE_2D , GL_TEXTURE_MAX_LOD , levels - 1 );
glTexParameteri( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_NEAREST );
glTexParameteri( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_NEAREST );
uint32_t w = width , h = height;
for ( auto i = 0u ; i < levels ; i ++ ) {
#ifdef INTRUSIVE_TRACES
printf( "init %p txid %d lv %d sz %dx%d\n" , this , id_ ,
i , w , h );
#endif
glTexImage2D( GL_TEXTURE_2D , i , ifmt , w , h , 0 , fmt , dt , nullptr );
w >>= 1;
h >>= 1;
assert( w && h );
}
GL_ASSERT( );
}
T_Texture::~T_Texture( )
{
glDeleteTextures( 1 , &id_ );
}
T_Texture& T_Texture::samplingMode(
__rd__ const E_TexSampling mode )
{
glBindTexture( GL_TEXTURE_2D , id_ );
GLenum min , max;
switch ( mode ) {
case E_TexSampling::NEAREST:
min = levels_ > 1 ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST;
max = GL_NEAREST;
break;
case E_TexSampling::LINEAR:
min = levels_ > 1 ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
max = GL_LINEAR;
break;
}
glTexParameteri( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , min );
glTexParameteri( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , max );
return *this;
}
T_Texture& T_Texture::wrap(
__rd__ const E_TexWrap mode )
{
GLenum gm;
switch ( mode ) {
case E_TexWrap::REPEAT:
gm = GL_REPEAT;
break;
case E_TexWrap::CLAMP_EDGE:
gm = GL_CLAMP_TO_EDGE;
break;
case E_TexWrap::CLAMP_BORDER:
gm = GL_CLAMP_TO_BORDER;
break;
}
glTexParameteri( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , gm );
glTexParameteri( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , gm );
return *this;
}
/*==============================================================================*/
T_TextureSampler::T_TextureSampler( )
{
glGenSamplers( 1 , &id_ );
GL_ASSERT( );
}
T_TextureSampler::T_TextureSampler(
__rw__ T_TextureSampler&& other ) noexcept
{
std::swap( id_ , other.id_ );
std::swap( sampling_ , other.sampling_ );
std::swap( lodSampling_ , other.lodSampling_ );
std::swap( hasLOD_ , other.hasLOD_ );
setSamplingMode( );
}
T_TextureSampler& T_TextureSampler::operator =(
__rw__ T_TextureSampler&& other ) noexcept
{
std::swap( id_ , other.id_ );
std::swap( sampling_ , other.sampling_ );
std::swap( lodSampling_ , other.lodSampling_ );
std::swap( hasLOD_ , other.hasLOD_ );
return *this;
}
T_TextureSampler::~T_TextureSampler( )
{
if ( id_ != 0 ) {
glDeleteSamplers( 1 , &id_ );
}
}
/*----------------------------------------------------------------------------*/
T_TextureSampler& T_TextureSampler::sampling(
__rd__ const E_TexSampling mode )
{
sampling_ = mode;
setSamplingMode( );
return *this;
}
T_TextureSampler& T_TextureSampler::noMipmap( )
{
hasLOD_ = false;
setSamplingMode( );
return *this;
}
T_TextureSampler& T_TextureSampler::mipmap(
__rd__ const E_TexSampling mode )
{
hasLOD_ = true;
lodSampling_ = mode;
setSamplingMode( );
return *this;
}
T_TextureSampler& T_TextureSampler::wrap(
__rd__ const E_TexWrap mode )
{
GLenum gm;
switch ( mode ) {
case E_TexWrap::REPEAT:
gm = GL_REPEAT;
break;
case E_TexWrap::CLAMP_EDGE:
gm = GL_CLAMP_TO_EDGE;
break;
case E_TexWrap::CLAMP_BORDER:
gm = GL_CLAMP_TO_BORDER;
break;
}
glSamplerParameteri( id_ , GL_TEXTURE_WRAP_S , gm );
glSamplerParameteri( id_ , GL_TEXTURE_WRAP_T , gm );
GL_ASSERT( );
return *this;
}
T_TextureSampler& T_TextureSampler::lod(
__rd__ const float min ,
__rd__ const float max )
{
glSamplerParameterf( id_ , GL_TEXTURE_MIN_LOD , min );
glSamplerParameterf( id_ , GL_TEXTURE_MAX_LOD , max );
GL_ASSERT( );
return *this;
}
/*----------------------------------------------------------------------------*/
void T_TextureSampler::setSamplingMode( ) const
{
GLenum min , max;
if ( hasLOD_ ) {
switch ( sampling_ ) {
case E_TexSampling::NEAREST:
min = lodSampling_ == E_TexSampling::LINEAR
? GL_NEAREST_MIPMAP_LINEAR
: GL_NEAREST_MIPMAP_NEAREST;
max = GL_NEAREST;
break;
case E_TexSampling::LINEAR:
min = lodSampling_ == E_TexSampling::LINEAR
? GL_LINEAR_MIPMAP_LINEAR
: GL_LINEAR_MIPMAP_NEAREST;
max = GL_LINEAR;
break;
}
} else {
min = ( sampling_ == E_TexSampling::LINEAR )
? GL_LINEAR
: GL_NEAREST;
max = min;
}
glSamplerParameteri( id_ , GL_TEXTURE_MIN_FILTER , min );
glSamplerParameteri( id_ , GL_TEXTURE_MAG_FILTER , max );
GL_ASSERT( );
}
/*============================================================================*/
constexpr uint32_t T_TextureManagement::MaxUnits;
std::unique_ptr< T_TextureManagement > T_TextureManagement::instance_;
T_TextureManagement& T_TextureManagement::TM( )
{
if ( !instance_ ) {
instance_.reset( new T_TextureManagement( ) );
}
return *instance_;
}
void T_TextureManagement::Shutdown( )
{
instance_.reset( );
}
T_TextureManagement::T_TextureManagement( )
{
std::shared_ptr< T_TextureSampler > tsam;
tsam = std::make_shared< T_TextureSampler >( );
tsam->wrap( E_TexWrap::CLAMP_EDGE ).sampling( E_TexSampling::NEAREST );
samplers_[ "nearest-edge" ] = tsam;
tsam = std::make_shared< T_TextureSampler >( );
tsam->wrap( E_TexWrap::CLAMP_EDGE ).sampling( E_TexSampling::LINEAR );
samplers_[ "linear-edge" ] = tsam;
tsam = std::make_shared< T_TextureSampler >( );
tsam->wrap( E_TexWrap::CLAMP_BORDER ).sampling( E_TexSampling::NEAREST );
samplers_[ "nearest-border" ] = tsam;
tsam = std::make_shared< T_TextureSampler >( );
tsam->wrap( E_TexWrap::CLAMP_BORDER ).sampling( E_TexSampling::LINEAR );
samplers_[ "linear-border" ] = tsam;
}
T_TextureSampler const* T_TextureManagement::sampler(
__rd__ std::string const& name ) const
{
auto pos( samplers_.find( name ) );
if ( pos == samplers_.end( ) ) {
return nullptr;
}
return (*pos).second.get( );
}
void T_TextureManagement::bind(
__rd__ const uint32_t unit ,
__rd__ T_Texture const& texture )
{
assert( unit < MaxUnits );
auto& u( bindings_[ unit ] );
if ( u.texture == texture.id( ) && !u.sampler ) {
return;
}
u.texture = texture.id( );
u.sampler = 0;
glBindTextureUnit( unit , texture.id( ) );
glBindSampler( unit , 0 );
}
void T_TextureManagement::bind(
__rd__ const uint32_t unit ,
__rd__ T_Texture const& texture ,
__rd__ T_TextureSampler const& sampler )
{
assert( unit < MaxUnits );
auto& u( bindings_[ unit ] );
if ( u.texture == texture.id( ) && u.sampler == sampler.id( ) ) {
return;
}
u.texture = texture.id( );
u.sampler = sampler.id( );
glBindTextureUnit( unit , texture.id( ) );
glBindSampler( unit , sampler.id( ) );
}
void T_TextureManagement::reset( )
{
for ( auto i = 0u ; i < MaxUnits ; i ++ ) {
auto& u( bindings_[ i ] );
u.texture = 0;
u.sampler = 0;
glBindTextureUnit( i , 0 );
glBindSampler( i , 0 );
}
}