int main()
{
int width = 800;
int height = 600;
int mesh_width = 256;
int mesh_height = 256;
// Creation du device
cutilSafeCall( cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() ) );
// Creation d'une fenetre
C3::Window OpenGLWin;
OpenGLWin.Create(C3::WindowMode(width,height),"CudaC3");
// Glew init
GLenum err = glewInit();
if(err != GLEW_OK)
std::cout << "Error on GLEW initialization.\n";
// Configuration OpenGL
glClearColor(0.0, 0.0, 0.0, 1.0);
glDisable(GL_DEPTH_TEST);
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)width / (GLfloat) height, 0.1, 10.0);
// VBO
// *** Create
GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// *** Initialize
unsigned int size = mesh_width * mesh_height * 4 * sizeof(float);
glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// *** Register in CUDA
cudaGraphicsResource *cuda_vbo_resource = NULL;
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_vbo_resource, vbo, cudaGraphicsMapFlagsWriteDiscard));
float g_fAnim = 0.f;
int nbFrame = 0;
float timeFPS = 0.f;
while(OpenGLWin.IsOpened())
{
// Events
C3::Event event;
while(OpenGLWin.PoolEvent(event))
{
//std::cout << "Event !" << std::endl;
if(event.Type == C3::Event::Closed)
{
std::cout << "Close ... " << std::endl;
OpenGLWin.Close();
}
else if(event.Type == C3::Event::KeyPressed)
{
if(event.Key.Code == C3::Key::Escape)
{
std::cout << "Close ... " << std::endl;
OpenGLWin.Close();
}
}
}
// Mise a jour du temps
g_fAnim += OpenGLWin.GetFrameTime() / 1000.f;
timeFPS += OpenGLWin.GetFrameTime() / 1000.f;
nbFrame++;
if(timeFPS > 1.0f)
{
std::stringstream ss;
ss << "CudaC3 [" << (int)ceil( nbFrame / timeFPS ) << " FPS]";
OpenGLWin.SetTitle(ss.str());
timeFPS = 0.f;
nbFrame = 0;
}
// Draw the scene
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// Lancer le calcul CUDA
// *** map OpenGL buffer object for writing from CUDA
float4 *dptr;
cutilSafeCall(cudaGraphicsMapResources(1, &cuda_vbo_resource, 0));
size_t num_bytes;
cutilSafeCall(cudaGraphicsResourceGetMappedPointer((void **)&dptr, &num_bytes, cuda_vbo_resource));
// *** Run kernel
runKernel(dptr, mesh_width, mesh_height,g_fAnim);
cutilSafeCall( cutilDeviceSynchronize() );
// *** Unmap
cutilSafeCall(cudaGraphicsUnmapResources(1, &cuda_vbo_resource, 0));
// OpenGL
// *** Make some transformation
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0, 0.0, -3.0);
glRotatef(0.0, 1.0, 0.0, 0.0);
glRotatef(0.0, 0.0, 1.0, 0.0);
// *** Render VBO
// --- Bind
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexPointer(4, GL_FLOAT, 0, 0);
// --- Draw
glEnableClientState(GL_VERTEX_ARRAY);
glColor3f(1.0, 0.0, 0.0);
glDrawArrays(GL_POINTS, 0, mesh_width * mesh_height);
glDisableClientState(GL_VERTEX_ARRAY);
// Swap buffers
OpenGLWin.Display();
}
// Liberation des ressources
cudaGraphicsUnregisterResource(cuda_vbo_resource);
glBindBuffer(1, vbo);
glDeleteBuffers(1, &vbo);
// Close device
cutilDeviceReset();
return 0;
}
void Example::render()
{
// 4. Use the buffer to render the data.
// Clear the color buffer and depth buffer with colors specified
// above with glClearColor(): 0.5f, 0.5f, 0.5f, 0.5f
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Replace the current matrix with the identity matrix
glLoadIdentity();
// Position the camera with
// gluLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ)
// first three args give position of camera
// second three give point the camera's looking at
// third three tell which way is up
gluLookAt(0.0, 6.0, 0.1, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
// Enable a vertex array
// Vertex arrays are a series of arrays that we declare
// to OpenGL, which stores different per-vertex attributes ,
// including positions and colors.
// The GL_VERTEX_ARRAY parameter tells OpenGL that the array to be
// enabled is a collection of positions. Another common parameter is
// GL_COLOR_ARRAY, which tells OpenGL that the array to be enabled
// is a collection of colors.
glEnableClientState(GL_VERTEX_ARRAY);
// Activate the buffer we loaded earlier
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
// Tells OpenGL that the array or part of the array contains vertices, and
// provides some details about the array so OpenGL knows how to use it
// void glVertexPointer(GLint size, GLenum type,
// GLsizei stride, const GLvoid *array);
//
// The call below tells OpenGL that each vertex in the array has three
// elements (x, y, and z), and each element is a floating-point number.
// The stride of 0 means there's no padding between vertices, and the
// final 0 says that the array starts at the first position in the array.
glVertexPointer(3, GL_FLOAT, 0, 0);
float pointSize = 0.5f;
for (unsigned int i = 0; i < m_vertices.size() / 3; ++i)
{
// Change the size of a point in pixels with
// void glPointSize(GLfloat size)
glPointSize(pointSize);
// glDrawArrays() is the most common method for rendering arrays.
// void glDrawArrays(GLenum mode, GLint first, GLsizei count);
// where mode is a type of primitive to render. Different modes include
// GL_POINTS, GL_LINES and GL_TRIANGLES
// The call below asks OpenGL to draw one point at the location
// given by m_vertices[i*3]
glDrawArrays(GL_POINTS, i, 1);
pointSize += 1.0f;
}
// Disable the client state when you're done with the array
glDisableClientState(GL_VERTEX_ARRAY);
}
static void drawIP(const char* ip, int size, int xx, int yy)
{
static const char* chardot = " "
" "
" "
" "
".";
static const char* char0 = "..."
". ."
". ."
". ."
"...";
static const char* char1 = "."
"."
"."
"."
".";
static const char* char2 = "..."
" ."
"..."
". "
"...";
static const char* char3 = "..."
" ."
"..."
" ."
"...";
static const char* char4 = ". "
". ."
". ."
"..."
" .";
static const char* char5 = "..."
". "
"..."
" ."
"...";
static const char* char6 = "..."
". "
"..."
". ."
"...";
static const char* char7 = "..."
" ."
" ."
" ."
" .";
static const char* char8 = "..."
". ."
"..."
". ."
"...";
static const char* char9 = "..."
". ."
"..."
" ."
"...";
static const char* loading =
". ... ... .. . ... ... "
". . . . . . . . . . . "
". . . ... . . . . . . . "
". . . . . . . . . . . . "
"... ... . . .. . . . ... . . .";
static const char* localip =
". ... ... ... . . ... . ... ... ... "
". . . . . . . . . . . . . . . . ."
". . . . ... . . ... . . . .. . . "
". . . . . . . . . . . . . . . ."
"... ... ... . . ... . . . . . . ... ";
static const char* ipinfo =
". ... . ... ... ... "
". . . . . . . . . "
". ... . . . .. . . ."
". . . . . . . . "
". . . . . . ... .";
static const char* version =
"... ... . . ... . "
" . . . . . . . . . ."
"... . . . . . . . . ."
". . . . ... . . ..."
"... ... . . . ... .";
static const char* chars[] = {char0, char1, char2, char3, char4, char5, char6, char7, char8, char9};
gglColor4f(0, 0, 0, 1);
oglDisable(GL_TEXTURE_2D);
oglEnableClientState(GL_VERTEX_ARRAY);
float v[8];
glVertexPointer(2, GL_FLOAT, 0, v);
int len = strlen(ip);
for (int i = 0; i < len; ++i)
{
const char* chr;
if (ip[i] == '.')
chr = chardot;
else if (ip[i] == 'I')
chr = localip;
else if (ip[i] == 'L')
chr = loading;
else if (ip[i] == 'V')
chr = version;
else
chr = chars[ip[i] - '0'];
int height = 5;
int width = strlen(chr) / height;
for (int y = 0; y < height; ++y)
for (int x = 0; x < width; ++x)
{
if (chr[x + y * width] == '.')
{
//glBegin(GL_QUADS);
//glVertex2i((x + xx) * size, (y + yy) * size);
//glVertex2i((x + xx + 1) * size, (y + yy) * size);
//glVertex2i((x + xx + 1) * size, (y + yy + 1) * size);
//glVertex2i((x + xx) * size, (y + yy + 1) * size);
//glEnd();
v[0] = (x + xx) * size; v[1] = (y + yy) * size;
v[2] = (x + xx + 1) * size; v[3] = (y + yy) * size;
v[4] = (x + xx) * size; v[5] = (y + yy + 1) * size;
v[6] = (x + xx + 1) * size; v[7] = (y + yy + 1) * size;
oglDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
}
xx = xx + width + 1;
}
oglDisableClientState(GL_VERTEX_ARRAY);
}
void
drawWater (Water *w, Bool full, Bool wire)
{
static const float mat_shininess[] = { 50.0 };
static const float mat_specular[] = { 0.5, 0.5, 0.5, 1.0 };
static const float mat_diffuse[] = { 0.2, 0.2, 0.2, 1.0 };
static const float mat_ambient[] = { 0.1, 0.1, 0.1, 1.0 };
static const float lmodel_ambient[] = { 0.4, 0.4, 0.4, 1.0 };
static const float lmodel_localviewer[] = { 0.0 };
float *v;
if (!w)
return;
glDisable (GL_DEPTH_TEST);
if (full)
{
glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
glLightModelfv (GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv (GL_LIGHT_MODEL_LOCAL_VIEWER, lmodel_localviewer);
glEnable (GL_COLOR_MATERIAL);
glEnable (GL_LIGHTING);
glEnable (GL_LIGHT1);
glDisable (GL_LIGHT0);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
v = (float *) w->vertices;
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
glEnableClientState (GL_NORMAL_ARRAY);
glVertexPointer (3, GL_FLOAT, 6 * sizeof (float), v);
glNormalPointer (GL_FLOAT, 6 * sizeof (float), v + 3);
glDrawElements (GL_TRIANGLES, w->nSIdx, GL_UNSIGNED_INT, w->indices);
glDisableClientState (GL_NORMAL_ARRAY);
glDisable (GL_LIGHTING);
glDrawElements (GL_TRIANGLES, w->nWIdx, GL_UNSIGNED_INT, w->indices + w->nSIdx);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
}
if (wire)
{
int i, j;
glColor4usv (defaultColor);
glDisable (GL_LIGHTING);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
for (i = 0; i < w->nIndices; i+=3)
{
glBegin(GL_LINE_LOOP);
for (j = 0; j < 3; j++)
glVertex3f(w->vertices[w->indices[i + j]].v[0],
w->vertices[w->indices[i + j]].v[1],
w->vertices[w->indices[i + j]].v[2]);
glEnd();
}
}
}
void SW::GLViewer::init()
{
setGL();
initGLSL();
#if BUFFER_
//glClearColor(0.0, 0.0, 0.0, 0.0);
//glDisable(GL_DITHER);
glShadeModel(GL_FLAT);
//glEnable(GL_DEPTH_TEST);
enum{Vertices, Color, Elements, NumVBOs};
GLuint buffers[NumVBOs];
// glew init is very important or errors occur
glewInit();
// generate vertex arrays, and each array is corresponding to a object to be render
glGenVertexArrays(1, &arrayId);
#ifdef QT_BUFFER
QGLFunctions qtgl;
qtgl.initializeGLFunctions(0);
#endif
// 3D world coordinate of points
#ifdef QT_BUFFER
QVector<QVector3D> Verts;
Verts.append(QVector3D(-1.0, -1.0, -1.0));
Verts.append(QVector3D(-1.0, -1.0, 1.0));
Verts.append(QVector3D(-1.0, 1.0, -1.0));
Verts.append(QVector3D(-1.0, 1.0, 1.0));
Verts.append(QVector3D(1.0, -1.0, -1.0));
Verts.append(QVector3D(1.0, -1.0, 1.0));
Verts.append(QVector3D(1.0, 1.0, -1.0));
Verts.append(QVector3D(1.0, 1.0, 1.0));
#else
GLfloat Verts[][3] = {
{-1.0, -1.0, -1.0},
{-1.0, -1.0, 1.0},
{-1.0, 1.0, -1.0},
{-1.0, 1.0, 1.0},
{1.0, -1.0, -1.0},
{1.0, -1.0, 1.0},
{1.0, 1.0, -1.0},
{1.0, 1.0, 1.0},
};
#endif
// colors of points
#ifdef QT_BUFFER
QVector<QVector3D> Colors;
Colors.append(QVector3D(0, 0.0, 0.0));
Colors.append(QVector3D(0, 0.0, 1.0));
Colors.append(QVector3D(0, 1.0, 0.0));
Colors.append(QVector3D(0, 1.0, 1.0));
Colors.append(QVector3D(1.0, 0.0, 0.0));
Colors.append(QVector3D(1.0, 0.0, 1.0));
Colors.append(QVector3D(1.0, 1.0, 0.0));
Colors.append(QVector3D(1.0, 1.0, 1.0));
#else
GLfloat Colors[][3] = {
{0.0, 0.0, 0.0},
{0.0, 0.0, 1.0},
{0.0, 1.0, 0.0},
{0.0, 1.0, 1.0},
{1.0, 0.0, 0.0},
{1.0, 0.0, 1.0},
{1.0, 1.0, 0.0},
{1.0, 1.0, 1.0},
};
#endif
// indices of points
#ifdef QT_BUFFER
QVector<uint> Indices;
Indices.append(0);Indices.append(1);Indices.append(3);Indices.append(2);
Indices.append(4);Indices.append(6);Indices.append(7);Indices.append(5);
Indices.append(2);Indices.append(3);Indices.append(7);Indices.append(6);
Indices.append(0);Indices.append(4);Indices.append(5);Indices.append(1);
Indices.append(0);Indices.append(2);Indices.append(6);Indices.append(4);
Indices.append(1);Indices.append(5);Indices.append(7);Indices.append(3);
#else
GLubyte Indices[]={
0, 1, 3, 2,
4, 6, 7, 5,
2, 3, 7, 6,
0, 4, 5, 1,
0, 2, 6, 4,
1, 5, 7, 3,
};
#endif
// active a vertex array
glBindVertexArray(arrayId);
// generate buffer objects, and each attribute(vertices, color, and normal..) is corresponding to one buffer
#ifdef QT_BUFFER
qtgl.glGenBuffers(NumVBOs, buffers);
#else
glGenBuffers(NumVBOs, buffers);
#endif
//---------------------------------------buffer for vertices----------------------------------//
// active a buffer object
#ifdef QT_BUFFER
qtgl.glBindBuffer(GL_ARRAY_BUFFER, buffers[Vertices]);
#else
glBindBuffer(GL_ARRAY_BUFFER, buffers[Vertices]);
#endif
// alloc a space for buffer
#ifdef QT_BUFFER
qtgl.glBufferData(GL_ARRAY_BUFFER, Verts.size()*sizeof(GLfloat), Verts.data(), GL_STATIC_DRAW);
#else
glBufferData(GL_ARRAY_BUFFER, sizeof(Verts), Verts, GL_STATIC_DRAW);
#endif
// put the data into the corresponding buffer
glVertexPointer(3, GL_FLOAT, 0,BUFFER_OFFSET(0));
glEnableClientState(GL_VERTEX_ARRAY);
//---------------------------------------buffer for colors----------------------------------//
// buffer for colors
#ifdef QT_BUFFER
qtgl.glBindBuffer(GL_ARRAY_BUFFER, buffers[Color]);
#else
glBindBuffer(GL_ARRAY_BUFFER, buffers[Color]);
#endif
#ifdef QT_BUFFER
qtgl.glBufferData(GL_ARRAY_BUFFER, Colors.size()*sizeof(GLfloat), Colors.data(), GL_STATIC_DRAW);
#else
glBufferData(GL_ARRAY_BUFFER, sizeof(Colors), Colors, GL_STATIC_DRAW);
#endif
glColorPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));
glEnableClientState(GL_COLOR_ARRAY);
//---------------------------------------buffer for elements----------------------------------//
// buffer for elements
#ifdef QT_BUFFER
numElement = Indices.size();
#else
numElement = sizeof(Indices)/sizeof(Indices[0]);
#endif
#ifdef QT_BUFFER
qtgl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[Elements]);
#else
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[Elements]);
#endif
#ifdef QT_BUFFER
qtgl.glBufferData(GL_ELEMENT_ARRAY_BUFFER, Indices.size()*sizeof(uint), Indices.data(), GL_STATIC_DRAW);
#else
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(Indices), Indices, GL_STATIC_DRAW);
#endif
#endif
}
void VoxelTerrain::UpdateTerrain(){
glBindBuffer(GL_ARRAY_BUFFER,0);
RecreateOctree();
glDisable(GL_ALPHA_TEST);
if (order!=0){
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
}else{
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
}
switch(brush.blend){
case 0:
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); // alpha
break;
case 1:
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); // alpha
break;
case 2:
glBlendFunc(GL_DST_COLOR,GL_ZERO); // multiply
break;
case 3:
glBlendFunc(GL_SRC_ALPHA,GL_ONE); // additive and alpha
break;
}
float ambient_red,ambient_green,ambient_blue;
// fx flag 1 - full bright ***todo*** disable all lights?
if (brush.fx & 1){
if(Global::fx1!=true){
Global::fx1=true;
glDisableClientState(GL_NORMAL_ARRAY);
}
ambient_red =1.0;
ambient_green=1.0;
ambient_blue =1.0;
}else{
if(Global::fx1!=false){
Global::fx1=false;
glEnableClientState(GL_NORMAL_ARRAY);
}
ambient_red =Global::ambient_red;
ambient_green=Global::ambient_green;
ambient_blue =Global::ambient_blue;
}
// fx flag 2 - vertex colours
/*if(brush.fx&2){
glEnable(GL_COLOR_MATERIAL);
}else{
glDisable(GL_COLOR_MATERIAL);
}*/
if(Global::fx2!=false){
Global::fx2=false;
glDisableClientState(GL_COLOR_ARRAY);
glDisable(GL_COLOR_MATERIAL);
}
// fx flag 4 - flatshaded
if(brush.fx&4){
glShadeModel(GL_FLAT);
}else{
glShadeModel(GL_SMOOTH);
}
// fx flag 8 - disable fog
if(brush.fx&8){
if(Global::fog_enabled==true){ // only disable if fog enabled in camera update
glDisable(GL_FOG);
}
}
// fx flag 16 - disable backface culling
if(brush.fx&16){
glDisable(GL_CULL_FACE);
}else{
glEnable(GL_CULL_FACE);
}
// light + material color
float ambient[]={ambient_red,ambient_green,ambient_blue};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,ambient);
float mat_ambient[]={brush.red,brush.green,brush.blue,brush.alpha};
float mat_diffuse[]={brush.red,brush.green,brush.blue,brush.alpha};
float mat_specular[]={brush.shine,brush.shine,brush.shine,brush.shine};
float mat_shininess[]={100.0}; // upto 128
glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,mat_ambient);
glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,mat_diffuse);
glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular);
glMaterialfv(GL_FRONT_AND_BACK,GL_SHININESS,mat_shininess);
// textures
int tex_count=0;
if(ShaderMat!=NULL){
ShaderMat->TurnOn(mat, 0, &vertices);
}
tex_count=brush.no_texs;
int DisableCubeSphereMapping=0;
for(int ix=0;ix<tex_count;ix++){
if(brush.tex[ix]){
// Main brush texture takes precedent over surface brush texture
unsigned int texture=0;
int tex_flags=0,tex_blend=0;
float tex_u_scale=1.0,tex_v_scale=1.0,tex_u_pos=0.0,tex_v_pos=0.0,tex_ang=0.0;
int tex_cube_mode=0;
texture=brush.cache_frame[ix];
tex_flags=brush.tex[ix]->flags;
tex_blend=brush.tex[ix]->blend;
//tex_coords=brush.tex[ix]->coords;
tex_u_scale=brush.tex[ix]->u_scale;
tex_v_scale=brush.tex[ix]->v_scale;
tex_u_pos=brush.tex[ix]->u_pos;
tex_v_pos=brush.tex[ix]->v_pos;
tex_ang=brush.tex[ix]->angle;
tex_cube_mode=brush.tex[ix]->cube_mode;
//frame=brush.tex_frame;
glActiveTexture(GL_TEXTURE0+ix);
glClientActiveTexture(GL_TEXTURE0+ix);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texture); // call before glTexParameteri
// masked texture flag
if(tex_flags&4){
glEnable(GL_ALPHA_TEST);
}else{
glDisable(GL_ALPHA_TEST);
}
// mipmapping texture flag
if(tex_flags&8){
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
}else{
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
}
// clamp u flag
if(tex_flags&16){
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
}else{
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
}
// clamp v flag
if(tex_flags&32){
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
}else{
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
}
// ***!ES***
// spherical environment map texture flag
if(tex_flags&64){
glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP);
glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
DisableCubeSphereMapping=1;
}/*else{
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
}*/
// cubic environment map texture flag
if(tex_flags&128){
glEnable(GL_TEXTURE_CUBE_MAP);
glBindTexture(GL_TEXTURE_CUBE_MAP,texture); // call before glTexParameteri
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
//glEnable(GL_TEXTURE_GEN_Q)
if(tex_cube_mode==1){
glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_REFLECTION_MAP);
glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_REFLECTION_MAP);
glTexGeni(GL_R,GL_TEXTURE_GEN_MODE,GL_REFLECTION_MAP);
}
if(tex_cube_mode==2){
glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_NORMAL_MAP);
glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_NORMAL_MAP);
glTexGeni(GL_R,GL_TEXTURE_GEN_MODE,GL_NORMAL_MAP);
}
DisableCubeSphereMapping=1;
}else if (DisableCubeSphereMapping!=0){
glDisable(GL_TEXTURE_CUBE_MAP);
// only disable tex gen s and t if sphere mapping isn't using them
if((tex_flags & 64)==0){
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
}
glDisable(GL_TEXTURE_GEN_R);
//glDisable(GL_TEXTURE_GEN_Q)
}
switch(tex_blend){
case 0: glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
break;
case 1: glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);
break;
case 2: glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
//case 2 glTexEnvf(GL_TEXTURE_ENV,GL_COMBINE_RGB_EXT,GL_MODULATE);
break;
case 3: glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_ADD);
break;
case 4:
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_DOT3_RGB_EXT);
break;
case 5:
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB,GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV,GL_RGB_SCALE,2.0);
break;
default: glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
}
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2,GL_FLOAT,32,&vertices[6]);
// reset texture matrix
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
if(tex_u_pos!=0.0 || tex_v_pos!=0.0){
glTranslatef(tex_u_pos,tex_v_pos,0.0);
}
if(tex_ang!=0.0){
glRotatef(tex_ang,0.0,0.0,1.0);
}
if(tex_u_scale!=1.0 || tex_v_scale!=1.0){
glScalef(tex_u_scale,tex_v_scale,1.0);
}
// ***!ES***
// if spheremap flag=true then flip tex
if(tex_flags&64){
glScalef(1.0,-1.0,-1.0);
}
// if cubemap flag=true then manipulate texture matrix so that cubemap is displayed properly
if(tex_flags&128){
glScalef(1.0,-1.0,-1.0);
// get current modelview matrix (set in last camera update)
float mod_mat[16];
glGetFloatv(GL_MODELVIEW_MATRIX,&mod_mat[0]);
// get rotational inverse of current modelview matrix
Matrix new_mat;
new_mat.LoadIdentity();
new_mat.grid[0][0] = mod_mat[0];
new_mat.grid[1][0] = mod_mat[1];
new_mat.grid[2][0] = mod_mat[2];
new_mat.grid[0][1] = mod_mat[4];
new_mat.grid[1][1] = mod_mat[5];
new_mat.grid[2][1] = mod_mat[6];
new_mat.grid[0][2] = mod_mat[8];
new_mat.grid[1][2] = mod_mat[9];
new_mat.grid[2][2] = mod_mat[10];
glMultMatrixf(&new_mat.grid[0][0]);
}
}
}
// draw tris
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glMultMatrixf(&mat.grid[0][0]);
glVertexPointer(3,GL_FLOAT,32,&vertices[0]);
glNormalPointer(GL_FLOAT,32,&vertices[3]);
glDrawArrays(GL_TRIANGLES, 0, triangleindex*3);
glPopMatrix();
// disable all texture layers
for(int ix=0;ix<tex_count;ix++){
glActiveTexture(GL_TEXTURE0+ix);
glClientActiveTexture(GL_TEXTURE0+ix);
// reset texture matrix
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glDisable(GL_TEXTURE_2D);
// ***!ES***
if (DisableCubeSphereMapping!=0){
glDisable(GL_TEXTURE_CUBE_MAP);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
DisableCubeSphereMapping=0;
}
}
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
if (brush.fx&8 && Global::fog_enabled==true){
glEnable(GL_FOG);
}
if(ShaderMat!=NULL){
ShaderMat->TurnOff();
}
}
void level::_renderRayTexture(void)
{
int maxX = _size.getX()*_tileSize, maxY = _size.getY()*_tileSize;
glEnable(GL_TEXTURE_2D);
switch(_colorModel)
{
case 3:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, maxX, maxY, 0, GL_RGBA, GL_FLOAT, &_rayTexture[0]);
glBindTexture(GL_TEXTURE_2D, _interpolatedTexture);
break;
case 4:
default:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, maxX, maxY, 0, GL_RGBA, GL_FLOAT, &_pointTexture[0]);
glBindTexture(GL_TEXTURE_2D, _outlineTexture);
break;
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glClear(GL_DEPTH_BUFFER_BIT);
float2D textureArray[6];
int2D corners[6];
float3D colors[6];
corners[0] = int2D(0, 0);
textureArray[0] = float2D(0, 0);
corners[1] = int2D(0, maxY);
textureArray[1] = float2D(0, 1.f);
corners[2] = int2D(maxX, maxY);
textureArray[2] = float2D(1.f, 1.f);
corners[3] = int2D(maxX, maxY);
textureArray[3] = float2D(1.f, 1.f);
corners[4] = int2D(maxX, 0);
textureArray[4] = float2D(1.f, 0);
corners[5] = int2D(0, 0);
textureArray[5] = float2D(0, 0);
for(int i = 0; i < 6; i++) colors[i] = float3D(1.f, 1.f, 1.f);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glColorPointer(3, GL_FLOAT, 0, &colors[0]);
glVertexPointer(2, GL_INT, 0, &corners[0]);
glTexCoordPointer(2, GL_FLOAT, 0, &textureArray[0]);
glDrawArrays(GL_TRIANGLES, 0, 6);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClear(GL_DEPTH_BUFFER_BIT);
glDisable(GL_TEXTURE_2D);
}
void mesh3DS::draw(){
assert(getNumFaces()!=0);
int face, numFaces, vertexIndex, texcoordIndex;
GLuint materialFaces; //GL_FRONT or GL_FRONT_AND_BACK
std::map<std::string, std::vector<ushort> >::iterator materialsIter;
for(materialsIter=m_materialFaces.begin(); materialsIter!=m_materialFaces.end(); ++materialsIter){
const material3DS& currentMaterial = m_parentModel->getMaterial(materialsIter->first);
// Bind texture map (if any)
bool hasTextureMap = currentMaterial.hasTextureMap();
if(hasTextureMap) glBindTexture(GL_TEXTURE_2D, currentMaterial.getTextureMapId());
//else glBindTexture(GL_TEXTURE_2D, 0);
const GLfloat *specular = currentMaterial.getSpecularColor();
float shininess = currentMaterial.getShininess();
float adjustedSpecular[4] = {specular[0]*shininess, specular[1]*shininess, specular[2]*shininess, 1};
glPushAttrib(GL_LIGHTING_BIT);
if(currentMaterial.isTwoSided()){
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,1);
materialFaces = GL_FRONT_AND_BACK;
}
else{
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,0);
materialFaces = GL_FRONT;
}
// Apply material colors
if(glIsEnabled(GL_LIGHTING)){
//const GLfloat matZero[4]={0,0,0,0};
const GLfloat matOne[4]={1,1,1,1};
if(hasTextureMap){ //replace color with texture, but keep lighting contribution
glMaterialfv(materialFaces, GL_DIFFUSE, matOne);
}
else glMaterialfv(materialFaces, GL_DIFFUSE, currentMaterial.getDiffuseColor());
glMaterialfv(materialFaces, GL_AMBIENT, currentMaterial.getAmbientColor());
glMaterialfv(materialFaces, GL_SPECULAR, adjustedSpecular);
glMaterialf(materialFaces, GL_SHININESS, 128.f * currentMaterial.getSpecularExponent());
}
else glColor3fv(currentMaterial.getDiffuseColor());
const std::vector<ushort> *currentMatFaces = &(materialsIter->second);
numFaces = (int)currentMatFaces->size(); //number of faces in this material
switch(m_drawMode){
case DRAW_IMMEDIATE_MODE:
glBegin(GL_TRIANGLES);
for(face=0; face<numFaces; face+=3){
if(hasTextureMap){
texcoordIndex = (*currentMatFaces)[face]*2;
glTexCoord2f(m_texcoords[texcoordIndex], m_texcoords[texcoordIndex+1]);
}
vertexIndex = (*currentMatFaces)[face]*3;
glNormal3f(m_normals[vertexIndex], m_normals[vertexIndex+1], m_normals[vertexIndex+2]);
glVertex3f(m_vertices[vertexIndex], m_vertices[vertexIndex+1], m_vertices[vertexIndex+2]);
if(hasTextureMap){
texcoordIndex = (*currentMatFaces)[face+1]*2;
glTexCoord2f(m_texcoords[texcoordIndex], m_texcoords[texcoordIndex+1]);
}
vertexIndex = (*currentMatFaces)[face+1]*3;
glNormal3f(m_normals[vertexIndex], m_normals[vertexIndex+1], m_normals[vertexIndex+2]);
glVertex3f(m_vertices[vertexIndex], m_vertices[vertexIndex+1], m_vertices[vertexIndex+2]);
if(hasTextureMap){
texcoordIndex = (*currentMatFaces)[face+2]*2;
glTexCoord2f(m_texcoords[texcoordIndex], m_texcoords[texcoordIndex+1]);
}
vertexIndex = (*currentMatFaces)[face+2]*3;
glNormal3f(m_normals[vertexIndex], m_normals[vertexIndex+1], m_normals[vertexIndex+2]);
glVertex3f(m_vertices[vertexIndex], m_vertices[vertexIndex+1], m_vertices[vertexIndex+2]);
}
glEnd();
break;
case DRAW_VERTEX_ARRAY:
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_NORMAL_ARRAY );
if(hasTextureMap){
glTexCoordPointer( 2, GL_FLOAT, 0, &m_texcoords[0] );
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
}
glVertexPointer( 3, GL_FLOAT, 0, &m_vertices[0] );
glNormalPointer(GL_FLOAT, 0, &m_normals[0] );
glDrawElements(GL_TRIANGLES, numFaces, GL_UNSIGNED_SHORT, &(materialsIter->second[0]));
glDisableClientState( GL_VERTEX_ARRAY );
glDisableClientState( GL_NORMAL_ARRAY );
if(hasTextureMap){
glDisableClientState( GL_TEXTURE_COORD_ARRAY );
}
break;
case DRAW_VBO:
break;
default:
std::cout<<"[3DS] ERROR: Invalid mesh draw mode specified"<<std::endl;
break;
}
glPopAttrib(); // GL_LIGHTING_BIT
}
}
//====================
// モデルデータの描画
//====================
void cPMDModel::render( void )
{
if( !m_pvec3OrgPositionArray ) return;
#if (1)
unsigned short *pIndices = m_pIndices;
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_NORMAL_ARRAY );
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
// 頂点座標、法線、テクスチャ座標の各配列をセット
glVertexPointer( 3, GL_FLOAT, 0, m_pvec3PositionArray );
glNormalPointer( GL_FLOAT, 0, m_pvec3NormalArray );
glTexCoordPointer( 2, GL_FLOAT, 0, m_puvOrgTexureUVArray );
for( unsigned long i = 0 ; i < m_ulNumMaterials ; i++ )
{
// マテリアル設定
glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, (float *)&(m_pMaterials[i].col4Diffuse) );
glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, (float *)&(m_pMaterials[i].col4Ambient) );
glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, (float *)&(m_pMaterials[i].col4Specular) );
glMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, m_pMaterials[i].fShininess );
if( m_pMaterials[i].col4Diffuse.a < 1.0f ) glDisable( GL_CULL_FACE );
else glEnable( GL_CULL_FACE );
if( m_pMaterials[i].uiTexID != 0xFFFFFFFF )
{
// テクスチャありならBindする
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, m_pMaterials[i].uiTexID );
}
else
{
// テクスチャなし
glDisable( GL_TEXTURE_2D );
}
// 頂点インデックスを指定してポリゴン描画
glDrawElements( GL_TRIANGLES, m_pMaterials[i].ulNumIndices, GL_UNSIGNED_SHORT, pIndices );
pIndices += m_pMaterials[i].ulNumIndices;
}
glDisableClientState( GL_VERTEX_ARRAY );
glDisableClientState( GL_NORMAL_ARRAY );
glDisableClientState( GL_TEXTURE_COORD_ARRAY );
#endif
#if _DBG_BONE_DRAW
glDisable( GL_DEPTH_TEST );
glDisable( GL_LIGHTING );
for( unsigned short i = 0 ; i < m_unNumBones ; i++ )
{
m_pBoneArray[i].debugDraw();
}
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
#endif
#if _DBG_IK_DRAW
glDisable( GL_DEPTH_TEST );
glDisable( GL_LIGHTING );
for( unsigned short i = 0 ; i < m_unNumIK ; i++ )
{
m_pIKArray[i].debugDraw();
}
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
#endif
#if _DBG_TEXTURE_DRAW
g_clsTextureList.debugDraw();
#endif
}
void GL_DrawAliasShadow (aliashdr_t *paliashdr, int posenum)
{
float s, t, l;
int i, j;
int index;
trivertx_t *v, *verts;
int list;
int *order;
vec3_t point;
float *normal;
float height, lheight;
int count;
lheight = currententity->origin[2] - lightspot[2];
height = 0;
verts = (trivertx_t *)((byte *)paliashdr + paliashdr->posedata);
verts += posenum * paliashdr->poseverts;
order = (int *)((byte *)paliashdr + paliashdr->commands);
height = -lheight + 1.0;
while (1)
{
// get the vertex count and primitive type
count = *order++;
if (!count)
break; // done
#ifdef USE_OPENGLES
{
int primType;
int c;
float* pVertex;
if (count < 0)
{
count = -count;
primType = GL_TRIANGLE_FAN;
}
else
primType = GL_TRIANGLE_STRIP;
pVertex = gVertexBuffer;
for(c = 0; c < count; c++)
{
// texture coordinates come from the draw list
// (skipped for shadows) glTexCoord2fv ((float *)order);
order += 2;
// normals and vertexes come from the frame list
pVertex[0] = verts->v[0] * paliashdr->scale[0] + paliashdr->scale_origin[0];
pVertex[1] = verts->v[1] * paliashdr->scale[1] + paliashdr->scale_origin[1];
pVertex[2] = verts->v[2] * paliashdr->scale[2] + paliashdr->scale_origin[2];
pVertex[0] -= shadevector[0]*(pVertex[2]+lheight);
pVertex[1] -= shadevector[1]*(pVertex[2]+lheight);
pVertex[2] = height;
// height -= 0.001;
pVertex += 3;
verts++;
}
glVertexPointer(3, GL_FLOAT, 0, gVertexBuffer);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDrawArrays(primType, 0, count);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
#else
if (count < 0)
{
count = -count;
glBegin (GL_TRIANGLE_FAN);
}
else
glBegin (GL_TRIANGLE_STRIP);
do
{
// texture coordinates come from the draw list
// (skipped for shadows) glTexCoord2fv ((float *)order);
order += 2;
// normals and vertexes come from the frame list
point[0] = verts->v[0] * paliashdr->scale[0] + paliashdr->scale_origin[0];
point[1] = verts->v[1] * paliashdr->scale[1] + paliashdr->scale_origin[1];
point[2] = verts->v[2] * paliashdr->scale[2] + paliashdr->scale_origin[2];
point[0] -= shadevector[0]*(point[2]+lheight);
point[1] -= shadevector[1]*(point[2]+lheight);
point[2] = height;
// height -= 0.001;
glVertex3fv (point);
verts++;
} while (--count);
glEnd ();
#endif
}
}
void COctree::CreateDisplayList(COctree *pNode, t3DModel *pRootWorld, int displayListOffset)
{
// This function handles our rendering code in the beginning and assigns it all
// to a display list. This increases our rendering speed, as long as we don't flood
// the pipeline with a TON of data. Display lists can actually be to bloated or too small.
// Like our DrawOctree() function, we need to find the end nodes by recursing down to them.
// We only create a display list for the end nodes and ignore the rest. The
// displayListOffset is used to add to the end nodes current display list ID, in case
// we created some display lists before creating the octree. Usually it is just 1 otherwise.
// Make sure a valid node was passed in, otherwise go back to the last node
if(!pNode) return;
// Check if this node is subdivided. If so, then we need to recurse down to it's nodes
if(pNode->IsSubDivided())
{
// Recurse down to each one of the children until we reach the end nodes
CreateDisplayList(pNode->m_pOctreeNodes[TOP_LEFT_FRONT], pRootWorld, displayListOffset);
CreateDisplayList(pNode->m_pOctreeNodes[TOP_LEFT_BACK], pRootWorld, displayListOffset);
CreateDisplayList(pNode->m_pOctreeNodes[TOP_RIGHT_BACK], pRootWorld, displayListOffset);
CreateDisplayList(pNode->m_pOctreeNodes[TOP_RIGHT_FRONT], pRootWorld, displayListOffset);
CreateDisplayList(pNode->m_pOctreeNodes[BOTTOM_LEFT_FRONT], pRootWorld, displayListOffset);
CreateDisplayList(pNode->m_pOctreeNodes[BOTTOM_LEFT_BACK], pRootWorld, displayListOffset);
CreateDisplayList(pNode->m_pOctreeNodes[BOTTOM_RIGHT_BACK], pRootWorld, displayListOffset);
CreateDisplayList(pNode->m_pOctreeNodes[BOTTOM_RIGHT_FRONT],pRootWorld, displayListOffset);
}
else
{
// Make sure we have valid data assigned to this node
if(!pNode->m_pWorld) return;
// Add our display list offset to our current display list ID
pNode->m_DisplayListID += displayListOffset;
// Start the display list and assign it to the end nodes ID
glNewList(pNode->m_DisplayListID,GL_COMPILE);
// Create a temp counter for our while loop below to store the objects drawn
int counter = 0;
// Store the object count and material count in some local variables for optimization
int objectCount = pNode->m_pObjectList.size();
int materialCount = pRootWorld->pMaterials.size();
// Go through all of the objects that are in our end node
while(counter < objectCount)
{
// Get the first object index into our root world
int i = pNode->m_pObjectList[counter];
// Store pointers to the current face list and the root object
// that holds all the data (verts, texture coordinates, normals, etc..)
t3DObject *pObject = &pNode->m_pWorld->pObject[i];
t3DObject *pRootObject = &pRootWorld->pObject[i];
// Check to see if this object has a texture map, if so, bind the texture to it.
if(pRootObject->bHasTexture)
{
// Turn on texture mapping and turn off color
glEnable(GL_TEXTURE_2D);
// Reset the color to normal again
glColor3ub(255, 255, 255);
// Bind the texture map to the object by it's materialID
glBindTexture(GL_TEXTURE_2D, g_Texture[pRootObject->materialID]);
}
else
{
// Turn off texture mapping and turn on color
glDisable(GL_TEXTURE_2D);
// Reset the color to normal again
glColor3ub(255, 255, 255);
}
// Check to see if there is a valid material assigned to this object
if(materialCount && pRootObject->materialID >= 0)
{
// Get and set the color that the object is, since it must not have a texture
BYTE *pColor = pRootWorld->pMaterials[pRootObject->materialID].color;
// Assign the current color to this model
glColor3ub(pColor[0], pColor[1], pColor[2]);
}
// Now we get to the more unknown stuff, vertex arrays. If you haven't
// dealt with vertex arrays yet, let me give you a brief run down on them.
// Instead of doing loops to go through and pass in each of the vertices
// of a model, we can just pass in the array vertices, then an array of
// indices that MUST be an unsigned int, which gives the indices into
// the vertex array. That means that we can send the vertices to the video
// card with one call to glDrawElements(). There are a bunch of other
// functions for vertex arrays that do different things, but I am just going
// to mention this one. Since texture coordinates, normals and colors are also
// associated with vertices, we are able to point OpenGL to these arrays before
// we draw the geometry. It uses the same indices that we pass to glDrawElements()
// for each of these arrays. Below, we point OpenGL to our texture coordinates,
// vertex and normal arrays. This is done with calls to glTexCoordPointer(),
// glVertexPointer() and glNormalPointer().
//
// Before using any of these functions, we need to enable their states. This is
// done with glEnableClientState(). You just pass in the ID of the type of array
// you are wanting OpenGL to look for. If you don't have data in those arrays,
// the program will most likely crash.
//
// If you don't want to use vertex arrays, you can just render the world like normal.
// That is why I saved the pFace information, as well as the pIndices info. This
// way you can use what ever method you are comfortable with. I tried both, and
// by FAR the vertex arrays are incredibly faster. You decide :)
// Make sure we have texture coordinates to render
if(pRootObject->pTexVerts)
{
// Turn on the texture coordinate state
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
// Point OpenGL to our texture coordinate array.
// We have them in a pair of 2, of type float and 0 bytes of stride between them.
glTexCoordPointer(2, GL_FLOAT, 0, pRootObject->pTexVerts);
}
// Make sure we have vertices to render
if(pRootObject->pVerts)
{
// Turn on the vertex array state
glEnableClientState(GL_VERTEX_ARRAY);
// Point OpenGL to our vertex array. We have our vertices stored in
// 3 floats, with 0 stride between them in bytes.
glVertexPointer(3, GL_FLOAT, 0, pRootObject->pVerts);
}
// Make sure we have normals to render
if(pRootObject->pNormals)
{
// Turn on the normals state
glEnableClientState(GL_NORMAL_ARRAY);
// Point OpenGL to our normals array. We have our normals
// stored as floats, with a stride of 0 between.
glNormalPointer(GL_FLOAT, 0, pRootObject->pNormals);
}
// Here we pass in the indices that need to be rendered. We want to
// render them in triangles, with numOfFaces * 3 for indice count,
// and the indices are of type UINT (important).
glDrawElements(GL_TRIANGLES, pObject->numOfFaces * 3,
GL_UNSIGNED_INT, pObject->pIndices);
// Increase the current object count rendered
counter++;
}
// End the display list for this ID
glEndList();
}
}
/*
=============
GL_DrawAliasFrame
=============
*/
void GL_DrawAliasFrame (aliashdr_t *paliashdr, int posenum)
{
float s, t;
float l;
int i, j;
int index;
trivertx_t *v, *verts;
int list;
int *order;
vec3_t point;
float *normal;
int count;
#ifdef USE_OPENGLES
glEnableClientState(GL_COLOR_ARRAY);
#endif
lastposenum = posenum;
verts = (trivertx_t *)((byte *)paliashdr + paliashdr->posedata);
verts += posenum * paliashdr->poseverts;
order = (int *)((byte *)paliashdr + paliashdr->commands);
while (1)
{
// get the vertex count and primitive type
count = *order++;
if (!count)
break; // done
#ifdef USE_OPENGLES
{
int primType;
int c;
float* pColor;
float* pTexCoord;
float* pPos;
if (count < 0)
{
count = -count;
primType = GL_TRIANGLE_FAN;
}
else
primType = GL_TRIANGLE_STRIP;
// texture coordinates come from the draw list
glTexCoordPointer(2, GL_FLOAT, 0, gTexCoordBuffer);
glVertexPointer(3, GL_FLOAT, 0, gVertexBuffer);
glColorPointer(4, GL_FLOAT, 0, gColorBuffer);
pColor = gColorBuffer;
pPos = gVertexBuffer;
pTexCoord = gTexCoordBuffer;
c = count;
do
{
// texture coordinates come from the draw list
*pTexCoord++ = ((float *)order)[0];
*pTexCoord++ = ((float *)order)[1];
order += 2;
// normals and vertexes come from the frame list
l = shadedots[verts->lightnormalindex] * shadelight;
*pColor++ = l;
*pColor++ = l;
*pColor++ = l;
*pColor++ = 1.0f;
*pPos++ = verts->v[0];
*pPos++ = verts->v[1];
*pPos++ = verts->v[2];
verts++;
} while (--c);
glDrawArrays(primType, 0, count);
}
#else
if (count < 0)
{
count = -count;
glBegin (GL_TRIANGLE_FAN);
}
else
glBegin (GL_TRIANGLE_STRIP);
do
{
// texture coordinates come from the draw list
glTexCoord2f (((float *)order)[0], ((float *)order)[1]);
order += 2;
// normals and vertexes come from the frame list
l = shadedots[verts->lightnormalindex] * shadelight;
glColor3f (l, l, l);
glVertex3f (verts->v[0], verts->v[1], verts->v[2]);
verts++;
} while (--count);
glEnd ();
#endif
}
#ifdef USE_OPENGLES
glDisableClientState(GL_COLOR_ARRAY);
#endif
}
/*
=================
R_DrawSpriteModel
=================
*/
void R_DrawSpriteModel (entity_t *e)
{
vec3_t point;
mspriteframe_t *frame;
float *up, *right;
vec3_t v_forward, v_right, v_up;
msprite_t *psprite;
// don't even bother culling, because it's just a single
// polygon without a surface cache
frame = R_GetSpriteFrame (e);
psprite = (msprite_t*) currententity->model->cache.data;
if (psprite->type == SPR_ORIENTED)
{ // bullet marks on walls
AngleVectors (currententity->angles, v_forward, v_right, v_up);
up = v_up;
right = v_right;
}
else
{ // normal sprite
up = vup;
right = vright;
}
glColor3f (1,1,1);
GL_DisableMultitexture();
GL_Bind(frame->gl_texturenum);
glEnable (GL_ALPHA_TEST);
#ifdef USE_OPENGLES
{
float* pPoint = gVertexBuffer;
float texCoords[] = {
0, 1,
0, 0,
1, 0,
1, 1
};
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->left, right, pPoint);
pPoint += 3;
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->left, right, pPoint);
pPoint += 3;
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->right, right, pPoint);
pPoint += 3;
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->right, right, pPoint);
glVertexPointer(3, GL_FLOAT, 0, gVertexBuffer);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
#else
glBegin (GL_QUADS);
glTexCoord2f (0, 1);
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->left, right, point);
glVertex3fv (point);
glTexCoord2f (0, 0);
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->left, right, point);
glVertex3fv (point);
glTexCoord2f (1, 0);
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->right, right, point);
glVertex3fv (point);
glTexCoord2f (1, 1);
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->right, right, point);
glVertex3fv (point);
glEnd ();
#endif
glDisable (GL_ALPHA_TEST);
}
void rain_draw(int tick)
{
int n,xadd,yadd,zadd,density,
slant_add,slant_mult,slant_div;
float slant_ang_y;
float *vertex_ptr,*col_ptr;
rain_draw_type *rain_draw;
// is rain on and not under liquid?
if (!map.rain.on) return;
if (view.render->camera.under_liquid_idx!=-1) return;
// reset on?
if (map.rain.reset) {
map.rain.reset=FALSE;
rain_setup(tick,view.render->camera.pnt.x,view.render->camera.pnt.y,view.render->camera.pnt.z);
}
// rain slant
slant_add=rain_slant_add;
slant_ang_y=rain_slant_ang_y;
if (map.rain.slant_time_msec!=0) {
// time to change slant?
if (tick>rain_slant_next_end_tick) {
rain_slant_add=slant_add=rain_slant_next_add;
rain_slant_ang_y=slant_ang_y=rain_slant_next_ang_y;
rain_setup_next_slant(tick);
}
else {
// slant in the middle of changing
if (tick>rain_slant_next_start_tick) {
slant_mult=tick-rain_slant_next_start_tick;
slant_div=(rain_slant_next_end_tick-rain_slant_next_start_tick);
slant_add=rain_slant_add+(((rain_slant_next_add-rain_slant_add)*slant_mult)/slant_div);
slant_ang_y=rain_slant_ang_y+((rain_slant_next_ang_y-rain_slant_ang_y)*((float)slant_mult/(float)slant_div));
}
}
}
angle_get_movement(slant_ang_y,slant_add,&xadd,&zadd);
// rain change
xadd=(tick-rain_last_tick)*xadd;
yadd=(tick-rain_last_tick)*map.rain.speed;
zadd=(tick-rain_last_tick)*zadd;
rain_last_tick=tick;
// rain density
density=map.rain.density;
if (density>max_rain_density) density=max_rain_density;
// construct VBO
vertex_ptr=view_bind_map_next_vertex_object(((density*2)*(3+4)));
if (vertex_ptr==NULL) return;
col_ptr=vertex_ptr+((density*2)*3);
// create vertexes
rain_draw=view.rain_draws;
for (n=0;n!=density;n++) {
// move rain
rain_draw->x+=xadd;
rain_draw->y+=yadd;
rain_draw->z+=zadd;
if (rain_draw->y>rain_draw->by) rain_setup_single_reset(rain_draw,view.render->camera.pnt.x,view.render->camera.pnt.y,view.render->camera.pnt.z);
// draw rain
*vertex_ptr++=(float)rain_draw->x;
*vertex_ptr++=(float)rain_draw->y;
*vertex_ptr++=(float)rain_draw->z;
*col_ptr++=map.rain.start_color.r;
*col_ptr++=map.rain.start_color.g;
*col_ptr++=map.rain.start_color.b;
*col_ptr++=map.rain.alpha;
*vertex_ptr++=(float)(rain_draw->x+xadd);
*vertex_ptr++=(float)(rain_draw->y+map.rain.line_length);
*vertex_ptr++=(float)(rain_draw->z+zadd);
*col_ptr++=map.rain.end_color.r;
*col_ptr++=map.rain.end_color.g;
*col_ptr++=map.rain.end_color.b;
*col_ptr++=map.rain.alpha;
rain_draw++;
}
view_unmap_current_vertex_object();
// setup view
gl_3D_view();
gl_3D_rotate(&view.render->camera.pnt,&view.render->camera.ang);
gl_setup_project();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_ALPHA_TEST);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glDepthMask(GL_FALSE);
// draw the rain
glLineWidth((float)map.rain.line_width);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3,GL_FLOAT,0,(void*)0);
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4,GL_FLOAT,0,(void*)(((density*2)*3)*sizeof(float)));
glDrawArrays(GL_LINES,0,(density*2));
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glLineWidth(1);
// unbind the vbo
view_unbind_current_vertex_object();
}
void LayerBase::drawWithOpenGL(const Region& clip) const
{
const DisplayHardware& hw(graphicPlane(0).displayHardware());
const uint32_t fbHeight = hw.getHeight();
const State& s(drawingState());
GLenum src = mPremultipliedAlpha ? GL_ONE : GL_SRC_ALPHA;
if (CC_UNLIKELY(s.alpha < 0xFF)) {
const GLfloat alpha = s.alpha * (1.0f/255.0f);
if (mPremultipliedAlpha) {
glColor4f(alpha, alpha, alpha, alpha);
} else {
glColor4f(1, 1, 1, alpha);
}
glEnable(GL_BLEND);
glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
} else {
glColor4f(1, 1, 1, 1);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
if (!isOpaque()) {
glEnable(GL_BLEND);
glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
} else {
glDisable(GL_BLEND);
}
}
struct TexCoords {
GLfloat u;
GLfloat v;
};
Rect crop(s.active.w, s.active.h);
if (!s.active.crop.isEmpty()) {
crop = s.active.crop;
}
GLfloat left = GLfloat(crop.left) / GLfloat(s.active.w);
GLfloat top = GLfloat(crop.top) / GLfloat(s.active.h);
GLfloat right = GLfloat(crop.right) / GLfloat(s.active.w);
GLfloat bottom = GLfloat(crop.bottom) / GLfloat(s.active.h);
TexCoords texCoords[4];
texCoords[0].u = left;
texCoords[0].v = top;
texCoords[1].u = left;
texCoords[1].v = bottom;
texCoords[2].u = right;
texCoords[2].v = bottom;
texCoords[3].u = right;
texCoords[3].v = top;
for (int i = 0; i < 4; i++) {
texCoords[i].v = 1.0f - texCoords[i].v;
}
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, mVertices);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glDrawArrays(GL_TRIANGLE_FAN, 0, mNumVertices);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_BLEND);
}
void Model::renderMesh(bool bWireframe, bool bLight)
{
// get the renderer of the model
CalRenderer *pCalRenderer;
pCalRenderer = m_calModel->getRenderer();
// begin the rendering loop
if(!pCalRenderer->beginRendering()) return;
// set wireframe mode if necessary
// set the global OpenGL states
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
// set the lighting mode if necessary
if(bLight)
{
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
}
// we will use vertex arrays, so enable them
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
// get the number of meshes
int meshCount;
meshCount = pCalRenderer->getMeshCount();
// render all meshes of the model
int meshId;
for(meshId = 0; meshId < meshCount; meshId++)
{
// get the number of submeshes
int submeshCount;
submeshCount = pCalRenderer->getSubmeshCount(meshId);
// render all submeshes of the mesh
int submeshId;
for(submeshId = 0; submeshId < submeshCount; submeshId++)
{
// select mesh and submesh for further data access
if(pCalRenderer->selectMeshSubmesh(meshId, submeshId))
{
unsigned char meshColor[4];
GLfloat materialColor[4];
// set the material ambient color
pCalRenderer->getAmbientColor(&meshColor[0]);
materialColor[0] = CLAMP(meshColor[0] / 255.0f,0,1); materialColor[1] = CLAMP(meshColor[1] / 255.0f,0,1);
materialColor[2] = CLAMP(meshColor[2] / 255.0f,0,1); materialColor[3] = CLAMP(meshColor[3] / 255.0f,0,1);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, materialColor);
// set the material diffuse color
pCalRenderer->getDiffuseColor(&meshColor[0]);
materialColor[0] = CLAMP(meshColor[0] / 255.0f,0,1); materialColor[1] = CLAMP(meshColor[1] / 255.0f,0,1);
materialColor[2] = CLAMP(meshColor[2] / 255.0f,0,1); materialColor[3] = 1;//CLAMP(meshColor[3] / 255.0f,0,1);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, materialColor);
// set the vertex color if we have no lights
if(!bLight)
{
glColor4f(materialColor[0],materialColor[1],materialColor[2],materialColor[3]);
}
// set the material specular color
pCalRenderer->getSpecularColor(&meshColor[0]);
materialColor[0] = meshColor[0] / 255.0f; materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, materialColor);
// set the material shininess factor
float shininess;
shininess = 50.0f; //TODO: pCalRenderer->getShininess();
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &shininess);
// get the transformed vertices of the submesh
static float meshVertices[30000][3];
int vertexCount;
vertexCount = pCalRenderer->getVertices(&meshVertices[0][0]);
// get the transformed normals of the submesh
static float meshNormals[30000][3];
pCalRenderer->getNormals(&meshNormals[0][0]);
// get the texture coordinates of the submesh
static float meshTextureCoordinates[30000][2];
int textureCoordinateCount;
textureCoordinateCount = pCalRenderer->getTextureCoordinates(0, &meshTextureCoordinates[0][0]);
// get the faces of the submesh
static CalIndex meshFaces[50000][3];
int faceCount;
faceCount = pCalRenderer->getFaces(&meshFaces[0][0]);
// set the vertex and normal buffers
glVertexPointer(3, GL_FLOAT, 0, &meshVertices[0][0]);
glNormalPointer(GL_FLOAT, 0, &meshNormals[0][0]);
// set the texture coordinate buffer and state if necessary
if((pCalRenderer->getMapCount() > 0) && (textureCoordinateCount > 0))
{
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_COLOR_MATERIAL);
// set the texture id we stored in the map user data
glBindTexture(GL_TEXTURE_2D, (GLuint)pCalRenderer->getMapUserData(0));
// set the texture coordinate buffer
glTexCoordPointer(2, GL_FLOAT, 0, &meshTextureCoordinates[0][0]);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}
// draw the submesh
if(bWireframe)
glDrawElements(GL_LINES, faceCount * 3, GL_UNSIGNED_SHORT, &meshFaces[0][0]);
else
//if(sizeof(CalIndex)==2)
glDrawElements(GL_TRIANGLES, faceCount * 3, GL_UNSIGNED_SHORT, &meshFaces[0][0]);
//else
// glDrawElements(GL_TRIANGLES, faceCount * 3, GL_UNSIGNED_INT, &meshFaces[0][0]);
// disable the texture coordinate state if necessary
if((pCalRenderer->getMapCount() > 0) && (textureCoordinateCount > 0))
{
glDisable(GL_COLOR_MATERIAL);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_2D);
}
// DEBUG-CODE //////////////////////////////////////////////////////////////////
/*
glBegin(GL_LINES);
glColor3f(1.0f, 1.0f, 1.0f);
int vertexId;
for(vertexId = 0; vertexId < vertexCount; vertexId++)
{
const float scale = 0.3f;
glVertex3f(meshVertices[vertexId][0], meshVertices[vertexId][1], meshVertices[vertexId][2]);
glVertex3f(meshVertices[vertexId][0] + meshNormals[vertexId][0] * scale, meshVertices[vertexId][1] + meshNormals[vertexId][1] * scale, meshVertices[vertexId][2] + meshNormals[vertexId][2] * scale);
}
glEnd();
*/
////////////////////////////////////////////////////////////////////////////////
}
}
}
// clear vertex array state
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
// reset the lighting mode
if(bLight)
{
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
}
// reset the global OpenGL states
glDisable(GL_DEPTH_TEST);
// end the rendering
pCalRenderer->endRendering();
}
// this doesn't yet work, it is an attempt to port over the point sprite logic
// from opengles. It draws the point sprites but it doesn't replace the point
// size or color values. I left it here in case anyone wants to fix it :)
void ofxParticleEmitter::drawPoints()
{
// Disable the texture coord array so that texture information is not copied over when rendering
// the point sprites.
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// Bind to the verticesID VBO and popuate it with the necessary vertex & color informaiton
glBindBuffer(GL_ARRAY_BUFFER, verticesID);
glBufferData(GL_ARRAY_BUFFER, sizeof(PointSprite) * maxParticles, vertices, GL_DYNAMIC_DRAW);
// Configure the vertex pointer which will use the currently bound VBO for its data
glVertexPointer(2, GL_FLOAT, sizeof(PointSprite), 0);
glColorPointer(4,GL_FLOAT,sizeof(PointSprite),(GLvoid*) (sizeof(GLfloat)*3));
// Bind to the particles texture
glBindTexture(GL_TEXTURE_2D, (GLuint)textureData.textureID);
// Enable the point size array
//glEnableClientState(GL_POINT_SIZE_ARRAY_OES);
// Configure the point size pointer which will use the currently bound VBO. PointSprite contains
// both the location of the point as well as its size, so the config below tells the point size
// pointer where in the currently bound VBO it can find the size for each point
//glPointSizePointerOES(GL_FLOAT,sizeof(PointSprite),(GLvoid*) (sizeof(GL_FLOAT)*2));
// Change the blend function used if blendAdditive has been set
// Set the blend function based on the configuration
glBlendFunc(blendFuncSource, blendFuncDestination);
// Enable and configure point sprites which we are going to use for our particles
glEnable(GL_POINT_SPRITE);
glTexEnvi( GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE );
// Now that all of the VBOs have been used to configure the vertices, pointer size and color
// use glDrawArrays to draw the points
glDrawArrays(GL_POINTS, 0, particleIndex);
// Unbind the current VBO
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Disable the client states which have been used incase the next draw function does
// not need or use them
//glDisableClientState(GL_POINT_SIZE_ARRAY_OES);
glDisable(GL_POINT_SPRITE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Re-enable the texture coordinates as we use them elsewhere in the game and it is expected that
// its on
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
int EspaceGL::afficher_briques_dock ()
{
if ( m_ptr_dock->possede_element_flotant() )
afficher_brique_flotante_dock();
_3d tmp = {0, 0, 0};
Uint32 timer_a;
Uint32 timer_b;
//std::cout<< BusApp::ref_instance().position_souris().x <<std::endl;
//std::cout << m_ptr_dock->n_elem()<< " briques dock"<<std::endl;
// std::cout << m_ptr_briques_dock->size() << " briques dock"<<std::endl;
int h = 0;
timer_a = SDL_GetTicks();
while ( h < (int) m_ptr_dock->n_elem())
{
int l = 0;
int limite = 500000;
do
{
Brique* brique = m_ptr_dock->montrer_ptr_brique(h);
/* arriere plan maillon : */
if ( m_ptr_dock->element(h).est_verrouille() ) m_rc = m_gc = m_bc = 255; else m_rc = m_gc = m_bc = 235;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()-m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()-m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.z = -1000.000000+10*m_ptr_dock->element(h).montrer_zoom();
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()-m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()-m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()-m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()-m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
/** indicateur verrou maillon*/
/* on choisit la bonne couleur */
if ( ! m_ptr_dock->element(h).est_verrouille() ) m_rc = m_gc = m_bc = 255;
else
{
m_rc = m_gc = m_bc = 0;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+5+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+5+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.z = -1000.000000+10*m_ptr_dock->element(h).montrer_zoom() +5;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+5+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+5+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+5+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+5+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
}
_col c = brique->montrer_couleur();
std::vector <_3d> tmpliste = brique->get_vtxtri();
//positionement
double mf[16];
double mr[16];
brique->copier_matrice_finale_dans(mf);
brique->copier_matrice_rotation_dans(mr);
for ( int i = 0 ; i < (int) tmpliste.size() ; i+=4 )
{
tmp = tmpliste[i+3];
mathematicien.appliquer_matrice(mr, &tmp);
if (tmp.z<0) tmp.z = -tmp.z;
tmp.z = m_lumiere_ambiante+(1-m_lumiere_ambiante)*tmp.z;
unsigned char rc = tmp.z*c.r, bc = tmp.z*c.b, gc = tmp.z*c.g;
for ( int j = i ; j < i+3 ; j++ )
{
tmp = tmpliste[j];
mathematicien.appliquer_matrice(mf, &tmp);
int mx = m_ptr_dock->element(h).obt_x();
int my = m_ptr_dock->element(h).obt_y();
mathematicien.perspective_inconsciente_2( &tmp.x, mx, my);
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = rc;
(*m_triangles_array).c[l+1] = gc;
(*m_triangles_array).c[l+2] = bc;
l+=3;
}
}
h++;
} while ( l < limite && h < (int) m_ptr_dock->n_elem());
(*m_triangles_array).n = l;
glEnable (GL_BLEND);
// Activation des vertex array
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
// Faces
glVertexPointer(P_SIZE, GL_FLOAT, (P_SIZE)*sizeof((*m_triangles_array).e[0]), (*m_triangles_array).e );
glColorPointer(C_SIZE, GL_UNSIGNED_BYTE, (C_SIZE)*sizeof((*m_triangles_array).c[0]), &(*m_triangles_array).c);
glDrawArrays(GL_TRIANGLES, 0,(*m_triangles_array).n/P_SIZE );
// Desctivation des vertex array
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
timer_b = SDL_GetTicks();
//std::cout << " (affichage dock : " << timer_b - timer_a << " milisec )"<< std::endl;
return 0;
}
static void setup_state(const char* vtxs, const ALLEGRO_VERTEX_DECL* decl, ALLEGRO_BITMAP* texture)
{
if(decl) {
ALLEGRO_VERTEX_ELEMENT* e;
e = &decl->elements[ALLEGRO_PRIM_POSITION];
if(e->attribute) {
int ncoord = 0;
GLenum type = 0;
bool normalized;
glEnableClientState(GL_VERTEX_ARRAY);
convert_storage(e->storage, &type, &ncoord, &normalized);
glVertexPointer(ncoord, type, decl->stride, vtxs + e->offset);
} else {
glDisableClientState(GL_VERTEX_ARRAY);
}
e = &decl->elements[ALLEGRO_PRIM_TEX_COORD];
if(!e->attribute)
e = &decl->elements[ALLEGRO_PRIM_TEX_COORD_PIXEL];
if(texture && e->attribute) {
int ncoord = 0;
GLenum type = 0;
bool normalized;
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
convert_storage(e->storage, &type, &ncoord, &normalized);
glTexCoordPointer(ncoord, type, decl->stride, vtxs + e->offset);
} else {
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
e = &decl->elements[ALLEGRO_PRIM_COLOR_ATTR];
if(e->attribute) {
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_FLOAT, decl->stride, vtxs + e->offset);
} else {
glDisableClientState(GL_COLOR_ARRAY);
glColor4f(1, 1, 1, 1);
}
} else {
const ALLEGRO_VERTEX* vtx = (const ALLEGRO_VERTEX*)vtxs;
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(ALLEGRO_VERTEX), &vtx[0].x);
glColorPointer(4, GL_FLOAT, sizeof(ALLEGRO_VERTEX), &vtx[0].color.r);
glTexCoordPointer(2, GL_FLOAT, sizeof(ALLEGRO_VERTEX), &vtx[0].u);
}
if (texture) {
GLuint gl_texture = al_get_opengl_texture(texture);
int true_w, true_h;
int tex_x, tex_y;
GLuint current_texture;
float mat[4][4] = {
{1, 0, 0, 0},
{0, -1, 0, 0},
{0, 0, 1, 0},
{0, 0, 0, 1}
};
int height;
if (texture->parent)
height = texture->parent->h;
else
height = texture->h;
al_get_opengl_texture_size(texture, &true_w, &true_h);
al_get_opengl_texture_position(texture, &tex_x, &tex_y);
mat[3][0] = (float)tex_x / true_w;
mat[3][1] = (float)(height - tex_y) / true_h;
if(decl) {
if(decl->elements[ALLEGRO_PRIM_TEX_COORD_PIXEL].attribute) {
mat[0][0] = 1.0f / true_w;
mat[1][1] = -1.0f / true_h;
} else {
mat[0][0] = (float)al_get_bitmap_width(texture) / true_w;
mat[1][1] = -(float)al_get_bitmap_height(texture) / true_h;
}
} else {
mat[0][0] = 1.0f / true_w;
mat[1][1] = -1.0f / true_h;
}
glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*)¤t_texture);
if (current_texture != gl_texture) {
glBindTexture(GL_TEXTURE_2D, gl_texture);
}
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(mat[0]);
glMatrixMode(GL_MODELVIEW);
} else {
glBindTexture(GL_TEXTURE_2D, 0);
}
}
int EspaceGL::afficher_briques_2 (void)
{
std::vector <Brique*> &b = (*m_ptr_briques);
_3d tmp = {0, 0, 0};
int mx = BusApp::ref_instance().renvoyer_resolution_fenetre().x/2;
int my = BusApp::ref_instance().renvoyer_resolution_fenetre().y/2;
int h = 0;
while ( h < (int) b.size())
{
int l = 0;
int limite = 500000;
do
{
Brique* brique = m_ptr_briques->at(h);
_col c = brique->montrer_couleur();
std::vector <_3d> tmpliste = brique->get_vtxtri();
//arr = brique->get_ptr_arrays();
//(*m_triangles_array).n = 0;
//positionement
double mf[16];
double mr[16];
brique->copier_matrice_finale_dans(mf);
mathematicien.produit(mf, m_Cam_matF);
// mathematicien.produit(mf, mb);
brique->copier_matrice_rotation_dans(mr);
mathematicien.produit(mr, m_Cam_matR);
// affichage des faces
_3d pos = brique->get_centre();
Mathematicien().appliquer_matrice(mf, &pos);
if ( (pos.z < LIMITE_PROCHE) && (pos.z > LIMITE_LOIN) )
{
for ( int i = 0 ; i < (int) tmpliste.size() ; i+=4 )
{
tmp = tmpliste[i+3];
mathematicien.appliquer_matrice(mr, &tmp);
if (tmp.z<0) tmp.z = -tmp.z;
// tmp.z = m_lumiere_ambiante+(1-m_lumiere_ambiante)*tmp.z;
unsigned char rc = tmp.z*c.r, bc = tmp.z*c.b, gc = tmp.z*c.g;
for ( int j = i ; j < i+3 ; j++ )
{
tmp = tmpliste[j];
mathematicien.perspective_folle(&(*m_triangles_array).e[l], &tmp.x, mf, mx, my);
(*m_triangles_array).c[l] = rc; l++;
(*m_triangles_array).c[l] = gc; l++;
(*m_triangles_array).c[l] = bc; l++;
}
}
}
h++;
//
//
} while ( l < limite && h < (int) b.size());
(*m_triangles_array).n = l;
glEnable (GL_BLEND);
// Activation des vertex array
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
// Faces
glVertexPointer(P_SIZE, GL_FLOAT, (P_SIZE)*sizeof((*m_triangles_array).e[0]), (*m_triangles_array).e );
glColorPointer(C_SIZE, GL_UNSIGNED_BYTE, (C_SIZE)*sizeof((*m_triangles_array).c[0]), &(*m_triangles_array).c);
// glNormalPointer();
glDrawArrays(GL_TRIANGLES, 0,(*m_triangles_array).n/P_SIZE );
// Desctivation des vertex array
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
return 0;
}
int main( void )
{
GLFWwindow *window;
// Initialize the library
if ( !glfwInit( ) )
{
return -1;
}
// Create a windowed mode window and its OpenGL context
window = glfwCreateWindow( SCREEN_WIDTH, SCREEN_HEIGHT, "Hello World", NULL, NULL );
if ( !window )
{
glfwTerminate( );
return -1;
}
// Make the window's context current
glfwMakeContextCurrent( window );
glViewport( 0.0f, 0.0f, SCREEN_WIDTH, SCREEN_HEIGHT ); // specifies the part of the window to which OpenGL will draw (in pixels), convert from normalised to pixels
glMatrixMode( GL_PROJECTION ); // projection matrix defines the properties of the camera that views the objects in the world coordinate frame. Here you typically set the zoom factor, aspect ratio and the near and far clipping planes
glLoadIdentity( ); // replace the current matrix with the identity matrix and starts us a fresh because matrix transforms such as glOrpho and glRotate cumulate, basically puts us at (0, 0, 0)
glOrtho( 0, SCREEN_WIDTH, 0, SCREEN_HEIGHT, 0, 1 ); // essentially set coordinate system
glMatrixMode( GL_MODELVIEW ); // (default matrix mode) modelview matrix defines how your objects are transformed (meaning translation, rotation and scaling) in your world
glLoadIdentity( ); // same as above comment
GLfloat polygonVertices[] =
{
320, 240, 0,
370, 290, 0,
420, 240, 0,
370, 190, 0
};
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
// Loop until the user closes the window
while ( !glfwWindowShouldClose( window ) )
{
glClear( GL_COLOR_BUFFER_BIT );
// render OpenGL here
glEnableClientState( GL_VERTEX_ARRAY );
glVertexPointer( 3, GL_FLOAT, 0, polygonVertices );
glDrawArrays( GL_TRIANGLE_FAN, 0, 4 );
glDisableClientState( GL_VERTEX_ARRAY );
// Swap front and back buffers
glfwSwapBuffers( window );
// Poll for and process events
glfwPollEvents( );
}
glfwTerminate( );
return 0;
}
int EspaceGL::afficher_brique_flotante_dock ()
{
_3d tmp = {0, 0, 0};
Uint32 timer_a;
Uint32 timer_b;
int h = 0;
timer_a = SDL_GetTicks();
while ( h < (int) m_ptr_dock->n_elem())
{
int l = 0;
int limite = 500000;
do
{
Brique* brique = m_ptr_dock->montrer_ptr_brique_flotante();
_col c = brique->montrer_couleur();
std::vector <_3d> tmpliste = brique->get_vtxtri();
//positionement
double mf[16];
double mr[16];
brique->copier_matrice_finale_dans(mf);
brique->copier_matrice_rotation_dans(mr);
for ( int i = 0 ; i < (int) tmpliste.size() ; i+=4 )
{
tmp = tmpliste[i+3];
mathematicien.appliquer_matrice(mr, &tmp);
if (tmp.z<0) tmp.z = -tmp.z;
tmp.z = m_lumiere_ambiante+(1-m_lumiere_ambiante)*tmp.z;
unsigned char rc = tmp.z*c.r, bc = tmp.z*c.b, gc = tmp.z*c.g;
for ( int j = i ; j < i+3 ; j++ )
{
tmp = tmpliste[j];
mathematicien.appliquer_matrice(mf, &tmp);
int mx = BusApp::ref_instance().position_souris().x;
int my = BusApp::ref_instance().position_souris().y;
mathematicien.perspective_inconsciente_2( &tmp.x, mx, my);
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = rc;
(*m_triangles_array).c[l+1] = gc;
(*m_triangles_array).c[l+2] = bc;
l+=3;
}
}
h++;
} while ( l < limite && h < (int) m_ptr_dock->n_elem());
(*m_triangles_array).n = l;
glEnable (GL_BLEND);
// Activation des vertex array
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
// Faces
glVertexPointer(P_SIZE, GL_FLOAT, (P_SIZE)*sizeof((*m_triangles_array).e[0]), (*m_triangles_array).e );
glColorPointer(C_SIZE, GL_UNSIGNED_BYTE, (C_SIZE)*sizeof((*m_triangles_array).c[0]), &(*m_triangles_array).c);
glDrawArrays(GL_TRIANGLES, 0,(*m_triangles_array).n/P_SIZE );
// Desctivation des vertex array
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
timer_b = SDL_GetTicks();
//std::cout << " (affichage dock : " << timer_b - timer_a << " milisec )"<< std::endl;
return 0;
}
//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Draws the scene
//-----------------------------------------------------------------------------
void Render()
{
glClearColor(0.0F, 0.0F, 0.0F, 1.0F);
glClearDepth(1.0F);
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClear(GL_COLOR_BUFFER_BIT);
//glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//gluLookAt(0, 0, 1, 0, 0, -5, 0, 1, 0);
//glTranslatef(0.0f, 0.0f, -0.1f);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
//gluPerspective(90.0f, 1.0, 0.1f, 100.0f);
glFrustum(-1, 1, -1, 1, 0.95, 10);
/*//glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//glTranslatef(0.0f, 0.0f,-4.0f);
gluLookAt(0, 0, 0, 0, 0, -5, 0, 1, 0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, 1.0f, 0.1f, 100.0f);*/
/*glBindBuffer(GL_ARRAY_BUFFER, BufferName[COLOR_OBJECT]);
glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, BufferName[POSITION_OBJECT]);
glVertexPointer(2, GL_FLOAT, 0, 0);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDrawArrays(GL_TRIANGLES, 0, VertexCount);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, 0);*/
//AE::uint strideInBytes = 11;
AE::uint strideInBytes = 15;
AE::uint sizeofFloat = sizeof(float);
AE::uint sizeOfFloatTimesTwo = sizeofFloat * 2;
AE::uint sizeOfFloatTimesThree = sizeofFloat * 3;
glBindBuffer(GL_ARRAY_BUFFER, bufferId);
//glVertexPointer(2, GL_FLOAT, strideInBytes, AE_GL_BUFFER_OFFSET(0));
glVertexPointer(3, GL_FLOAT, strideInBytes, AE_GL_BUFFER_OFFSET(0));
//glColorPointer(3, GL_UNSIGNED_BYTE, strideInBytes, AE_GL_BUFFER_OFFSET(sizeOfFloatTimesTwo));
glColorPointer(3, GL_UNSIGNED_BYTE, strideInBytes, AE_GL_BUFFER_OFFSET(sizeOfFloatTimesThree));
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferId);
size_t error = glGetError();
//glDrawArrays(GL_TRIANGLES, 0, 3);
glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_BYTE, AE_GL_BUFFER_OFFSET(0));
error = glGetError();
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, 0);
/*glColor3f(1.0, 1.0, 1.0);
glBegin(GL_POLYGON);
glVertex3f(0.25, 0.25, 0.0);
glVertex3f(0.75, 0.25, 0.0);
glVertex3f(0.75, 0.75, 0.0);
glVertex3f(0.25, 0.75, 0.0);
glEnd();*/
//glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glViewport(0, 0, 300, 300);
// Reset the coordinate system before modifying
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Pseudo window coordinates
gluOrtho2D(0.0, (GLfloat) 300, 0.0f, (GLfloat) 300);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
GLuint *pImage = (GLuint *)(malloc(sizeof(GLuint)));
pImage[0] = 0xFFFF00FF;
glRasterPos2i(50, 50);
glDrawPixels(1, 1, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pImage);
free(pImage);
::SwapBuffers(deviceContext);
}
int EspaceGL::afficher_briques_dock_offscreen ( void )
{
_3d tmp = {0, 0, 0};
Uint32 timer_a;
Uint32 timer_b;
// std::cout<< BusApp::ref_instance().position_souris().x <<std::endl;
//std::cout << m_ptr_dock->n_elem()<< " briques dock off"<<std::endl;
// std::cout << m_ptr_briques_dock->size() << " briques dock"<<std::endl;
int h = 0;
timer_a = SDL_GetTicks();
while ( h < (int) m_ptr_dock->n_elem())
{
int l = 0;
int limite = 500000;
do
{
Brique* brique = m_ptr_dock->montrer_ptr_brique(h);
tmp.x = (double) m_ptr_dock->element(h).montrer_x()-m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()-m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.z = -1000.000000+10*m_ptr_dock->element(h).montrer_zoom();
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()-m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.z = -1000.000000+10*m_ptr_dock->element(h).montrer_zoom();;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.z = -1000.000000+10*m_ptr_dock->element(h).montrer_zoom();;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()-m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()-m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.z = -1000.000000+10*m_ptr_dock->element(h).montrer_zoom();;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()+m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.z = -1000.000000+10*m_ptr_dock->element(h).montrer_zoom();;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
tmp.x = (double) m_ptr_dock->element(h).montrer_x()-m_ptr_dock->element(h).montrer_w()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.y = (double) m_ptr_dock->element(h).montrer_y()+m_ptr_dock->element(h).montrer_h()*-m_ptr_dock->element(h).montrer_zoom()/2;
tmp.z = -1000.000000+10*m_ptr_dock->element(h).montrer_zoom();;
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).e[l+1] = tmp.y;
(*m_triangles_array).e[l+2] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) m_rc;
(*m_triangles_array).c[l+1] = (unsigned char) m_gc;
(*m_triangles_array).c[l+2] = (unsigned char) m_bc;
l+=3;
m_map_ptr_brique[m_ptr] = brique;
m_map_id_surface_brique[m_ptr] = -1;
m_ptr++; m_rc++; if (m_rc==256) { m_rc = 0; m_gc++; if (m_gc==256) { m_gc = 0; m_bc++; } }
std::vector <_3d> tmpliste = brique->get_vtxsom();
(*m_triangles_array).n = 0;
//positionement
double mf[16];
double mr[16];
brique->copier_matrice_finale_dans(mf);
brique->copier_matrice_rotation_dans(mr);
// affichage des faces
for ( int j = 0 ; j < brique->n_surface() ; j++)
{
for ( int i = 0 ; i < brique->surface(j).n_tri()*3 ; i++ )
{
tmp = tmpliste[brique->surface(j).som(i)];
// mathematicien.appliquer_matrice(mf, &tmp);
mathematicien.appliquer_matrice(mf, &tmp);
int mx = m_ptr_dock->element(h).obt_x();
int my = m_ptr_dock->element(h).obt_y();
mathematicien.perspective_inconsciente_2( &tmp.x, mx, my);
(*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).c[l] = (unsigned char) (m_rc); l++;
(*m_triangles_array).e[l] = tmp.y;
(*m_triangles_array).c[l] = (unsigned char) (m_gc); l++;
(*m_triangles_array).e[l] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) (m_bc); l++;
}
m_map_id_surface_brique[m_ptr] = j;
m_map_ptr_brique[m_ptr] = brique;
m_ptr++; m_rc++; if (m_rc==256) { m_rc = 0; m_gc++; if (m_gc==256) { m_gc = 0; m_bc++; } }
}
h++;
} while ( l < limite && h < (int) m_ptr_dock->n_elem());
(*m_triangles_array).n = l;
glEnable (GL_BLEND);
// Activation des vertex array
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
// Faces
glVertexPointer(P_SIZE, GL_FLOAT, (P_SIZE)*sizeof((*m_triangles_array).e[0]), (*m_triangles_array).e );
glColorPointer(C_SIZE, GL_UNSIGNED_BYTE, (C_SIZE)*sizeof((*m_triangles_array).c[0]), &(*m_triangles_array).c);
glDrawArrays(GL_TRIANGLES, 0,(*m_triangles_array).n/P_SIZE );
// Desctivation des vertex array
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
timer_b = SDL_GetTicks();
//std::cout << " (affichage dock : " << timer_b - timer_a << " milisec )"<< std::endl;
m_taille_map_brique = m_ptr;
return 0;
}
//! Render piclist texture
void Storm3D_Scene_PicList_Picture::Render()
{
IStorm3D_Material::ATYPE alphaType = IStorm3D_Material::ATYPE_NONE;
if(material)
{
alphaType = material->GetAlphaType();
if(alpha < 0.99f && alphaType == IStorm3D_Material::ATYPE_NONE)
material->SetAlphaType(IStorm3D_Material::ATYPE_USE_TEXTRANSPARENCY);
// Apply the texture
material->ApplyBaseTextureExtOnly();
if(wrap)
{
glActiveTexture(GL_TEXTURE0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
} else {
glActiveTexture(GL_TEXTURE0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
// Animate
{
IStorm3D_Texture *ti = material->GetBaseTexture();
// FIXED: crashed to null pointer here. -jpk
if (ti != NULL)
{
Storm3D_Texture *t = static_cast<Storm3D_Texture *> (ti);
t->AnimateVideo();
}
}
}
// FIXME: ugly hack to work around disappearing grenade throw meter
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// Create 3d-vector
VC3 pos(position.x,position.y,0);
// Create color (color+alpha)
DWORD col = 0xFFFFFFFF;
if(material)
{
COL c(1.f, 1.f, 1.f);
float newAlpha = 1.f;
c = material->GetColor();
newAlpha = alpha * (1-material->GetTransparency());
col=COLOR_RGBA((int)(c.r*255.0f),(int)(c.g*255.0f),(int)(c.b*255.0f),(int)(newAlpha*255.0f));
//col = COLOR_RGBA(c.r, c.g, c.b, newAlpha);
}
// Render it
frozenbyte::storm::VertexShader::disable();
// render with custom shape
if(customShape && customShape->vertices)
{
// use combined alpha
float alpha_mul = 1.0f;
if(material)
{
alpha_mul = alpha * (1.0f - material->GetTransparency());
}
for(int i = 0; i < customShape->numVertices; i++)
{
DWORD c = customShape->vertices[i].color;
int newAlpha = (int)((c >> 24) * alpha_mul);
c &= 0x00FFFFFF;
c |= (newAlpha & 0xFF) << 24;
customShape->vertices[i].color = c;
customShape->vertices[i].position.x -= .5f;
customShape->vertices[i].position.y -= .5f;
}
glEnableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glClientActiveTexture(GL_TEXTURE0);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(VXFORMAT_2D), &customShape->vertices[0].position);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VXFORMAT_2D), &customShape->vertices[0].color);
glTexCoordPointer(2, GL_FLOAT, sizeof(VXFORMAT_2D), &customShape->vertices[0].texcoords);
glDrawArrays(GL_TRIANGLES, 0, customShape->numVertices);
scene->AddPolyCounter(customShape->numVertices/3);
}
int EspaceGL::afficher_briques_offscreen()
{
m_ptr = 0;
Uint32 timer_a, timer_b;
std::vector <Brique*> &b = (*m_ptr_briques);
_3d tmp = {0, 0, 0};
m_map_id_surface_brique[m_ptr] = -1;
m_map_ptr_brique[m_ptr] = m_ptr_briques->at(0);
m_ptr++; m_rc++;
int mx = BusApp::ref_instance().renvoyer_resolution_fenetre().x/2;
int my = BusApp::ref_instance().renvoyer_resolution_fenetre().y/2;
int h = 1;
while ( h < (int) b.size())
{
int l = 0;
int limite = 700000;
timer_a = SDL_GetTicks();
do
{
Brique* brique = m_ptr_briques->at(h);
std::vector <_3d> tmpliste = brique->get_vtxsom();
(*m_triangles_array).n = 0;
//positionement
double mf[16];
double mr[16];
brique->copier_matrice_finale_dans(mf);
mathematicien.produit(mf, m_Cam_matF);
brique->copier_matrice_rotation_dans(mr);
mathematicien.produit(mr, m_Cam_matR);
_3d pos = brique->get_centre();
Mathematicien().appliquer_matrice(mf, &pos);
if ( pos.z < LIMITE_PROCHE && pos.z > LIMITE_LOIN )
{
// affichage des faces
for ( int j = 0 ; j < brique->n_surface() ; j++)
{
for ( int i = 0 ; i < brique->surface(j).n_tri()*3 ; i++ )
{
tmp = tmpliste[brique->surface(j).som(i)];
// mathematicien.appliquer_matrice(mf, &tmp);
mathematicien.perspective_folle(&(*m_triangles_array).e[l], &tmp.x, mf , mx,my);
// (*m_triangles_array).e[l] = tmp.x;
(*m_triangles_array).c[l] = (unsigned char) (m_rc); l++;
//(*m_triangles_array).e[l] = tmp.y;
(*m_triangles_array).c[l] = (unsigned char) (m_gc); l++;
//(*m_triangles_array).e[l] = tmp.z;
(*m_triangles_array).c[l] = (unsigned char) (m_bc); l++;
}
m_map_id_surface_brique[m_ptr] = j;
m_map_ptr_brique[m_ptr] = brique;
m_ptr++; m_rc++; if (m_rc==256) { m_rc = 0; m_gc++; if (m_gc==256) { m_gc = 0; m_bc++; } }
}
}
h++;
//
//
} while ( l < limite && h < (int) b.size());
(*m_triangles_array).n = l;
timer_b = SDL_GetTicks();
//std::cout << " array_offsrceen.n (remplissage : " << timer_b - timer_a << " milisec ) : " << l << " vertex"<<std::endl;
glEnable (GL_BLEND);
// Activation des vertex array
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
// Faces
glVertexPointer(P_SIZE, GL_FLOAT, (P_SIZE)*sizeof((*m_triangles_array).e[0]), (*m_triangles_array).e );
glColorPointer(C_SIZE, GL_UNSIGNED_BYTE, (C_SIZE)*sizeof((*m_triangles_array).c[0]), &(*m_triangles_array).c);
glDrawArrays(GL_TRIANGLES, 0,(*m_triangles_array).n/P_SIZE );
//
//
// Desctivation des vertex array
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
timer_a = SDL_GetTicks();
#ifdef COUT_TEMPS8RENDU
std::cout << " (affichage : " << timer_a - timer_b << " milisec ) : " <<std::endl;
#endif // COUT_TEMPS8RENDU
}
m_taille_map_brique = m_ptr;
return 0;
}
void
Canvas::DrawCircle(int x, int y, unsigned radius)
{
if (IsPenOverBrush() && pen.GetWidth() > 2) {
GLDonutVertices vertices(x, y,
radius - pen.GetWidth() / 2,
radius + pen.GetWidth() / 2);
if (!brush.IsHollow()) {
vertices.bind_inner_circle();
brush.Set();
glDrawArrays(GL_TRIANGLE_FAN, 0, vertices.CIRCLE_SIZE);
}
vertices.bind();
pen.Set();
glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices.SIZE);
} else if (OpenGL::vertex_buffer_object && radius < 16) {
/* draw a "small" circle with VBO */
OpenGL::small_circle_buffer->Bind();
glVertexPointer(2, GL_SHORT, 0, NULL);
glPushMatrix();
#ifdef HAVE_GLES
glTranslatex((GLfixed)x << 16, (GLfixed)y << 16, 0);
glScalex((GLfixed)radius << 8, (GLfixed)radius << 8, (GLfixed)1 << 16);
#else
glTranslatef(x, y, 0.);
glScalef(radius / 256., radius / 256., 1.);
#endif
if (!brush.IsHollow()) {
brush.Set();
glDrawArrays(GL_TRIANGLE_FAN, 0, OpenGL::SMALL_CIRCLE_SIZE);
}
if (IsPenOverBrush()) {
pen.Bind();
glDrawArrays(GL_LINE_LOOP, 0, OpenGL::SMALL_CIRCLE_SIZE);
pen.Unbind();
}
glPopMatrix();
OpenGL::small_circle_buffer->Unbind();
} else if (OpenGL::vertex_buffer_object) {
/* draw a "big" circle with VBO */
OpenGL::circle_buffer->Bind();
glVertexPointer(2, GL_SHORT, 0, NULL);
glPushMatrix();
#ifdef HAVE_GLES
glTranslatex((GLfixed)x << 16, (GLfixed)y << 16, 0);
glScalex((GLfixed)radius << 6, (GLfixed)radius << 6, (GLfixed)1 << 16);
#else
glTranslatef(x, y, 0.);
glScalef(radius / 1024., radius / 1024., 1.);
#endif
if (!brush.IsHollow()) {
brush.Set();
glDrawArrays(GL_TRIANGLE_FAN, 0, OpenGL::CIRCLE_SIZE);
}
if (IsPenOverBrush()) {
pen.Bind();
glDrawArrays(GL_LINE_LOOP, 0, OpenGL::CIRCLE_SIZE);
pen.Unbind();
}
glPopMatrix();
OpenGL::circle_buffer->Unbind();
} else {
GLCircleVertices vertices(x, y, radius);
vertices.bind();
if (!brush.IsHollow()) {
brush.Set();
glDrawArrays(GL_TRIANGLE_FAN, 0, vertices.SIZE);
}
if (IsPenOverBrush()) {
pen.Bind();
glDrawArrays(GL_LINE_LOOP, 0, vertices.SIZE);
pen.Unbind();
}
}
}
void LayerBase::drawWithOpenGL(const Region& clip, const Texture& texture) const
{
const DisplayHardware& hw(graphicPlane(0).displayHardware());
const uint32_t fbHeight = hw.getHeight();
const State& s(drawingState());
// bind our texture
TextureManager::activateTexture(texture, needsFiltering());
uint32_t width = texture.width;
uint32_t height = texture.height;
GLenum src = mPremultipliedAlpha ? GL_ONE : GL_SRC_ALPHA;
int renderEffect = mFlinger->getRenderEffect();
int renderColorR = mFlinger->getRenderColorR();
int renderColorG = mFlinger->getRenderColorG();
int renderColorB = mFlinger->getRenderColorB();
bool noEffect = renderEffect == 0;
if (UNLIKELY(s.alpha < 0xFF) && noEffect) {
const GLfloat alpha = s.alpha * (1.0f/255.0f);
if (mPremultipliedAlpha) {
glColor4f(alpha, alpha, alpha, alpha);
} else {
glColor4f(1, 1, 1, alpha);
}
glEnable(GL_BLEND);
glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
} else if (noEffect) {
glColor4f(1, 1, 1, 1);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
if (needsBlending()) {
glEnable(GL_BLEND);
glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
} else {
glDisable(GL_BLEND);
}
} else {
// Apply a render effect, which is simple color masks for now.
GLenum env, src;
env = GL_MODULATE;
src = mPremultipliedAlpha ? GL_ONE : GL_SRC_ALPHA;
const GGLfixed alpha = (s.alpha << 16)/255;
switch (renderEffect) {
case RENDER_EFFECT_NIGHT:
glColor4x(alpha, alpha*0.6204, alpha*0.3018, alpha);
break;
case RENDER_EFFECT_TERMINAL:
glColor4x(0, alpha, 0, alpha);
break;
case RENDER_EFFECT_BLUE:
glColor4x(0, 0, alpha, alpha);
break;
case RENDER_EFFECT_AMBER:
glColor4x(alpha, alpha*0.75, 0, alpha);
break;
case RENDER_EFFECT_SALMON:
glColor4x(alpha, alpha*0.5, alpha*0.5, alpha);
break;
case RENDER_EFFECT_FUSCIA:
glColor4x(alpha, 0, alpha*0.5, alpha);
break;
case RENDER_EFFECT_N1_CALIBRATED_N:
glColor4x(alpha*renderColorR/1000, alpha*renderColorG/1000, alpha*renderColorB/1000, alpha);
break;
case RENDER_EFFECT_N1_CALIBRATED_R:
glColor4x(alpha*(renderColorR-50)/1000, alpha*renderColorG/1000, alpha*(renderColorB-30)/1000, alpha);
break;
case RENDER_EFFECT_N1_CALIBRATED_C:
glColor4x(alpha*renderColorR/1000, alpha*renderColorG/1000, alpha*(renderColorB+30)/1000, alpha);
break;
case RENDER_EFFECT_RED:
glColor4x(alpha, 0, 0, alpha);
break;
}
glEnable(GL_BLEND);
glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, env);
}
/*
* compute texture coordinates
* here, we handle NPOT, cropping and buffer transformations
*/
GLfloat cl, ct, cr, cb;
if (!mBufferCrop.isEmpty()) {
// source is cropped
const GLfloat us = (texture.NPOTAdjust ? texture.wScale : 1.0f) / width;
const GLfloat vs = (texture.NPOTAdjust ? texture.hScale : 1.0f) / height;
cl = mBufferCrop.left * us;
ct = mBufferCrop.top * vs;
cr = mBufferCrop.right * us;
cb = mBufferCrop.bottom * vs;
} else {
cl = 0;
ct = 0;
cr = (texture.NPOTAdjust ? texture.wScale : 1.0f);
cb = (texture.NPOTAdjust ? texture.hScale : 1.0f);
}
/*
* For the buffer transformation, we apply the rotation last.
* Since we're transforming the texture-coordinates, we need
* to apply the inverse of the buffer transformation:
* inverse( FLIP_V -> FLIP_H -> ROT_90 )
* <=> inverse( ROT_90 * FLIP_H * FLIP_V )
* = inverse(FLIP_V) * inverse(FLIP_H) * inverse(ROT_90)
* = FLIP_V * FLIP_H * ROT_270
* <=> ROT_270 -> FLIP_H -> FLIP_V
*
* The rotation is performed first, in the texture coordinate space.
*
*/
struct TexCoords {
GLfloat u;
GLfloat v;
};
enum {
// name of the corners in the texture map
LB = 0, // left-bottom
LT = 1, // left-top
RT = 2, // right-top
RB = 3 // right-bottom
};
// vertices in screen space
int vLT = LB;
int vLB = LT;
int vRB = RT;
int vRT = RB;
// the texture's source is rotated
uint32_t transform = mBufferTransform;
if (transform & HAL_TRANSFORM_ROT_90) {
vLT = RB;
vLB = LB;
vRB = LT;
vRT = RT;
}
if (transform & HAL_TRANSFORM_FLIP_V) {
swap(vLT, vLB);
swap(vRT, vRB);
}
if (transform & HAL_TRANSFORM_FLIP_H) {
swap(vLT, vRT);
swap(vLB, vRB);
}
TexCoords texCoords[4];
texCoords[vLT].u = cl;
texCoords[vLT].v = ct;
texCoords[vLB].u = cl;
texCoords[vLB].v = cb;
texCoords[vRB].u = cr;
texCoords[vRB].v = cb;
texCoords[vRT].u = cr;
texCoords[vRT].v = ct;
if (needsDithering()) {
glEnable(GL_DITHER);
} else {
glDisable(GL_DITHER);
}
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, mVertices);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
Region::const_iterator it = clip.begin();
Region::const_iterator const end = clip.end();
while (it != end) {
const Rect& r = *it++;
const GLint sy = fbHeight - (r.top + r.height());
glScissor(r.left, sy, r.width(), r.height());
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
void MDTexture::render_billboards3(MDOpenGL &opengl, vector<int> &visible_atom_indices, vector<int> &atom_types, vector<vector<float> > &positions, bool draw_water, double color_cutoff, double dr2_max, vector<float> system_size, bool periodic_boundary_conditions) {
Camera *camera = opengl.camera;
CVector left, up, right, direction, v0, v1, v2, v3;
int S = 1.0;
double cam_x = camera->position.x; double cam_y = camera->position.y; double cam_z = camera->position.z;
double one_over_color_cutoff = 1.0/color_cutoff;
CVector up_on_screen = opengl.coord_to_ray(0,opengl.window_height/2.0);
double dx = camera->target.x - cam_x;
double dy = camera->target.y - cam_y;
double dz = camera->target.z - cam_z;
direction = camera->target;
left = direction.Cross(up_on_screen);
up = (direction.Cross(left)).Normalize();
right = (direction.Cross(up)).Normalize();
v0 = (right + up);
v1 = (right*-1 + up);
v2 = (right*-1 + up*-1);
v3 = (right + up*-1);
glNormal3f(direction.x, direction.y, direction.z);
int num_vertices = 0;
int num_atoms = 0;
for(int n=0; n<positions.size(); n++) {
int atom_type = atom_types[n];
if( (atom_type == H_TYPE || atom_type == O_TYPE) && !draw_water) continue;
double scale = visual_atom_radii[atom_type];
double real_x = positions[n][0];
double real_y = positions[n][1];
double real_z = positions[n][2];
for(int dx = -1; dx <= 1; dx++) {
for(int dy = -1; dy <= 1; dy++) {
for(int dz = -1; dz <= 1; dz++) {
if(!periodic_boundary_conditions && (dx != 0 || dy != 0 || dz != 0)) continue;
double x = real_x + system_size[0]*dx;
double y = real_y + system_size[1]*dy;
double z = real_z + system_size[2]*dz;
double delta_x = x - cam_x;
double delta_y = y - cam_y;
double delta_z = z - cam_z;
double dr2 = delta_x*delta_x + delta_y*delta_y + delta_z*delta_z;
if(dr2 < 50) continue;
if(dr2 > dr2_max) continue;
double cam_target_times_dr = delta_x*direction.x + delta_y*direction.y + delta_z*direction.z;
if(cam_target_times_dr < 0) continue;
vertices[3*num_vertices + 0] = v0.x*scale + x;
vertices[3*num_vertices + 1] = v0.y*scale + y;
vertices[3*num_vertices + 2] = v0.z*scale + z;
indices[num_vertices] = num_vertices;
num_vertices++;
vertices[3*num_vertices + 0] = v1.x*scale + x;
vertices[3*num_vertices + 1] = v1.y*scale + y;
vertices[3*num_vertices + 2] = v1.z*scale + z;
indices[num_vertices] = num_vertices;
num_vertices++;
vertices[3*num_vertices + 0] = v2.x*scale + x;
vertices[3*num_vertices + 1] = v2.y*scale + y;
vertices[3*num_vertices + 2] = v2.z*scale + z;
indices[num_vertices] = num_vertices;
num_vertices++;
vertices[3*num_vertices + 0] = v3.x*scale + x;
vertices[3*num_vertices + 1] = v3.y*scale + y;
vertices[3*num_vertices + 2] = v3.z*scale + z;
indices[num_vertices] = num_vertices;
num_vertices++;
colors[4*num_atoms + 0] = color_list[atom_type][0];
colors[4*num_atoms + 1] = color_list[atom_type][1];
colors[4*num_atoms + 2] = color_list[atom_type][2];
colors[4*num_atoms + 3] = 1.0;
num_atoms++;
}
}
}
}
glNormal3f(direction.x, direction.y, direction.z);
// glNormalPointer(GL_FLOAT, 6*sizeof(GLfloat), (float*)(3*sizeof(GLfloat)));
glBindBuffer(GL_ARRAY_BUFFER, vertices_id);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*3*num_vertices, NULL, GL_DYNAMIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLfloat)*3*num_vertices, vertices);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_id);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*num_vertices, NULL, GL_STATIC_DRAW);
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(GLuint)*num_vertices, indices);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, GL_FLOAT, 3*sizeof(GLfloat), NULL);
glColorPointer (4, GL_FLOAT, 4, NULL);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_id);
glBindBuffer(GL_ARRAY_BUFFER, vertices_id);
glDrawElements(GL_QUADS, num_vertices, GL_UNSIGNED_INT, 0);
glDisableClientState(GL_VERTEX_ARRAY);
}
void GLMeshBuffer::draw()
{
if(m_effectType == setCustom && m_uShaderEffectProgram != INVALID_GLBUFFER)
glUseProgram(m_uShaderEffectProgram);
glPushAttrib(GL_ALL_ATTRIB_BITS);
if(m_bWireFrame)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
//Color
if(m_isValidColor)
{
glBindBuffer(GL_ARRAY_BUFFER, m_vboColor);
glColorPointer(m_stepColor, GL_FLOAT, 0, 0);
glEnableClientState(GL_COLOR_ARRAY);
}
//TexCoord
if(m_isValidTexCoord)
{
glBindBuffer(GL_ARRAY_BUFFER, m_vboTexCoord);
glTexCoordPointer(m_stepTexCoord, GL_FLOAT, 0, 0);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
//Normal
if(m_isValidNormal)
{
glBindBuffer(GL_ARRAY_BUFFER, m_vboNormal);
glNormalPointer(GL_FLOAT, 0, 0);
glEnableClientState(GL_NORMAL_ARRAY);
}
//Vertex
if(m_isValidVertex)
{
glBindBuffer(GL_ARRAY_BUFFER, m_vboVertex);
glVertexPointer(m_stepVertex, GL_FLOAT, 0, 0);
glEnableClientState(GL_VERTEX_ARRAY);
}
//Draw Faces
if(m_isValidIndex)
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iboFaces);
glEnableClientState(GL_ELEMENT_ARRAY_BUFFER);
glDrawElements(m_faceMode, (GLsizei)m_ctFaceElements, GL_UNSIGNED_INT, (GLvoid*)0);
glDisableClientState(GL_ELEMENT_ARRAY_BUFFER);
}
else
glDrawArrays(m_faceMode, 0, m_ctFaceElements);
if(m_isValidColor)
glDisableClientState(GL_COLOR_ARRAY);
if(m_isValidTexCoord)
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
if(m_isValidNormal)
glDisableClientState(GL_NORMAL_ARRAY);
if(m_isValidVertex)
glDisableClientState(GL_VERTEX_ARRAY);
glPopAttrib();
if(m_effectType == setCustom && m_uShaderEffectProgram != INVALID_GLBUFFER)
glUseProgram(0);
}