bluecore/engine/RenderDevice.cpp

241 líneas
5.0 KiB
C++

#include "RenderDevice.h"
#include "Utilities/Log.h"
#include "Math/Matrix.h"
#include "GL/gl.h"
#include "GL/glu.h"
namespace BlueCore
{
void RenderDevice::WindowResizeSlot(int width, int height)
{
glViewport( 0, 0, width, height);
_ViewportWidth = width;
_ViewportHeight = height;
}
RenderDevice::RenderDevice(RenderWindow* renderWindow) :
_RenderWindow(renderWindow), _ActiveTextures(0)
{
if (_RenderWindow.valid())
{
_RenderWindow->WindowResizeSignal.connect(this,
&RenderDevice::WindowResizeSlot);
_RenderWindow->WindowCloseSignal.connect(this,
&RenderDevice::WindowCloseSlot);
_ViewportWidth = _RenderWindow->getWidth();
_ViewportHeight = _RenderWindow->getHeight();
glViewport( 0, 0, _ViewportWidth, _ViewportHeight);
}
clog << ">>> RenderDevice constructed..." << endlog;
}
RenderDevice::~RenderDevice()
{
clog << ">>> RenderDevice destructed..."<< endlog;
}
void RenderDevice::WindowCloseSlot()
{
DeviceShutdownSignal();
}
int RenderDevice::getViewportWidth()
{
return _ViewportWidth;
}
int RenderDevice::getViewportHeight()
{
return _ViewportHeight;
}
void RenderDevice::begin2D()
{
// prepare state
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glNormal3f( 0.0, 0.0, 1.0);
// set projection matrix
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
//int newheight = (_width / 16.0) * 9.0;
gluOrtho2D( 0, _ViewportWidth-1, 0, _ViewportHeight-1);
// prepare model matrix
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
}
void RenderDevice::end2D()
{
// restore projection matrix
glMatrixMode(GL_PROJECTION);
glPopMatrix();
// restore model matrix
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
// restore old state
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
}
void RenderDevice::clear()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
}
void RenderDevice::swap()
{
glfwSwapBuffers();
}
void RenderDevice::setAmbientLight(float r, float g, float b)
{
GLfloat lightAmbient[] =
{ r, g, b, 1.0f };
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightAmbient);
}
void RenderDevice::begin3D(Camera *camera)
{
_Camera = camera;
setupProjectionMatrix();
setupViewMatrix();
}
void RenderDevice::end3D()
{
}
void RenderDevice::setupProjectionMatrix()
{
if (_Camera.valid())
{
Scalar fH = tan( (_Camera->getFov() / 2) / 180 * Pi)
* _Camera->getNearPlane();
Scalar fW = fH * _ViewportWidth / _ViewportHeight;
// setup projectiom matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum( -fW, fW, -fH, fH, _Camera->getNearPlane(),
_Camera->getFarPlane());
}
}
void RenderDevice::setupViewMatrix()
{
if (_Camera.valid())
{
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
Matrix4x4 m(_Camera->getRotation(), _Camera->getRotation().applyInversed(_Camera->getPosition() * -1.0) );
glMultMatrixd( ( GLdouble * ) &m.m );
}
}
void RenderDevice::pushTransformation(const Vector3& position,
const Quaternion& orientation)
{
glMatrixMode( GL_MODELVIEW);
glPushMatrix();
Matrix4x4 m(orientation, position);
glMultMatrixd( ( GLdouble * ) &m.m );
}
void RenderDevice::pushAbsoluteTransformation(const Vector3& position,
const Quaternion& orientation)
{
glMatrixMode( GL_MODELVIEW);
glPushMatrix();
Matrix4x4 m(orientation, position);
glLoadMatrixd( ( GLdouble * ) &m.m );
}
void RenderDevice::popTransformation()
{
glMatrixMode( GL_MODELVIEW);
glPopMatrix();
}
void RenderDevice::setTexture(unsigned int unit, Texture* texture, bool last)
{
glActiveTextureARB(GL_TEXTURE0_ARB + unit);
glBindTexture(GL_TEXTURE_2D, texture->getId());
glEnable(GL_TEXTURE_2D);
if (unit > _ActiveTextures)
_ActiveTextures = unit;
if (last)
{
for (unsigned int i = unit + 1; i < _ActiveTextures; i++)
{
glActiveTextureARB(GL_TEXTURE0_ARB + i);
glDisable( GL_TEXTURE_2D);
}
_ActiveTextures = unit;
}
}
void RenderDevice::setShaderProgram(ShaderProgram shader_program)
{
// if ( !_usingShaders)
// return;
glUseProgramObjectARB(shader_program);
}
void RenderDevice::setTexture(ShaderProgram shader_program,
unsigned int texture, const std::string &name)
{
// if ( !_usingShaders)
// return;
GLint location = glGetUniformLocationARB(shader_program, name.c_str() );
//if( location > 0 )
glUniform1iARB(location, texture);
}
#if 0
void RenderDevice::setTangentBuffer(ShaderProgram shader_program,
const Buffer<Vector3Float>& tangent_buffer, const std::string &name)
{
// if ( !_usingShaders || !tangent_buffer)
// return;
GLuint location = glGetAttribLocationARB(shader_program, name.c_str() );
glEnableVertexAttribArrayARB(location);
//tangent_buffer->bind();
glVertexAttribPointerARB(location, 3, GL_FLOAT, 0, 0, 0);
}
//------------------------------------------------------------------------------
void ShaderManager::disableTangentBuffer(ShaderProgram shader_program,
const std::string &name)
{
// if ( !_usingShaders)
// return;
GLuint location = glGetAttribLocationARB(shader_program, name.c_str() );
glDisableVertexAttribArrayARB(location);
}
#endif
} // namespace BlueCore