Texture::Texture(int width, int height, int precision)
{
Index = 0xFFFE;
glGenTextures(1, &Index);
glBindTexture(GL_TEXTURE_2D, Index);
if(PrintGLError() || Index == 0xFFFE)
{
Valid = false;
Index = 0;
return ;
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
PrintGLError();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
PrintGLError();
GLenum format = GL_RGBA;
if(precision == 16)
format = GL_RGBA16F_EXT;
if(precision == 32)
format = GL_RGBA32F_EXT;
ImageSize = TextureSize = Vec2I{width, height};
glTexImage2D(GL_TEXTURE_2D, 0, format, TextureSize.X, TextureSize.Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
PrintGLError();
TextureCoordinates = calcTextureCoordinates(0, ImageSize);
Valid = true;
}
void Shutdown() {
PrintGLError();
delete fxaaFilter;
delete fxaaShader;
delete crate;
delete deathstroke;
delete camera;
delete susane;
delete diffuseTextureShader;
delete solidColorShader;
delete deathstrokeDiffuse;
PrintGLError();
}
void RenderContext2D::setRenderTarget(RenderTarget* target)
{
mRenderTarget = target;
if(target)
mRenderTarget->bind();
PrintGLError();
}
bool Initialize() {
camera = new Camera(GetWidth(), GetHeight(), Camera::COLOR_DEPTH, 60.0f, float(GetWidth()) / float(GetHeight()), 0.01f, 500.0f);
deathstrokeDiffuse = new Texture("Assets/Deathstroke_D.png");
crate = new Obj("Assets/Cube.obj");
susane = new Obj("Assets/Monkey.obj");
deathstroke = new Obj("Assets/Deathstroke.obj");
solidColorShader = new Shader();
solidColorShader->SetVertexShaderFromFile("Shaders/solid.vs");
solidColorShader->SetFragmentShaderFromFile("Shaders/solid.fs");
solidColorShader->Prepare();
diffuseTextureShader = new Shader();
diffuseTextureShader->SetVertexShaderFromFile("Shaders/diffuse.vs");
diffuseTextureShader->SetFragmentShaderFromFile("Shaders/diffuse.fs");
diffuseTextureShader->Prepare();
fxaaShader = new Shader();
fxaaShader->SetVertexShaderFromFile("Shaders/fxaa.vs");
fxaaShader->SetFragmentShaderFromFile("Shaders/fxaa.fs");
fxaaShader->Prepare();
fxaaFilter = new PostProcess(GetWidth(), GetHeight(), camera->GetRenderTarget(), fxaaShader);
PrintGLError();
return true;
}
RenderContext2D::RenderContext2D(RenderTarget* target)
{
glEnable(GL_BLEND);
glDisable(GL_CULL_FACE);
setRenderTarget(target);
setShader (mShader);
PrintGLError();
}
void Resize(int w, int h) {
camera->LookAt(camPosition, glm::vec3(0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
camera->Perspective(60.0f, float(w) / float(h), 0.01f, 500.0f);
camera->UpdateFrameBuffer(w, h);
fxaaFilter->Resize(w, h);
fxaaFilter->SetInput(camera->GetRenderTarget());
fxaaFilter->SetShader(fxaaShader);
PrintGLError();
}
/// Re-instates old shader as needed.
void TextFont::OnEndRender(GraphicsState & graphicsState)
{
if (shaderBased)
{
// Bind 0?
}
else
{
glEnd();
}
/// enable writing to depth-buffer again.4
glDepthMask(GL_TRUE);
PrintGLError("Font.h: Error after rendering error");
}
int Game::Loop(WindowMgr* windowMgr)
{
while (!inputMgr->quit)
{
time->UpdateTime();
inputMgr->UpdateInput(time->deltaTime);
world->UpdateAll(time->deltaTime);
renderer->RenderAll(windowMgr);
windowMgr->SwapBuffers();
PrintGLError();
SDL_Delay(10);
}
return 0;
}
Texture::Texture(const TextureData& tex)
{
Index = 0xFFFE;
glGenTextures(1, &Index);
glBindTexture(GL_TEXTURE_2D, Index);
if(PrintGLError() || Index == 0xFFFE)
{
Valid = false;
Index = 0;
return ;
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
PrintGLError();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
PrintGLError();
ImageSize = Vec2I{tex.Data.Width, tex.Data.Height};
TextureSize = ImageSize;
//TextureSize = Vec2I{makePowerOfTwo(width), makePowerOfTwo(height)};
// TODO: Handle non-dense texture data
if(!(TextureSize == ImageSize))
{
std::vector<uint32_t> empty(TextureSize.X * TextureSize.Y, 0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TextureSize.X, TextureSize.Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, empty.data());
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, ImageSize.X, ImageSize.Y, GL_RGBA, GL_UNSIGNED_BYTE, tex.Data.DataPtr);
PrintGLError();
}
else
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TextureSize.X, TextureSize.Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex.Data.DataPtr);
PrintGLError();
}
glGenerateMipmap(GL_TEXTURE_2D);
PrintGLError();
TextureCoordinates = calcTextureCoordinates(0, ImageSize);
Valid = true;
}
void RenderContext2D::clear(Vec3F clr)
{
glClearColor(clr.X, clr.Y, clr.Z, 1.f);
glClear(GL_COLOR_BUFFER_BIT);
PrintGLError();
}
void RenderContext2D::setShader(ShaderProgram shader)
{
mShader = shader;
glUseProgram(mShader.Handle);
PrintGLError();
}
bool Update(float dt) {
PrintGLError();
return true;
}
bool TextFont::PrepareForRender()
{
if (!texture){
std::cout<<"\nERROR: Texture not allocated in Font::RenderText";
return false;
}
if (!whitened && false){ // Change so whitening process is executed only for those fonts which need it.
MakeTextureWhite();
}
/// Bufferize texture as needed.
if (texture->glid == -1)
{
texture->releaseOnBufferization = false;
TexMan.BufferizeTexture(texture);
}
/// Prepare shader.
if (shaderBased)
{
// Load shader.
shader = ShadeMan.SetActiveShader("Font");
if (!shader)
return false;
// Enable texture
glEnable(GL_TEXTURE_2D);
// Set matrices.
shader->SetProjectionMatrix(graphicsState->projectionMatrixF);
shader->SetViewMatrix(graphicsState->viewMatrixF);
shader->SetModelMatrix(graphicsState->modelMatrixF);
// Set text color
glUniform4f(shader->uniformPrimaryColorVec4, color.x, color.y, color.z, color.w);
// set hover state
glUniform1i(shader->uniformHoveredOver, hoveredOver? 1 : 0);
// Set some color.. hmm.
// glColor4f(color[0], color[1], color[2], color[3]);
glEnable(GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Don't write depth to depth buffer.
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
// Set texture in shader? hm.
glBindTexture(GL_TEXTURE_2D, texture->glid);
// Fetch and bufferizes model.
if (!model)
model = ModelMan.GetModel("sprite.obj");
model->BufferizeIfNeeded();
}
else
{
// Enable textures if it wasn't already
glEnable(GL_TEXTURE_2D);
PrintGLError("Font.h: glEnable(GL_TEXTURE_2D) error");
/// Set fill mode!
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
ShadeMan.SetActiveShader(0);
glEnable(GL_TEXTURE_2D);
// glEnable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glLoadMatrixf(graphicsState->projectionMatrixF.getPointer());
Matrix4f modelView = graphicsState->viewMatrixF * graphicsState->modelMatrixF;
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(modelView.getPointer());
glColor4f(color[0], color[1], color[2], color[3]);
glEnable(GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_LIGHTING);
// Disable depth test.. lol no?
// glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glBindTexture(GL_TEXTURE_2D, texture->glid);
// when texture area is small, bilinear filter the closest mipmap
// when texture area is large, bilinear filter the original
bool linear = false;
if (linear){
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
else {
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
// glUseProgram(shader->shaderProgram);
/// Begin the QUADS!
glBegin(GL_QUADS);
}
return true;
}
