void Texture::initialise(const TextureResource* init_data /* = nullptr */)
{
GLenum tex_type = toTextureType(type());
GLenum colour_fmt = toSurfaceFormat(format());
# if defined(VCL_GL_ARB_direct_state_access)
glCreateTextures(tex_type, 1, &_glId);
allocImpl(colour_fmt);
// Configure texture
glTextureParameteri(_glId, GL_TEXTURE_BASE_LEVEL, firstMipMapLevel());
glTextureParameteri(_glId, GL_TEXTURE_MAX_LEVEL, firstMipMapLevel() + mipMapLevels() - 1);
# elif defined(VCL_GL_EXT_direct_state_access)
glGenTextures(1, &_glId);
allocImpl(colour_fmt);
// Configure texture
glTextureParameteriEXT(_glId, tex_type, GL_TEXTURE_BASE_LEVEL, firstMipMapLevel());
glTextureParameteriEXT(_glId, tex_type, GL_TEXTURE_MAX_LEVEL, firstMipMapLevel() + mipMapLevels() - 1);
# else
glCreateTextures(tex_type, 1, &_glId);
TextureBindPoint bp(tex_type, _glId);
allocImpl(colour_fmt);
// Configure texture
glTexParameteri(tex_type, GL_TEXTURE_BASE_LEVEL, firstMipMapLevel());
glTexParameteri(tex_type, GL_TEXTURE_MAX_LEVEL, firstMipMapLevel() + mipMapLevels() - 1);
# endif
if (init_data)
updateImpl(*init_data);
}
/**
* @brief
* Constructor
*/
Texture2DArrayDsa::Texture2DArrayDsa(OpenGLRenderer &openGLRenderer, unsigned int width, unsigned int height, unsigned int numberOfSlices, Renderer::TextureFormat::Enum textureFormat, void *data, unsigned int flags) :
Texture2DArray(openGLRenderer, width, height, numberOfSlices)
{
#ifndef OPENGLRENDERER_NO_STATE_CLEANUP
// Backup the currently set alignment
GLint openGLAlignmentBackup = 0;
glGetIntegerv(GL_UNPACK_ALIGNMENT, &openGLAlignmentBackup);
#endif
// Set correct alignment
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// Upload the base map of the texture (mipmaps are automatically created as soon as the base map is changed)
glTextureImage3DEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, 0, Mapping::getOpenGLInternalFormat(textureFormat), static_cast<GLsizei>(width), static_cast<GLsizei>(height), static_cast<GLsizei>(numberOfSlices), 0, Mapping::getOpenGLFormat(textureFormat), Mapping::getOpenGLType(textureFormat), data);
// Build mipmaps automatically on the GPU?
if (flags & Renderer::TextureFlag::MIPMAPS)
{
glGenerateTextureMipmapEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT);
glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
}
else
{
glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
#ifndef OPENGLRENDERER_NO_STATE_CLEANUP
// Restore previous alignment
glPixelStorei(GL_UNPACK_ALIGNMENT, openGLAlignmentBackup);
#endif
}
static int glnvg__renderCreateTexture(void* uptr, int type, int w, int h, int imageFlags, const unsigned char* data)
{
GLNVGcontext* gl = (GLNVGcontext*)uptr;
GLNVGtexture* tex = glnvg__allocTexture(gl);
if (tex == NULL) return 0;
glGenTextures(1, &tex->tex);
tex->width = w;
tex->height = h;
tex->type = type;
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_ROW_LENGTH, tex->width);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
if (type == NVG_TEXTURE_RGBA)
glTextureImage2DEXT(tex->tex, GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
else
glTextureImage2DEXT(tex->tex, GL_TEXTURE_2D, 0, GL_RED, w, h, 0, GL_RED, GL_UNSIGNED_BYTE, data);
if (imageFlags & NVG_IMAGE_GENERATE_MIPMAPS) {
glTextureParameteriEXT(tex->tex, GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
} else {
glTextureParameteriEXT(tex->tex, GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
glTextureParameteriEXT(tex->tex, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
// The new way to build mipmaps on GLES and GL3
if (imageFlags & NVG_IMAGE_GENERATE_MIPMAPS) {
glGenerateTextureMipmapEXT(tex->tex, GL_TEXTURE_2D);
}
return tex->id;
}
bool initTexture2D()
{
glGenTextures(1, &TextureName);
glTextureParameteriEXT(TextureName, GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED);
glTextureParameteriEXT(TextureName, GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
glTextureParameteriEXT(TextureName, GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
glTextureParameteriEXT(TextureName, GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
glTextureParameteriEXT(TextureName, GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTextureParameteriEXT(TextureName, GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1000);
gli::texture2D Image = gli::load(TEXTURE_DIFFUSE);
for(std::size_t Level = 0; Level < Image.levels(); ++Level)
{
glTextureImage2DEXT(
TextureName,
GL_TEXTURE_2D,
GLint(Level),
GL_RGB,
GLsizei(Image[Level].dimensions().x),
GLsizei(Image[Level].dimensions().y),
0,
GL_RGB,
GL_UNSIGNED_BYTE,
Image[Level].data());
}
if(Image.levels() == 1)
glGenerateTextureMipmapEXT(TextureName, GL_TEXTURE_2D);
return glf::checkError("initTexture2D");
}
void texture::parameter(GLenum pname, int param)
{
gl_assert_error("entering texture::parameter(GLenum, int)");
#ifdef SCM_GL_USE_DIRECT_STATE_ACCESS
glTextureParameteriEXT(id(), target(), pname, param);
#else // SCM_GL_USE_DIRECT_STATE_ACCESS
binding_guard guard(target(), binding());
bind();
glTexParameteri(target(), pname, param);
unbind();
#endif // SCM_GL_USE_DIRECT_STATE_ACCESS
gl_assert_error("exiting texture::parameter(GLenum, int)");
}
void OGLTexture::TexParameteri(GLenum pname, GLint param)
{
KLAYGE_AUTO(iter, tex_param_i_.find(pname));
if ((iter == tex_param_i_.end()) || (iter->second != param))
{
if (glloader_GL_EXT_direct_state_access())
{
glTextureParameteriEXT(texture_, target_type_, pname, param);
}
else
{
glBindTexture(target_type_, texture_);
glTexParameteri(target_type_, pname, param);
}
tex_param_i_[pname] = param;
}
}
void OGLTexture::TexParameteri(GLenum pname, GLint param)
{
auto iter = tex_param_i_.find(pname);
if ((iter == tex_param_i_.end()) || (iter->second != param))
{
if (glloader_GL_VERSION_4_5() || glloader_GL_ARB_direct_state_access())
{
glTextureParameteri(texture_, pname, param);
}
else if (glloader_GL_EXT_direct_state_access())
{
glTextureParameteriEXT(texture_, target_type_, pname, param);
}
else
{
OGLRenderEngine& re = *checked_cast<OGLRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindTexture(0, target_type_, texture_);
glTexParameteri(target_type_, pname, param);
}
tex_param_i_[pname] = param;
}
}
static void init()
{
glPushGroupMarkerEXT(0, "init");
glGenTextures( 1, &tex );
GLubyte pix[] = {
0x60, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x80, 0x00, 0xff,
0x80, 0x80, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x80, 0x80, 0x80, 0xff, 0x00, 0x80, 0x80, 0xff,
0x00, 0xff, 0xff, 0xff, 0x00, 0x80, 0x00, 0xff, 0x80, 0x00, 0xff, 0xff, 0x00, 0x00, 0x80, 0xff
};
glTextureImage2DEXT( tex, GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, pix );
glTextureParameteriEXT( tex, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
glTextureParameteriEXT( tex, GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glBindMultiTextureEXT( texunit, GL_TEXTURE_2D, tex );
GLfloat mat_specular[] = { 0.0f, 0.0f, 1.0f, 1.0f };
GLfloat mat_shininess[] = { 50.0f };
GLfloat light_position[] = { 1.0f, 1.0f, 0.2f, 1.0f };
GLfloat light_atten[] = { 1.0f, 1.0f, 1.0f };
GLfloat light_diffuse[] = { 10.0f, 10.0f, 10.0f, 10.0f };
GLfloat light_specular[] = { 10.0f, 10.0f, 10.0f, 10.0f };
GLfloat light_spotdir[] = { -0.1f, -0.1f, -1.0f };
GLfloat light_spotcut[] = { 30.0f };
GLfloat light_spotexp[] = { 3.0f };
glClearColor (0.0, 0.0, 0.0, 0.0);
//glShadeModel (GL_SMOOTH);
glMatrixPushEXT( GL_MODELVIEW );
glMatrixLoadIdentityEXT( GL_MODELVIEW );
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
//glMaterialfv(GL_BACK, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightf( GL_LIGHT0, GL_LINEAR_ATTENUATION, light_atten[1] );
glLightf( GL_LIGHT0, GL_QUADRATIC_ATTENUATION, light_atten[2] );
glLightfv( GL_LIGHT0, GL_DIFFUSE, light_diffuse );
glLightfv( GL_LIGHT0, GL_SPECULAR, light_specular );
glLightfv( GL_LIGHT0, GL_SPOT_DIRECTION, light_spotdir );
glLightfv( GL_LIGHT0, GL_SPOT_CUTOFF, light_spotcut );
glLightfv( GL_LIGHT0, GL_SPOT_EXPONENT, light_spotexp );
//GLfloat light_ambient[] = { 0.0, -1.0, 0.0, 0.0 };
//glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glMatrixPopEXT( GL_MODELVIEW );
glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE );
glLightModelf( GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR );
glEnable( GL_COLOR_MATERIAL ) ;
glColorMaterial( GL_BACK, GL_SPECULAR );
glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glFogi( GL_FOG_MODE, GL_LINEAR );
glFogf( GL_FOG_START, 2.0f );
glFogf( GL_FOG_END, 4.0f );
GLfloat fog_color[] = { 1.0, 1.0, 0.0, 0.0 };
glFogfv( GL_FOG_COLOR, fog_color );
glEnable( GL_CLIP_PLANE3 );
GLdouble clip[] = { 1, 1, -1, 0 };
glClipPlane( GL_CLIP_PLANE3, clip );
glPopGroupMarkerEXT();
}
bool initTexture()
{
gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str()));
gli::gl GL(gli::gl::PROFILE_GL33);
gli::gl::format const Format = GL.translate(Texture.format(), Texture.swizzles());
glGenTextures(texture::MAX, &TextureName[0]);
glTextureParameteriEXT(TextureName[texture::TEXTURE], GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTextureParameteriEXT(TextureName[texture::TEXTURE], GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels()));
glTextureParameteriEXT(TextureName[texture::TEXTURE], GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTextureParameteriEXT(TextureName[texture::TEXTURE], GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTextureParameteriEXT(TextureName[texture::TEXTURE], GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, Format.Swizzles[0]);
glTextureParameteriEXT(TextureName[texture::TEXTURE], GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, Format.Swizzles[1]);
glTextureParameteriEXT(TextureName[texture::TEXTURE], GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, Format.Swizzles[2]);
glTextureParameteriEXT(TextureName[texture::TEXTURE], GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, Format.Swizzles[3]);
glTextureStorage2DEXT(TextureName[texture::TEXTURE], GL_TEXTURE_2D, GLint(Texture.levels()), Format.Internal, GLsizei(Texture[0].extent().x), GLsizei(Texture[0].extent().y));
for(std::size_t Level = 0; Level < Texture.levels(); ++Level)
{
glTextureSubImage2DEXT(TextureName[texture::TEXTURE], GL_TEXTURE_2D,
GLint(Level),
0, 0,
GLsizei(Texture[Level].extent().x), GLsizei(Texture[Level].extent().y),
Format.External, Format.Type,
Texture[Level].data());
}
glTextureParameteriEXT(TextureName[texture::MULTISAMPLE], GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, 0);
glTextureParameteriEXT(TextureName[texture::MULTISAMPLE], GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LEVEL, 0);
glTextureParameteriEXT(TextureName[texture::MULTISAMPLE], GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTextureParameteriEXT(TextureName[texture::MULTISAMPLE], GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTextureStorage2DMultisampleEXT(TextureName[texture::MULTISAMPLE], GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y, GL_FALSE);
glTextureParameteriEXT(TextureName[texture::COLORBUFFER], GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTextureParameteriEXT(TextureName[texture::COLORBUFFER], GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
glTextureParameteriEXT(TextureName[texture::COLORBUFFER], GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTextureParameteriEXT(TextureName[texture::COLORBUFFER], GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTextureStorage2DEXT(TextureName[texture::COLORBUFFER], GL_TEXTURE_2D, 1, GL_RGBA8, GLsizei(FRAMEBUFFER_SIZE.x), GLsizei(FRAMEBUFFER_SIZE.y));
return true;
}
//[-------------------------------------------------------]
//[ Public methods ]
//[-------------------------------------------------------]
Texture2DArrayDsa::Texture2DArrayDsa(OpenGLRenderer &openGLRenderer, uint32_t width, uint32_t height, uint32_t numberOfSlices, Renderer::TextureFormat::Enum textureFormat, const void *data, uint32_t flags) :
Texture2DArray(openGLRenderer, width, height, numberOfSlices)
{
#ifndef OPENGLRENDERER_NO_STATE_CLEANUP
// Backup the currently set alignment
GLint openGLAlignmentBackup = 0;
glGetIntegerv(GL_UNPACK_ALIGNMENT, &openGLAlignmentBackup);
#endif
// Set correct alignment
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// Create the OpenGL texture instance
const bool isARB_DSA = openGLRenderer.getExtensions().isGL_ARB_direct_state_access();
if (isARB_DSA)
{
glCreateTextures(GL_TEXTURE_2D_ARRAY_EXT, 1, &mOpenGLTexture);
}
else
{
glGenTextures(1, &mOpenGLTexture);
}
// Upload the base map of the texture (mipmaps are automatically created as soon as the base map is changed)
if (isARB_DSA)
{
glTextureStorage3D(mOpenGLTexture, 1, Mapping::getOpenGLInternalFormat(textureFormat), static_cast<GLsizei>(width), static_cast<GLsizei>(height), static_cast<GLsizei>(numberOfSlices));
if (nullptr != data)
{
glTextureSubImage3D(mOpenGLTexture, 0, 0, 0, 0, static_cast<GLsizei>(width), static_cast<GLsizei>(height), static_cast<GLsizei>(numberOfSlices), Mapping::getOpenGLFormat(textureFormat), Mapping::getOpenGLType(textureFormat), data);
}
}
else
{
glTextureImage3DEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, 0, static_cast<GLint>(Mapping::getOpenGLInternalFormat(textureFormat)), static_cast<GLsizei>(width), static_cast<GLsizei>(height), static_cast<GLsizei>(numberOfSlices), 0, Mapping::getOpenGLFormat(textureFormat), Mapping::getOpenGLType(textureFormat), data);
}
// Build mipmaps automatically on the GPU? (or GPU driver)
if (flags & Renderer::TextureFlag::GENERATE_MIPMAPS)
{
if (isARB_DSA)
{
glGenerateTextureMipmap(mOpenGLTexture);
glTextureParameteri(mOpenGLTexture, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
}
else
{
glGenerateTextureMipmapEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT);
glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
}
}
else
{
if (isARB_DSA)
{
glTextureParameteri(mOpenGLTexture, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
else
{
glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
}
if (isARB_DSA)
{
glTextureParameteri(mOpenGLTexture, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
else
{
glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
#ifndef OPENGLRENDERER_NO_STATE_CLEANUP
// Restore previous alignment
glPixelStorei(GL_UNPACK_ALIGNMENT, openGLAlignmentBackup);
#endif
}
void AbstractTexture::parameterImplementationDSA(GLenum parameter, GLint value) {
glTextureParameteriEXT(_id, _target, parameter, value);
}
