inline void tglMultMatrix(const math::Matrix4& matrix)
{
#if defined(TAU_SCALAR_DOUBLE)
glMultTransposeMatrixd((const double*)matrix.getData());
#else
glMultTransposeMatrixf((const float*)matrix.getData());
#endif
}
static int lua_glMultTransposeMatrixf(lua_State *L) {
CHECK_ARG_COUNT(L, 1);
Array1D<Float> m(L, 1);
if (m.size() != 16) {
luaL_error(L, "gl.MultTransposeMatrixf: invalid matrix data");
}
glMultTransposeMatrixf(m);
return 0;
}
void set_camera_view( void )
{
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
// do rotation
glMultTransposeMatrixf( core.camera.rotation.mat );
//glRotatef( core.camera.pitch , 1.f, 0.f, 0.f );
//glRotatef( core.camera.heading, 0.f, 1.f, 0.f );
// THEN move the origin
glTranslatef( core.camera.origin[0], core.camera.origin[1], core.camera.origin[2] );
}
void drawer_t::drawTriangles( tessellation_t * tes )
{
tesQuads_t * qtes = (tesQuads_t *) tes;
glPushMatrix();
glTranslatef( tes->origin[0], tes->origin[1], tes->origin[2] );
glMultTransposeMatrixf( tes->rotation.mat );
glEnableClientState( GL_COLOR_ARRAY );
glEnableClientState( GL_VERTEX_ARRAY );
glVertexPointer( 3, GL_FLOAT, 0, qtes->buf.data );
glColorPointer( 3, GL_FLOAT, 0, qtes->colors.data );
glDrawArrays( GL_TRIANGLE_STRIP, 0, qtes->colors.length() );
glDisableClientState( GL_COLOR_ARRAY );
glDisableClientState( GL_VERTEX_ARRAY );
glPopMatrix();
}
void PointLight::render()
{
glPushMatrix();
glMultTransposeMatrixf(object.getComponent<Transform>()->getLocalToWorld().get());
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glColor3f(0, 1, 0);
glDrawCube();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_TEXTURE);
glEnable(GL_LIGHTING);
glPopMatrix();
}
void ShapeUtils::applyTransform(const cv::Mat &mtx) {
// Convert incoming matrix to float for OpenGL
cv::Mat mtxf;
if (mtx.depth() != CV_32F) {
mtx.convertTo(mtxf, CV_32F);
} else {
mtxf = mtx;
}
cv::Mat mtx3D = cv::Mat::eye(4, 4, CV_32FC1);
mtx3D.at<float>(0, 0) = mtxf.at<float>(0, 0);
mtx3D.at<float>(0, 1) = mtxf.at<float>(0, 1);
mtx3D.at<float>(0, 3) = mtxf.at<float>(0, 2);
mtx3D.at<float>(1, 0) = mtxf.at<float>(1, 0);
mtx3D.at<float>(1, 1) = mtxf.at<float>(1, 1);
mtx3D.at<float>(1, 3) = mtxf.at<float>(1, 2);
mtx3D.at<float>(3, 0) = mtxf.at<float>(2, 0);
mtx3D.at<float>(3, 1) = mtxf.at<float>(2, 1);
glMultTransposeMatrixf(mtx3D.ptr<float>(0));
}
void TScene::RenderShipPreview(Vector pos,Vector dir, Vector up, int NumMesh)
{
// glPushMatrix();
// glLoadIdentity();
float mmodel[16]={0};
Vector a(0,0,0),b(0,0,0);
Vector eye=Camera->GetPosition()-pos;
eye=NormalizeVector(eye);
a=CrossProduct(&eye,&Camera->UpVector);
a=NormalizeVector(a);
b=CrossProduct(&a,&eye);//*-1.0f;
// D3DXMatrixLookAtLH (&matView, &(eye*150.0f),&(b*50.0f), &World.aiGlobal.cam->GetTy());
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(eye.x*40.0f,eye.y*40.0f,eye.z*40.0f,-b.x*10.0f,-b.y*10.0f,-b.z*10.0f,Camera->UpVector.x,Camera->UpVector.y,Camera->UpVector.z);
// engine->m_d3dDevice->SetTransform (D3DTS_VIEW, &matView);
glGetFloatv(GL_MODELVIEW_MATRIX, mmodel);
// World.resManager.m_Res[World.aiGlobal.cam->target->gRes].p_d3dx_mesh->DrawSubset( 0 );
// if (World.aiGlobal.cam->target){
// matWorld=World.aiGlobal.cam->target->GetCurMatrix();
// engine->m_d3dDevice->SetTransform(D3DTS_WORLD, &matWorld);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMultMatrixf(ProjectionMatrix);
// glMultTransposeMatrixf(mmodel);
glMultMatrixf(mmodel);
// glPushMatrix();
// glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0,0,0,dir.x,dir.y,dir.z,up.x,up.y,up.z);
glGetFloatv(GL_MODELVIEW_MATRIX, mmodel);
// glPopMatrix();
glLoadIdentity();
// glTranslatef(pos.x, pos.y, pos.z);
glMultTransposeMatrixf(mmodel);
Mesh[NumMesh].Render();
// glPopMatrix();
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultTransposeMatrixf(JNIEnv *env, jclass clazz, jlong m, jlong function_pointer) {
const GLfloat *m_address = (const GLfloat *)(intptr_t)m;
glMultTransposeMatrixfPROC glMultTransposeMatrixf = (glMultTransposeMatrixfPROC)((intptr_t)function_pointer);
glMultTransposeMatrixf(m_address);
}
/*** Procesamiento de cada cuadro ***/
void Video( float elapsed )
{
/* Limpio la pantalla */
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
/* Perspectiva */
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( 50.0f/zoom, // Ángulo de visión vertical
(GLfloat)WIDTH / (GLfloat)HEIGHT, // Aspecto
1.0f, // Plano cercano
2000.0f ); // Plano lejano
/* Cámara */
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
/* Espada */
glPushMatrix();
glMultTransposeMatrixf(volumesEspada.matrix);
// glTranslatef(cam.pos.x, cam.pos.y + 5, cam.pos.z + 10);
glRotatef(angX, 1.0f, 0.0f, 0.0f);
glRotatef(angY, 0.0f, 1.0f, 0.0f);
glRotatef(angZ, 0.0f, 0.0f, 1.0f);
glCallList(modeloEspada.modelList);
glPopMatrix();
/*________*/
VECTOR dir = SumVector(cam.pos, cam.look);
gluLookAt( cam.pos.x, cam.pos.y, cam.pos.z, // Posición
dir.x, dir.y, dir.z, // Dirección
0.0f, 1.0f, 0.0f ); // Arriba
/*Luz*/
glPushMatrix();
SetDirLight(GL_LIGHT0, &dirLight);
glEnable (GL_LIGHT0);
glPopMatrix();
/*Terreno*/
glPushMatrix();
SetMaterial( &terrain.material );
glBindTexture(GL_TEXTURE_2D, terrain.textureID);
glCallList( terrain.terrainList );
glPopMatrix();
/*agua*/
/*
glPushMatrix();
glEnable(GL_BLEND);
SetMaterial( &agua.material );
glBindTexture(GL_TEXTURE_2D, agua.textureID);
glCallList( agua.terrainList );
glDisable(GL_BLEND);
glPopMatrix();
*/
/*texto fps*/
// RenderText(fpstex, arialfont, 0, 0, &fontColor, GL_FALSE);
/*SkyBox*/
glPushMatrix();
RenderSkybox(&skybox, &skyboxBox, &skyboxColor);
glPopMatrix();
//**texturitas!!!**//
/* subacuatica*/
glPushMatrix();
//glLoadIdentity();
glEnable(GL_BLEND);
SetMaterial(&aguaMtrl);
glBindTexture(GL_TEXTURE_2D, UnderwaterTex);
glTranslatef(cam.pos.x, vWater, cam.pos.z);
glScalef(1000.0f, 1000.0f, 1000.0f);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER , );
glBegin(GL_QUADS);
//Cara posterior
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f ( 0.0f, 1.0f + movWater);
glVertex3f (-1.0f, 0.0f, -1.0f);
glTexCoord2f ( 0.0f, 0.0f + movWater);
glVertex3f ( 1.0f, 0.0f, -1.0f);
glTexCoord2f ( 1.0f, 0.0f + movWater);
glVertex3f ( 1.0f, 0.0f, 1.0f);
glTexCoord2f ( 1.0f, 1.0f + movWater);
glVertex3f (-1.0f, 0.0f, 1.0f);
glEnd();
glDisable(GL_BLEND);
glPopMatrix();
//_______________//
//Transparencia
/*HUD*/
Begin2D(WIDTH, HEIGHT);
if ( !renderUnderwater){
}
if (under){
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
Render2DTexture( UnderwaterTex, 0, 0, WIDTH, HEIGHT );
}
//RENDER DEL MAPA Y EL DOT
glPushMatrix();
glTranslatef(WIDTH*0.79 , HEIGHT * 0.79, 0);
Render2DTexture( mapTex, 0, 0, mapWidth, mapHeight );
Render2DTexture( dotTex, dotX, dotZ, dotX+10, dotZ+10 );
glPopMatrix();
Render2DTexture(hudNull, 0, 0, WIDTH, HEIGHT);
Render2DTexture(oxBar, 0, 0, ox * 10.0f, 50.0f);
End2D();
/* Ejecutar comandos en cola */
glFlush();
/* BackBuffer=FrontBuffer(flip) */
SDL_GL_SwapBuffers();
}
void glMultTransposeMatrixd(const GLdouble *m) {
constArrayToFloat(m, 16);
glMultTransposeMatrixf(s);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultTransposeMatrixf(JNIEnv *__env, jclass clazz, jlong mAddress, jlong __functionAddress) {
const GLfloat *m = (const GLfloat *)(intptr_t)mAddress;
glMultTransposeMatrixfPROC glMultTransposeMatrixf = (glMultTransposeMatrixfPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glMultTransposeMatrixf(m);
}
void gl4es_glMatrixMultTransposef(GLenum matrixMode, const GLfloat *m) {
mat(glMultTransposeMatrixf(m));
}
void shape::draw(bool selected)
{
//Ensure we're in the correct mode for drawing
glMatrixMode(GL_MODELVIEW);
//In order to translate only this shape, we need to push and pop the current matrix
glPushMatrix();
//Translate the shape so that its centre is in the right location
glTranslated(mXCentre, mYCentre, 0.0);
// glPushMatrix();
//glPushMatrix();
QMatrix4x4 myMat4(myMat);
glMultTransposeMatrixf(myMat4.data());
//glPopMatrix();
//glPopMatrix();
//This might be a good place to add other transformations
//(Here's an example, the identity matrix)
/*
GLdouble matrix[4][4];
matrix[0][0] = 1;
matrix[0][1] = 0;
matrix[0][2] = 0;
matrix[0][3] = 0;
matrix[1][0] = 0;
matrix[1][1] = 1;
matrix[1][2] = 0;
matrix[1][3] = 0;
matrix[2][0] = 0;
matrix[2][1] = 0;
matrix[2][2] = 1;
matrix[2][3] = 0;
matrix[3][0] = 0;
matrix[3][1] = 0;
matrix[3][2] = 0;
matrix[3][3] = 1;
glMultMatrixd(&matrix[0][0]);
*/
//Set the colour
glColor3f(mNormalColour.redF(), mNormalColour.greenF(), mNormalColour.blueF());
//Draw the actual shape
glBegin(GL_POLYGON);
drawShape();
glEnd();
//If it's selected, draw a highlight
if(selected)
{
glColor3f(mSelectedColour.redF(), mSelectedColour.greenF(), mSelectedColour.blueF());
const float lineWidth = 3.0;
glLineWidth(lineWidth);
glBegin(GL_LINE_LOOP);
drawShape();
glEnd();
}
//Restore the original matrix
glPopMatrix();
}
