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");
}
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 initFramebuffer()
{
glGenRenderbuffers(1, &ColorRenderbufferName);
glNamedRenderbufferStorageMultisampleEXT(ColorRenderbufferName, 4, GL_RGBA, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y);
glGenFramebuffers(1, &FramebufferRenderName);
glNamedFramebufferRenderbufferEXT(FramebufferRenderName, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, ColorRenderbufferName);
if(glCheckNamedFramebufferStatusEXT(FramebufferRenderName, GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
return false;
glGenTextures(1, &ColorTextureName);
glTextureImage2DEXT(ColorTextureName, GL_TEXTURE_2D, 0, GL_RGBA8, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glGenFramebuffers(1, &FramebufferResolveName);
glNamedFramebufferTextureEXT(FramebufferResolveName, GL_COLOR_ATTACHMENT0, ColorTextureName, 0);
if(glCheckNamedFramebufferStatusEXT(FramebufferResolveName, GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
return false;
return glf::checkError("initFramebuffer");
}
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();
}
void SuzanneGL::RenderShadowMaps()
{
GLuint FramebufferName = 0;
glCreateFramebuffers(1, &FramebufferName);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glm::mat4 depthViewProjectionMatrices[NUMBER_OF_LIGHTS];
for (int i = 0; i < NUMBER_OF_LIGHTS; ++i)
{
glCreateTextures(GL_TEXTURE_2D, 1, &shadowMaps[i]);
glTextureImage2DEXT(shadowMaps[i], GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, SHADOW_RESOLUTION, SHADOW_RESOLUTION, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, shadowMaps[i], 0);
glDrawBuffer(GL_NONE);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
return;
glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, SHADOW_RESOLUTION, SHADOW_RESOLUTION);
glm::vec3 lightDir = glm::normalize(glm::vec3(lighting.lights[i].position.x, lighting.lights[i].position.y, lighting.lights[i].position.z));
glm::mat4 depthProjectionMatrix = glm::ortho<float>(-10, 10, -10, 10, -10, 20);
glm::mat4 depthViewMatrix = glm::lookAt(lightDir, glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
depthViewProjectionMatrices[i] = depthProjectionMatrix * depthViewMatrix;
shadowModelMatrixIndex = glGetUniformLocation(shadowShaderProgram, "modelMatrix");
shadowViewProjectionMatrixIndex = glGetUniformLocation(shadowShaderProgram, "viewProjectionMatrix");
glProgramUniformMatrix4fv(shadowShaderProgram, shadowViewProjectionMatrixIndex, 1, GL_FALSE, glm::value_ptr(depthViewProjectionMatrices[i]));
for (ModelGL model : models)
{
glProgramUniformMatrix4fv(shadowShaderProgram, shadowModelMatrixIndex, 1, GL_FALSE, glm::value_ptr(model.modelMatrix));
glNamedBufferSubData(materialBuffer, 0, sizeof(Material), &model.material);
glBindVertexArray(model.vertexArray);
glUseProgram(shadowShaderProgram);
glDrawArrays(GL_TRIANGLES, 0, model.vertexCount);
}
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glm::mat4 biasMatrix(
0.5, 0.0, 0.0, 0.0,
0.0, 0.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
0.5, 0.5, 0.5, 1.0
);
shadowViewProjectionMatrixIndex = glGetUniformLocation(shaderProgram, "shadowViewProjectionMatrix");
shadowBiasMatrixIndex = glGetUniformLocation(shaderProgram, "shadowBiasMatrix");
glProgramUniformMatrix4fv(shaderProgram, shadowViewProjectionMatrixIndex, 2, GL_FALSE, glm::value_ptr(depthViewProjectionMatrices[0]));
glProgramUniformMatrix4fv(shaderProgram, shadowBiasMatrixIndex, 1, GL_FALSE, glm::value_ptr(biasMatrix));
}
void AbstractTexture::imageImplementationDSA(GLenum target, GLint level, InternalFormat internalFormat, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
glTextureImage2DEXT(_id, target, level, GLint(internalFormat), size.x(), size.y(), 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
}
