/*
** This is a screwball function. What it does is the following:
** Given screen x and y coordinates, compute the corresponding object space
** x and y coordinates given that the object space z is 0.9 + OFFSETZ.
** Since the tops of (most) pieces are at z = 0.9 + OFFSETZ, we use that
** number.
*/
int
computeCoords(int piece, int mousex, int mousey,
GLfloat * selx, GLfloat * sely)
{
GLfloat modelMatrix[16];
GLfloat projMatrix[16];
GLfloat finalMatrix[16];
GLfloat in[4];
GLfloat a, b, c, d;
GLfloat top, bot;
GLfloat z;
GLfloat w;
GLfloat height;
if (piece == 0)
return 0;
height = zsize[piece] - 0.1 + OFFSETZ;
glGetFloatv(GL_PROJECTION_MATRIX, projMatrix);
glGetFloatv(GL_MODELVIEW_MATRIX, modelMatrix);
multMatrices(modelMatrix, projMatrix, finalMatrix);
if (!invertMatrix(finalMatrix, finalMatrix))
return 0;
in[0] = (2.0 * (mousex - viewport[0]) / viewport[2]) - 1;
in[1] = (2.0 * ((H - mousey) - viewport[1]) / viewport[3]) - 1;
a = in[0] * finalMatrix[0 * 4 + 2] +
in[1] * finalMatrix[1 * 4 + 2] +
finalMatrix[3 * 4 + 2];
b = finalMatrix[2 * 4 + 2];
c = in[0] * finalMatrix[0 * 4 + 3] +
in[1] * finalMatrix[1 * 4 + 3] +
finalMatrix[3 * 4 + 3];
d = finalMatrix[2 * 4 + 3];
/*
** Ok, now we need to solve for z: ** (a + b z) / (c + d
z) = height. ** ("height" is the height in object space we
want to solve z for) ** ** ==> a + b z = height c +
height d z ** bz - height d z = height c - a ** z =
(height c - a) / (b - height d) */
top = height * c - a;
bot = b - height * d;
if (bot == 0.0)
return 0;
z = top / bot;
/*
** Ok, no problem. ** Now we solve for x and y. We know
that w = c + d z, so we compute it. */
w = c + d * z;
/*
** Now for x and y: */
*selx = (in[0] * finalMatrix[0 * 4 + 0] +
in[1] * finalMatrix[1 * 4 + 0] +
z * finalMatrix[2 * 4 + 0] +
finalMatrix[3 * 4 + 0]) / w - OFFSETX;
*sely = (in[0] * finalMatrix[0 * 4 + 1] +
in[1] * finalMatrix[1 * 4 + 1] +
z * finalMatrix[2 * 4 + 1] +
finalMatrix[3 * 4 + 1]) / w - OFFSETY;
return 1;
}
void transformVecByModelView(float outVec[4], float inVec[4]){
float modelview[16];
glGetFloatv( GL_MODELVIEW_MATRIX, modelview );
matMultVec4f( outVec, inVec, modelview );
}
/*
=============
R_SetupGL
=============
*/
void R_SetupGL (void)
{
float screenaspect;
float yfov;
int i;
extern int glwidth, glheight;
int x, x2, y2, y, w, h;
//
// set up viewpoint
//
glMatrixMode(GL_PROJECTION);
glLoadIdentity ();
x = r_refdef.vrect.x * glwidth/vid.width;
x2 = (r_refdef.vrect.x + r_refdef.vrect.width) * glwidth/vid.width;
y = (vid.height-r_refdef.vrect.y) * glheight/vid.height;
y2 = (vid.height - (r_refdef.vrect.y + r_refdef.vrect.height)) * glheight/vid.height;
// fudge around because of frac screen scale
if (x > 0)
x--;
if (x2 < glwidth)
x2++;
if (y2 < 0)
y2--;
if (y < glheight)
y++;
w = x2 - x;
h = y - y2;
if (envmap)
{
x = y2 = 0;
w = h = 256;
}
glViewport (glx + x, gly + y2, w, h);
screenaspect = (float)r_refdef.vrect.width/r_refdef.vrect.height;
// yfov = 2*atan((float)r_refdef.vrect.height/r_refdef.vrect.width)*180/M_PI;
MYgluPerspective (r_refdef.fov_y, screenaspect, 4, 4096);
if (mirror)
{
if (mirror_plane->normal[2])
glScalef (1, -1, 1);
else
glScalef (-1, 1, 1);
glCullFace(GL_BACK);
}
else
glCullFace(GL_FRONT);
glMatrixMode(GL_MODELVIEW);
#ifdef DO_OWN_MATRIX_MATH
float mv[16];
setIdentityM(mv, 0);
rotateM(mv, -90, 1, 0, 0); // put Z going up
rotateM(mv, 90, 0, 0, 1); // put Z going up
rotateM(mv, -r_refdef.viewangles[2], 1, 0, 0);
rotateM(mv, -r_refdef.viewangles[0], 0, 1, 0);
rotateM(mv, -r_refdef.viewangles[1], 0, 0, 1);
translateM(mv, 0, -r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]);
glLoadMatrixf(mv);
memcpy(r_world_matrix, mv, sizeof(r_world_matrix));
#else
glLoadIdentity ();
glRotatef (-90, 1, 0, 0); // put Z going up
glRotatef (90, 0, 0, 1); // put Z going up
glRotatef (-r_refdef.viewangles[2], 1, 0, 0);
glRotatef (-r_refdef.viewangles[0], 0, 1, 0);
glRotatef (-r_refdef.viewangles[1], 0, 0, 1);
glTranslatef (-r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]);
#ifdef USE_OPENGLES
static qboolean initialized;
static qboolean haveGL_OES_matrix_get;
static qboolean haveGL_OES_query_matrix;
#if 0
if (! initialized) {
const char* extensions = (const char*) glGetString(GL_EXTENSIONS);
haveGL_OES_matrix_get =
strstr(extensions, "GL_OES_matrix_get") != NULL;
haveGL_OES_query_matrix =
strstr(extensions, "GL_OES_query_matrix") != NULL;
initialized = true;
}
if (haveGL_OES_query_matrix) {
GLfixed mantissa[16];
GLint exponent[16];
glQueryMatrixxOES( mantissa, exponent );
for(int i = 0; i < 16; i++) {
r_world_matrix[i] = scalbnf(mantissa[i], exponent[i]-16);
}
}
else if (haveGL_OES_matrix_get) {
glGetIntegerv (MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES,
(GLint*) r_world_matrix);
}
else
#endif
{
// No way to get the world matix, set to identity
memset(r_world_matrix, 0, sizeof(r_world_matrix));
for(i = 0; i < 16; i += 5) {
r_world_matrix[i] = 1.0f;
}
}
#else
glGetFloatv (GL_MODELVIEW_MATRIX, r_world_matrix);
#endif
#endif // DO_OWN_MATRIX_MATH
//
// set drawing parms
//
if (gl_cull.value)
glEnable(GL_CULL_FACE);
else
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
glEnable(GL_DEPTH_TEST);
}
float glaGetOneFloat(int param)
{
GLfloat v;
glGetFloatv(param, &v);
return v;
}
void C_Frustum::calculateFrustum(void)
{
float proj[16]; // This will hold our projection matrix
float modl[16]; // This will hold our modelview matrix
float clip[16]; // This will hold the clipping planes
glGetFloatv(GL_PROJECTION_MATRIX, proj);
glGetFloatv(GL_MODELVIEW_MATRIX, modl);
clip[ 0] = modl[ 0] * proj[ 0] + modl[ 1] * proj[ 4] + modl[ 2] * proj[ 8] + modl[ 3] * proj[12];
clip[ 1] = modl[ 0] * proj[ 1] + modl[ 1] * proj[ 5] + modl[ 2] * proj[ 9] + modl[ 3] * proj[13];
clip[ 2] = modl[ 0] * proj[ 2] + modl[ 1] * proj[ 6] + modl[ 2] * proj[10] + modl[ 3] * proj[14];
clip[ 3] = modl[ 0] * proj[ 3] + modl[ 1] * proj[ 7] + modl[ 2] * proj[11] + modl[ 3] * proj[15];
clip[ 4] = modl[ 4] * proj[ 0] + modl[ 5] * proj[ 4] + modl[ 6] * proj[ 8] + modl[ 7] * proj[12];
clip[ 5] = modl[ 4] * proj[ 1] + modl[ 5] * proj[ 5] + modl[ 6] * proj[ 9] + modl[ 7] * proj[13];
clip[ 6] = modl[ 4] * proj[ 2] + modl[ 5] * proj[ 6] + modl[ 6] * proj[10] + modl[ 7] * proj[14];
clip[ 7] = modl[ 4] * proj[ 3] + modl[ 5] * proj[ 7] + modl[ 6] * proj[11] + modl[ 7] * proj[15];
clip[ 8] = modl[ 8] * proj[ 0] + modl[ 9] * proj[ 4] + modl[10] * proj[ 8] + modl[11] * proj[12];
clip[ 9] = modl[ 8] * proj[ 1] + modl[ 9] * proj[ 5] + modl[10] * proj[ 9] + modl[11] * proj[13];
clip[10] = modl[ 8] * proj[ 2] + modl[ 9] * proj[ 6] + modl[10] * proj[10] + modl[11] * proj[14];
clip[11] = modl[ 8] * proj[ 3] + modl[ 9] * proj[ 7] + modl[10] * proj[11] + modl[11] * proj[15];
clip[12] = modl[12] * proj[ 0] + modl[13] * proj[ 4] + modl[14] * proj[ 8] + modl[15] * proj[12];
clip[13] = modl[12] * proj[ 1] + modl[13] * proj[ 5] + modl[14] * proj[ 9] + modl[15] * proj[13];
clip[14] = modl[12] * proj[ 2] + modl[13] * proj[ 6] + modl[14] * proj[10] + modl[15] * proj[14];
clip[15] = modl[12] * proj[ 3] + modl[13] * proj[ 7] + modl[14] * proj[11] + modl[15] * proj[15];
right->setPlane
(
clip[ 3] - clip[ 0] ,
clip[ 7] - clip[ 4] ,
clip[11] - clip[ 8] ,
clip[15] - clip[12]
);
left->setPlane
(
clip[ 3] + clip[ 0] ,
clip[ 7] + clip[ 4] ,
clip[11] + clip[ 8] ,
clip[15] + clip[12]
);
bottom->setPlane
(
clip[ 3] + clip[ 1] ,
clip[ 7] + clip[ 5] ,
clip[11] + clip[ 9] ,
clip[15] + clip[13]
);
top->setPlane
(
clip[ 3] - clip[ 1] ,
clip[ 7] - clip[ 5] ,
clip[11] - clip[ 9] ,
clip[15] - clip[13]
);
back->setPlane
(
clip[ 3] - clip[ 2] ,
clip[ 7] - clip[ 6] ,
clip[11] - clip[10] ,
clip[15] - clip[14]
);
front->setPlane
(
clip[ 3] + clip[ 2] ,
clip[ 7] + clip[ 6] ,
clip[11] + clip[10] ,
clip[15] + clip[14]
);
right->normalizePlane();
left->normalizePlane();
bottom->normalizePlane();
top->normalizePlane();
back->normalizePlane();
front->normalizePlane();
}
bool checkGLState(GLenum pname, const glm::vec4 value)
{
glm::vec4 v;
glGetFloatv(pname, reinterpret_cast<float*>(&v[0]));
return (v == value);
}
//------------------------------------------------------------------------------
// drawFunc() - draw our objects
//------------------------------------------------------------------------------
void CrsPntr::drawFunc()
{
GLfloat ocolor[4];
GLfloat lw;
glGetFloatv(GL_CURRENT_COLOR, ocolor);
glGetFloatv(GL_LINE_WIDTH, &lw);
glColor3f(1, 1, 1);
glLineWidth(2);
if (showCrsPtr) {
// this is the course pointer
glPushMatrix();
glBegin(GL_LINE_STRIP);
glVertex2f(0.044f, 0.49f);
glVertex2f(0.044f, 0.865f);
glVertex2f(0, 1.065f);
glVertex2f(-0.044f, 0.865f);
glVertex2f(-0.044f, 0.49f);
glVertex2f(0.044f, 0.49f);
glEnd();
glBegin(GL_LINE_STRIP);
glVertex2f(0, -0.6f);
glVertex2f(-0.044f, -0.676f);
glVertex2f(-0.044f, -1.1f);
glVertex2f( 0.044f, -1.1f);
glVertex2f( 0.044f, -0.676f);
glVertex2f(0, -0.6f);
glEnd();
glPopMatrix();
}
if (showCdi) {
// figure how far to translate
LCreal scale = inchesPerDot * cdiDots;
// limit ourself to the size of the scale
if (scale > 0.88) scale = 0.88f;
if (scale < -0.88) scale = -0.88f;
// cdi
glPushMatrix();
glTranslatef(static_cast<GLfloat>(scale), 0, 0);
glBegin(GL_LINE_STRIP);
glVertex2f(-0.044f, -0.45f);
glVertex2f(0.044f, -0.45f);
glVertex2f(0.044f, 0.35f);
glVertex2f(-0.044f, 0.35f);
glVertex2f(-0.044f, -0.45f);
glEnd();
glPopMatrix();
}
// our to from arrow will not be display unless we get a 1 (to) or a 0 (from)
if (showToFrom) {
if (toFrom == 1) {
glPushMatrix();
glBegin(GL_POLYGON);
glVertex2f(0, -0.6f);
glVertex2f(-0.044f, -0.475f);
glVertex2f(0.044f, -0.475f);
glEnd();
glPopMatrix();
}
if (toFrom == 0) {
glPushMatrix();
glBegin(GL_POLYGON);
glVertex2f(0, 0.475f);
glVertex2f(-0.044f, 0.37f);
glVertex2f(0.044f, 0.37f);
glEnd();
glPopMatrix();
}
}
glColor4fv(ocolor);
glLineWidth(lw);
}
// The face knows where it needs to rotate to.
// Pass the current perspective to the face and load the returned perspective rotation.
void rotateToFace(int faceNum) {
GLfloat matrix[16];
glGetFloatv(GL_MODELVIEW_MATRIX, matrix);
face[faceNum]->rotateToSelf(matrix);
glLoadMatrixf(matrix);
}
void CGlobalRendering::PostInit() {
supportNPOTs = GLEW_ARB_texture_non_power_of_two;
haveARB = GLEW_ARB_vertex_program && GLEW_ARB_fragment_program;
haveGLSL = (glGetString(GL_SHADING_LANGUAGE_VERSION) != NULL);
haveGLSL &= GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader;
haveGLSL &= !!GLEW_VERSION_2_0; // we want OpenGL 2.0 core functions
{
const char* glVendor = (const char*) glGetString(GL_VENDOR);
const char* glRenderer = (const char*) glGetString(GL_RENDERER);
const std::string vendor = (glVendor != NULL)? StringToLower(std::string(glVendor)): "";
const std::string renderer = (glRenderer != NULL)? StringToLower(std::string(glRenderer)): "";
haveATI = (vendor.find("ati ") != std::string::npos) || (vendor.find("amd ") != std::string::npos);
haveMesa = (renderer.find("mesa ") != std::string::npos) || (renderer.find("gallium ") != std::string::npos);
haveIntel = (vendor.find("intel") != std::string::npos);
haveNvidia = (vendor.find("nvidia ") != std::string::npos);
//FIXME Neither Intel's nor Mesa's GLSL implementation seem to be in a workable state atm (date: Nov. 2011)
haveGLSL &= !haveIntel;
haveGLSL &= !haveMesa;
//FIXME add an user config to force enable it!
if (haveATI) {
// x-series doesn't support NPOTs (but hd-series does)
supportNPOTs = (renderer.find(" x") == std::string::npos && renderer.find(" 9") == std::string::npos);
}
}
// use some ATI bugfixes?
const int atiHacksCfg = configHandler->GetInt("AtiHacks");
atiHacks = haveATI && (atiHacksCfg < 0); // runtime detect
atiHacks |= (atiHacksCfg > 0); // user override
// Runtime compress textures?
if (GLEW_ARB_texture_compression) {
// we don't even need to check it, 'cos groundtextures must have that extension
// default to off because it reduces quality (smallest mipmap level is bigger)
compressTextures = configHandler->GetBool("CompressTextures");
}
#ifdef GLEW_NV_primitive_restart
supportRestartPrimitive = !!(GLEW_NV_primitive_restart);
#endif
// maximum 2D texture size
{
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
}
// retrieve maximu smoothed PointSize
float2 aliasedPointSizeRange, smoothPointSizeRange;
glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*)&aliasedPointSizeRange);
glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, (GLfloat*)&smoothPointSizeRange);
maxSmoothPointSize = std::min(aliasedPointSizeRange.y, smoothPointSizeRange.y);
// some GLSL relevant information
{
glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &glslMaxUniformBufferBindings);
glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &glslMaxUniformBufferSize);
glGetIntegerv(GL_MAX_VARYING_FLOATS, &glslMaxVaryings);
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &glslMaxAttributes);
glGetIntegerv(GL_MAX_DRAW_BUFFERS, &glslMaxDrawBuffers);
glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &glslMaxRecommendedIndices);
glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &glslMaxRecommendedVertices);
glslMaxVaryings /= 4; // GL_MAX_VARYING_FLOATS returns max individual floats, we want float4
}
// detect if GL_DEPTH_COMPONENT24 is supported (many ATIs don't do so)
{
// ATI seems to support GL_DEPTH_COMPONENT24 for static textures, but you can't render to them
/*
GLint state = 0;
glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, 16, 16, 0, GL_LUMINANCE, GL_FLOAT, NULL);
glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &state);
support24bitDepthBuffers = (state > 0);
*/
support24bitDepthBuffers = false;
if (FBO::IsSupported() && !atiHacks) {
const int fboSizeX = 16, fboSizeY = 16;
FBO fbo;
fbo.Bind();
fbo.CreateRenderBuffer(GL_COLOR_ATTACHMENT0_EXT, GL_RGBA8, fboSizeX, fboSizeY);
fbo.CreateRenderBuffer(GL_DEPTH_ATTACHMENT_EXT, GL_DEPTH_COMPONENT24, fboSizeX, fboSizeY);
const GLenum status = fbo.GetStatus();
fbo.Unbind();
support24bitDepthBuffers = (status == GL_FRAMEBUFFER_COMPLETE_EXT);
}
}
// print info
LOG(
"GL info:\n"
"\thaveARB: %i, haveGLSL: %i, ATI hacks: %i\n"
"\tFBO support: %i, NPOT-texture support: %i, 24bit Z-buffer support: %i\n"
"\tmaximum texture size: %i, compress MIP-map textures: %i\n"
"\tmaximum SmoothPointSize: %0.0f, maximum vec4 varying/attributes: %i/%i\n"
"\tmaximum drawbuffers: %i, maximum recommended indices/vertices: %i/%i\n"
"\tnumber of UniformBufferBindings: %i (%ikB)",
haveARB, haveGLSL, atiHacks,
FBO::IsSupported(), supportNPOTs, support24bitDepthBuffers,
maxTextureSize, compressTextures, maxSmoothPointSize,
glslMaxVaryings, glslMaxAttributes, glslMaxDrawBuffers,
glslMaxRecommendedIndices, glslMaxRecommendedVertices,
glslMaxUniformBufferBindings, glslMaxUniformBufferSize / 1024
);
teamNanospray = configHandler->GetBool("TeamNanoSpray");
}
int main(int argc, char *argv[])
{
SDL_Surface *screen;
if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) {
printf("Unable to initialize SDL: %s\n", SDL_GetError());
return 1;
}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
screen = SDL_SetVideoMode( 640, 480, 24, SDL_OPENGL );
if ( !screen ) {
printf("Unable to set video mode: %s\n", SDL_GetError());
return 1;
}
glClearColor( 0, 0, 0, 0 );
glClear( GL_COLOR_BUFFER_BIT );
glGenVertexArrays_ = (PFNGLGENVERTEXARRAYSPROC) SDL_GL_GetProcAddress("glGenVertexArrays");
assert(glGenVertexArrays_);
glBindVertexArray_ = (PFNGLBINDVERTEXARRAYPROC) SDL_GL_GetProcAddress("glBindVertexArray");
assert(glBindVertexArray_);
glDeleteVertexArrays_ = (PFNGLDELETEVERTEXARRAYSPROC) SDL_GL_GetProcAddress("glDeleteVertexArrays");
assert(glDeleteVertexArrays_);
glEnableClientState(GL_TEXTURE_COORD_ARRAY); // enabling it *before* the vao does nothing, the vao should wipe it out!
// Generate a VAO
GLuint vao;
glGenVertexArrays_(1, &vao);
glBindVertexArray_(vao);
// Create a texture
GLuint texture;
glGenTextures( 1, &texture );
glBindTexture( GL_TEXTURE_2D, texture );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
GLubyte textureData[16*16*4];
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
*((int*)&textureData[(x*16 + y) * 4]) = x*16 + ((y*16) << 8);
}
}
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0,
GL_RGBA, GL_UNSIGNED_BYTE, textureData );
// Create a second texture
GLuint texture2;
glGenTextures( 1, &texture2 );
glBindTexture( GL_TEXTURE_2D, texture2 );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
GLubyte texture2Data[] = { 0xff, 0, 0, 0xff,
0, 0xff, 0, 0xaa,
0, 0, 0xff, 0x55,
0x80, 0x90, 0x70, 0 };
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0,
GL_RGBA, GL_UNSIGNED_BYTE, texture2Data );
// BEGIN
#if USE_GLEW
glewInit();
#endif
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// original: glFrustum(-0.6435469817188064, 0.6435469817188064 ,-0.48266022190470925, 0.48266022190470925 ,0.5400000214576721, 2048);
//glFrustum(-0.6435469817188064, 0.1435469817188064 ,-0.48266022190470925, 0.88266022190470925 ,0.5400000214576721, 2048);
GLfloat pm[] = { 1.372136116027832, 0, 0, 0, 0, 0.7910231351852417, 0, 0, -0.6352481842041016, 0.29297152161598206, -1.0005275011062622, -1, 0, 0, -1.080284833908081, 0 };
glLoadMatrixf(pm);
glMatrixMode(GL_MODELVIEW);
GLfloat matrixData[] = { -1, 0, 0, 0,
0, 0,-1, 0,
0, 1, 0, 0,
0, 0, 0, 1 };
glLoadMatrixf(matrixData);
//glTranslated(-512,-512,-527); // XXX this should be uncommented, but if it is then nothing is shown
// glEnable(GL_CULL_FACE);
// glEnable(GL_DEPTH_TEST);
//glClear(GL_DEPTH_BUFFER_BIT);
// glEnableClientState(GL_NORMAL_ARRAY);
// glEnableClientState(GL_COLOR_ARRAY);
glActiveTexture(GL_TEXTURE0);
glEnableClientState(GL_VERTEX_ARRAY);
GLuint arrayBuffer, elementBuffer;
glGenBuffers(1, &arrayBuffer);
glGenBuffers(1, &elementBuffer);
GLubyte arrayData[] = {
/*
[0, 0, 0, 67] ==> 128 float
[0, 0, 128, 67] ==> 256 float
[0, 0, 0, 68] ==> 512 float
[0, 0, 128, 68] ==> 1024 float
[vertex x ] [vertex y ] [vertex z ] [nr] [texture u ] [texture v ] [lm u ] [lm v ] [color r,g,b,a ] */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 0
0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 1
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 2
0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 3
0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 4
0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 5
0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 6
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 7
0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 8
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 9
0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 10
0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 11
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 12
0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 13
0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 14
0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 15
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128,
0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128
};
assert(sizeof(arrayData) == 1408);
glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(arrayData), arrayData, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
GLushort elementData[] = { 1, 2, 0, 2, 3, 0, 5, 6, 4, 6, 7, 4, 9, 10, 8, 10, 11, 8, 13, 14, 12, 14, 15, 12 };
assert(sizeof(elementData) == 48);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elementData), elementData, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
// sauer vertex data is apparently 0-12: V3F, 12: N1B, 16-24: T2F, 24-28: T2S, 28-32: C4B
glVertexPointer(3, GL_FLOAT, 32, (void*)0); // all these apply to the ARRAY_BUFFER that is bound
glTexCoordPointer(2, GL_FLOAT, 32, (void*)16);
// glClientActiveTexture(GL_TEXTURE1); // XXX seems to be ignored in native build
// glTexCoordPointer(2, GL_SHORT, 32, (void*)24);
// glClientActiveTexture(GL_TEXTURE0); // likely not needed, it is a cleanup
// glNormalPointer(GL_BYTE, 32, (void*)12);
// glColorPointer(4, GL_UNSIGNED_BYTE, 32, (void*)28);
glBindTexture(GL_TEXTURE_2D, texture); // diffuse?
glActiveTexture(GL_TEXTURE0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture2); // lightmap?
glActiveTexture(GL_TEXTURE0);
GLint ok;
const char *vertexShader = "uniform mat4 u_modelView;\n"
"uniform mat4 u_projection;\n"
"varying vec4 v_texCoord0;\n"
"void main(void)\n"
"{\n" // (gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex)
// (u_projection * u_modelView * a_position)
" gl_Position = (u_projection * u_modelView * gl_Vertex) + vec4(200, 0, 0, 0);\n"
" v_texCoord0.xy = gl_MultiTexCoord0.xy/20.0;\n" // added /100 here
"}\n";
const char *fragmentShader = "uniform sampler2D diffusemap;\n"
"varying vec4 v_texCoord0;\n"
"void main(void)\n"
"{\n"
" vec4 diffuse = texture2D(diffusemap, v_texCoord0.xy);\n"
" gl_FragColor = diffuse;\n"
"}\n";
GLuint vs = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vs, 1, &vertexShader, NULL);
glCompileShader(vs);
glGetShaderiv(vs, GL_COMPILE_STATUS, &ok);
if (!ok) {
printf("Shader compilation error with vertex\n");
GLint infoLen = 0;
glGetShaderiv (vs, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen > 1)
{
char* infoLog = (char *)malloc(sizeof(char) * infoLen+1);
glGetShaderInfoLog(vs, infoLen, NULL, infoLog);
printf("Error compiling shader:\n%s\n", infoLog);
}
}
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fs, 1, &fragmentShader, NULL);
glCompileShader(fs);
glGetShaderiv(fs, GL_COMPILE_STATUS, &ok);
if (!ok) {
printf("Shader compilation error with fragment\n");
GLint infoLen = 0;
glGetShaderiv (vs, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen > 1)
{
char* infoLog = (char *)malloc(sizeof(char) * infoLen+1);
glGetShaderInfoLog(vs, infoLen, NULL, infoLog);
printf("Error compiling shader:\n%s\n", infoLog);
}
}
GLuint program = glCreateProgram();
glAttachShader(program, vs);
glAttachShader(program, fs);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &ok);
assert(ok);
glUseProgram(program);
//GLint lightmapLocation = glGetUniformLocation(program, "lightmap");
//assert(lightmapLocation >= 0);
//glUniform1i(lightmapLocation, 1); // sampler2D? Is it the texture unit?
GLint diffusemapLocation = glGetUniformLocation(program, "diffusemap");
assert(diffusemapLocation >= 0);
glUniform1i(diffusemapLocation, 0);
//GLint texgenscrollLocation = glGetUniformLocation(program, "texgenscroll");
//assert(texgenscrollLocation >= 0);
//GLint colorparamsLocation = glGetUniformLocation(program, "colorparams");
//assert(colorparamsLocation >= 0);
//GLfloat texgenscrollData[] = { 0, 0, 0, 0 };
//glUniform4fv(texgenscrollLocation, 1, texgenscrollData);
//GLfloat colorparamsData[] = { 2, 2, 2, 1 };
//glUniform4fv(colorparamsLocation, 1, colorparamsData);
{
GLfloat data[16];
glGetFloatv(GL_MODELVIEW_MATRIX, data);
printf("Modelview: ");
for (int i = 0; i < 16; i++) printf("%.3f, ", data[i]);
printf("\n");
//memset(data, 0, 16*4);
GLint modelViewLocation = glGetUniformLocation(program, "u_modelView");
assert(modelViewLocation >= 0);
glUniformMatrix4fv(modelViewLocation, 1, GL_FALSE, data);
}
{
GLfloat data[16];
glGetFloatv(GL_PROJECTION_MATRIX, data);
printf("Projection: ");
for (int i = 0; i < 16; i++) printf("%.3f, ", data[i]);
printf("\n");
//memset(data, 0, 16*4);
GLint projectionLocation = glGetUniformLocation(program, "u_projection");
assert(projectionLocation >= 0);
glUniformMatrix4fv(projectionLocation, 1, GL_FALSE, data);
}
/*
glBindAttribLocation(program, 0, "a_position");
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 32, (void*)0);
glEnableVertexAttribArray(0);
glBindAttribLocation(program, 1, "v_texCoord0");
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 32, (void*)16);
glEnableVertexAttribArray(1);
*/
// stop recording in the VAO
glBindVertexArray_(0);
// unbind all the stuff the VAO would save for us, so this is a valid test
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
// draw with VAO
glBindVertexArray_(vao);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)12);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*) 0);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)24);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)36);
// END
SDL_GL_SwapBuffers();
#if !EMSCRIPTEN
SDL_Delay(1500);
#endif
// SDL_Quit();
return 0;
}
/**
* @brief Loads a surface into an opengl texture.
*
* @param surface Surface to load into a texture.
* @param flags Flags to use.
* @param[out] rw Real width of the texture.
* @param[out] rh Real height of the texture.
* @return The opengl texture id.
*/
static GLuint gl_loadSurface( SDL_Surface* surface, int *rw, int *rh, unsigned int flags, int freesur )
{
GLuint texture;
GLfloat param;
/* Prepare the surface. */
surface = gl_prepareSurface( surface );
if (rw != NULL)
(*rw) = surface->w;
if (rh != NULL)
(*rh) = surface->h;
/* opengl texture binding */
glGenTextures( 1, &texture ); /* Creates the texture */
glBindTexture( GL_TEXTURE_2D, texture ); /* Loads the texture */
/* Filtering, LINEAR is better for scaling, nearest looks nicer, LINEAR
* also seems to create a bit of artifacts around the edges */
if ((gl_screen.scale != 1.) || (flags & OPENGL_TEX_MIPMAPS)) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
/* Always wrap just in case. */
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
/* now lead the texture data up */
SDL_LockSurface( surface );
if (gl_texHasCompress()) {
glTexImage2D( GL_TEXTURE_2D, 0, surface->format->BytesPerPixel,
surface->w, surface->h, 0, GL_COMPRESSED_RGBA,
GL_UNSIGNED_BYTE, surface->pixels );
}
else {
glTexImage2D( GL_TEXTURE_2D, 0, surface->format->BytesPerPixel,
surface->w, surface->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surface->pixels );
}
SDL_UnlockSurface( surface );
/* Create mipmaps. */
if ((flags & OPENGL_TEX_MIPMAPS) && gl_texHasMipmaps()) {
/* Do fancy stuff. */
if (gl_hasExt("GL_EXT_texture_filter_anisotropic")) {
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, ¶m);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, param);
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 9);
/* Now generate the mipmaps. */
nglGenerateMipmap(GL_TEXTURE_2D);
}
/* cleanup */
if (freesur)
SDL_FreeSurface( surface );
gl_checkErr();
return texture;
}
PsychError SCREENDrawDots(void)
{
PsychWindowRecordType *windowRecord;
int whiteValue, m,n,p,mc,nc,pc,idot_type;
int i, nrpoints, nrsize;
boolean isArgThere, usecolorvector, isdoublecolors, isuint8colors;
double *xy, *size, *center, *dot_type, *colors;
unsigned char *bytecolors;
GLfloat pointsizerange[2];
double convfactor;
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
// Check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(6)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs
// Get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord);
// Query, allocate and copy in all vectors...
nrpoints = 2;
nrsize = 0;
colors = NULL;
bytecolors = NULL;
PsychPrepareRenderBatch(windowRecord, 2, &nrpoints, &xy, 4, &nc, &mc, &colors, &bytecolors, 3, &nrsize, &size);
isdoublecolors = (colors) ? TRUE:FALSE;
isuint8colors = (bytecolors) ? TRUE:FALSE;
usecolorvector = (nc>1) ? TRUE:FALSE;
// Get center argument
isArgThere = PsychIsArgPresent(PsychArgIn, 5);
if(!isArgThere){
center = (double *) PsychMallocTemp(2 * sizeof(double));
center[0] = 0;
center[1] = 0;
} else {
PsychAllocInDoubleMatArg(5, TRUE, &m, &n, &p, ¢er);
if(p!=1 || n!=2 || m!=1) PsychErrorExitMsg(PsychError_user, "center must be a 1-by-2 vector");
}
// Get dot_type argument
isArgThere = PsychIsArgPresent(PsychArgIn, 6);
if(!isArgThere){
idot_type = 0;
} else {
PsychAllocInDoubleMatArg(6, TRUE, &m, &n, &p, &dot_type);
if(p!=1 || n!=1 || m!=1 || (dot_type[0]<0 || dot_type[0]>2))
PsychErrorExitMsg(PsychError_user, "dot_type must be 0, 1 or 2");
idot_type = (int) dot_type[0];
}
// Child-protection: Alpha blending needs to be enabled for smoothing to work:
// Ok, not such a good idea :-( The flag also enables drawing of round dots and
// there are applications were we want to set the flag without using alpha blending...
// Therefore disabled -> May want to turn this into some kind of warning or hint in the future...
if (idot_type>0 && windowRecord->actualEnableBlending!=TRUE) {
//PsychErrorExitMsg(PsychError_user, "Point smoothing doesn't work with alpha-blending disabled! See Screen('BlendFunction') on how to enable it.");
}
// Turn on antialiasing to draw circles
if(idot_type) {
glEnable(GL_POINT_SMOOTH);
glGetFloatv(GL_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
// A dot type of 2 requests for highest quality point smoothing:
glHint(GL_POINT_SMOOTH_HINT, (idot_type>1) ? GL_NICEST : GL_DONT_CARE);
}
else {
#ifndef GL_ALIASED_POINT_SIZE_RANGE
#define GL_ALIASED_POINT_SIZE_RANGE 0x846D
#endif
glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
}
// Set size of a single dot:
if (size[0] > pointsizerange[1] || size[0] < pointsizerange[0]) {
printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n",
size[0], pointsizerange[0], pointsizerange[1]);
PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots').");
}
// Setup initial common point size for all points:
glPointSize(size[0]);
// Setup modelview matrix to perform translation by 'center':
glMatrixMode(GL_MODELVIEW);
// Make a backup copy of the matrix:
glPushMatrix();
// Apply a global translation of (center(x,y)) pixels to all following points:
glTranslated(center[0], center[1], 0);
// Render the array of 2D-Points - Efficient version:
// This command sequence allows fast processing of whole arrays
// of vertices (or points, in this case). It saves the call overhead
// associated with the original implementation below and is potentially
// optimized in specific OpenGL implementations.
// Pass a pointer to the start of the point-coordinate array:
glVertexPointer(2, GL_DOUBLE, 0, &xy[0]);
// Enable fast rendering of arrays:
glEnableClientState(GL_VERTEX_ARRAY);
if (usecolorvector) {
PsychSetupVertexColorArrays(windowRecord, TRUE, mc, colors, bytecolors);
}
// Render all n points, starting at point 0, render them as POINTS:
if (nrsize==1) {
// One common point size for all dots provided. Good! This is very efficiently
// done with one single render-call:
glDrawArrays(GL_POINTS, 0, nrpoints);
}
else {
// Different size for each dot provided: We have to do One GL - call per dot.
// This is *pretty inefficient* and should be reimplemented in the future via
// Point-Sprite extensions, cleverly used display lists or via vertex-shaders...
// For now we do it the stupid way:
for (i=0; i<nrpoints; i++) {
if (size[i] > pointsizerange[1] || size[i] < pointsizerange[0]) {
printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n",
size[i], pointsizerange[0], pointsizerange[1]);
PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots').");
}
// Setup point size for this point:
glPointSize(size[i]);
// Render point:
glDrawArrays(GL_POINTS, i, 1);
}
}
// Disable fast rendering of arrays:
glDisableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_DOUBLE, 0, NULL);
if (usecolorvector) PsychSetupVertexColorArrays(windowRecord, FALSE, 0, NULL, NULL);
// Restore old matrix from backup copy, undoing the global translation:
glPopMatrix();
// turn off antialiasing again
if(idot_type) glDisable(GL_POINT_SMOOTH);
// Reset pointsize to 1.0
glPointSize(1);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
//All psychfunctions require this.
return(PsychError_none);
}
/*
** GL_SetDefaultState
*/
void GL_SetDefaultState( void )
{
glClearDepth( 1.0f );
glCullFace( GL_FRONT );
glColor4f( 1, 1, 1, 1 );
// initialize downstream texture unit if we're running
// in a multitexture environment
if ( GLEW_ARB_multitexture )
{
GL_SelectTexture( 1 );
GL_TextureMode( r_textureMode->string );
GL_TextureAnisotropy( r_textureAnisotropy->value );
GL_TexEnv( GL_MODULATE );
glDisable( GL_TEXTURE_2D );
GL_SelectTexture( 0 );
}
glEnable( GL_TEXTURE_2D );
GL_TextureMode( r_textureMode->string );
GL_TextureAnisotropy( r_textureAnisotropy->value );
GL_TexEnv( GL_MODULATE );
glShadeModel( GL_SMOOTH );
glDepthFunc( GL_LEQUAL );
// the vertex array is always enabled, but the color and texture
// arrays are enabled and disabled around the compiled vertex array call
glEnableClientState( GL_VERTEX_ARRAY );
//
// make sure our GL state vector is set correctly
//
glState.glStateBits = GLS_DEPTHTEST_DISABLE | GLS_DEPTHMASK_TRUE;
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
glDepthMask( GL_TRUE );
glDisable( GL_DEPTH_TEST );
glEnable( GL_SCISSOR_TEST );
glDisable( GL_CULL_FACE );
glDisable( GL_BLEND );
//----(SA) added.
#if 0
// ATI pn_triangles
if ( GLEW_ATI_pn_triangles )
{
int maxtess;
// get max supported tesselation
glGetIntegerv( GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI, ( GLint * ) &maxtess );
#ifdef __MACOS__
glConfig.ATIMaxTruformTess = 7;
#else
glConfig.ATIMaxTruformTess = maxtess;
#endif
// cap if necessary
if ( r_ati_truform_tess->value > maxtess )
{
ri.Cvar_Set( "r_ati_truform_tess", va( "%d", maxtess ) );
}
// set Wolf defaults
glPNTrianglesfATI( GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI, r_ati_truform_tess->value );
}
#endif
if ( glConfig.anisotropicAvailable )
{
float maxAnisotropy;
glGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy );
glConfig.maxAnisotropy = maxAnisotropy;
// set when rendering
// glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, glConfig.maxAnisotropy);
}
//----(SA) end
}
void OnInit()
{
GL_CHECK_ERRORS
//generate the checker texture
GLubyte data[128][128]={0};
for(int j=0;j<128;j++) {
for(int i=0;i<128;i++) {
data[i][j]=(i<=64 && j<=64 || i>64 && j>64 )?255:0;
}
}
//generate texture object
glGenTextures(1, &checkerTextureID);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, checkerTextureID);
//set texture parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
GL_CHECK_ERRORS
//set maximum aniostropy setting
GLfloat largest_supported_anisotropy;
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &largest_supported_anisotropy);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, largest_supported_anisotropy);
//set mipmap base and max level
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4);
//allocate texture object
glTexImage2D(GL_TEXTURE_2D,0,GL_RED, 128, 128, 0, GL_RED, GL_UNSIGNED_BYTE, data);
//generate mipmaps
glGenerateMipmap(GL_TEXTURE_2D);
GL_CHECK_ERRORS
//create a textured plane object
checker_plane = new Graphics::CTexturedPlane();
GL_CHECK_ERRORS
//setup camera
//setup the camera position and look direction
Vector3 p = Vector3(5, 5, 5);
cam.SetPosition(p);
Vector3 look(p);
look.normalize();
//rotate the camera for proper orientation
float yaw = glm::degrees(float(atan2(look.z, look.x)+Math::M_PI));
float pitch = glm::degrees(asin(look.y));
rX = yaw;
rY = pitch;
cam.Rotate(rX,rY,0);
std::cout << "initialization completed" << std::endl;
}
void OpenGLRender::blitText(IND_Font *pFo,
char *pText,
int pX,
int pY,
int pOffset,
int pLineSpacing,
float pScaleX,
float pScaleY,
BYTE pR,
BYTE pG,
BYTE pB,
BYTE pA,
BYTE pFadeR,
BYTE pFadeG,
BYTE pFadeB,
BYTE pFadeA,
IND_Filter pLinearFilter,
IND_BlendingType pSo,
IND_BlendingType pDs,
IND_Align pAlign) {
// ----- Transform -----
bool correctParams = true;
if(!pFo->getSurface()) {
correctParams = false;
}
if (correctParams) {
setTransform2d(pX, pY, 0, 0, 0, pScaleX, pScaleY, 0, 0, 0, 0, pFo->getSurface()->getWidthBlock(), pFo->getSurface()->getHeightBlock(), 0);
setRainbow2d(pFo->_font._surface->getTypeInt(), 1, 0, 0, pLinearFilter, pR, pG, pB, pA, pFadeR, pFadeG, pFadeB, pFadeA, pSo, pDs);
// ----- Drawing text -----
BYTE mChar1;
BYTE mChar2;
int mCont1 = 0;
int mCont2 = 0;
int mTranslationX = 0;
int mTranslationY = 0;
bool mErrorChar; // Char that doesn't exist
int mSentencePos;
int mLongActualSentence;
GLfloat mLineTransform[16]; //Maintains a transform inside the entity coord system
GLfloat mEntityTransform[16]; //Maintains transform for the whole entity coord system
mCont1 = 0;
mChar1 = pText [mCont1++];
//Store entity transform
glGetFloatv(GL_MODELVIEW_MATRIX,mEntityTransform);
//LOOP - Blit character by character
while (mChar1 != 0) {
// If it's a new line or it's the first line
if (mChar1 == '\n' || mCont1 == 1) {
// First line
if (mCont1 == 1) {
mSentencePos = 0;
//Any other line
} else {
mSentencePos = mCont1;
}
// Set the alignment
switch (pAlign) {
case IND_CENTER: {
mLongActualSentence = static_cast<int>(getLongInPixels(pFo, pText, mSentencePos, pOffset) * pScaleX);
mTranslationX = (int)(mLongActualSentence / 2);
break;
}
case IND_RIGHT: {
mLongActualSentence = static_cast<int>(getLongInPixels(pFo, pText, mSentencePos, pOffset) * pScaleX);
mTranslationX = (int)(mLongActualSentence);
break;
}
case IND_LEFT: {
break;
}
}
//Load line transform matrix taking into account entity transform
//This effectively resets transform to first character in the new line
IND_Matrix transform;
_math.matrix4DSetTranslation(transform, static_cast<float>(-mTranslationX), static_cast<float>(mTranslationY), 0.0f);
transform.arrayRepresentation(mLineTransform);
glLoadMatrixf(mEntityTransform);
glMultMatrixf(mLineTransform);
mTranslationY += static_cast<int>((pLineSpacing * pScaleY));
} //Was first new line or first line
// It's a normal character
if (mChar1 != '\n') {
mErrorChar = 0;
mCont2 = 0;
mChar2 = pFo->getLetters() [mCont2++]._letter;
// Seek its location in the bitmap
while (mChar2 != mChar1 && mCont2 < pFo->getNumChars()) {
mChar2 = pFo->getLetters() [mCont2++]._letter;
}
if (mCont2 == pFo->getNumChars())
mErrorChar = 1;
mCont2--;
if (!mErrorChar) {
//#warning lookout
//mvTransformPresetState(); //Need to preset transform state, as the blit operation will reset the state!!!!
blitRegionSurface(pFo->getSurface(),
pFo->getLetters() [mCont2]._offsetX + 1,
pFo->getLetters() [mCont2]._offsetY + 1,
pFo->getLetters() [mCont2]._widthChar - 1,
pFo->getLetters() [mCont2]._heightChar - 1);
}
//Displacement of the character.
//Displacement transform accumulates for every character in the line
float charTranslateX = ((pFo->getLetters() [mCont2]._widthChar) + pOffset) * pScaleX;
glTranslatef(charTranslateX,0.0f,0.0f);
}//Was normal character
// Advance one character
mChar1 = pText [mCont1++];
}//LOOP END - Blit character by character
}
}
void LoadingObject::Draw()
{
// Enable depth testing if flag is set
if(_depth)
{
glEnable(GL_DEPTH_TEST);
glAlphaFunc (GL_GREATER, 0.1f);
glEnable (GL_ALPHA_TEST);
}
else
glDisable(GL_DEPTH_TEST);
float zoom = _sx/2;
float width = _sy;
glLoadIdentity();
glTranslatef(0.0f, 0.0f, 0.0f);
glRotatef(_rotX, 1, 0, 0);
glRotatef(_rotY, 0, 1, 0);
glRotatef(_rotZ, 0, 0, 1);
float z = -4;
glPushMatrix(); //push the matrix so that our translations only affect
{
glTranslatef(_x, _y, z); //translate the tile to where it should belong
glColor4f(_color->r,_color->g,_color->b,_color->a);
glPointSize(1);
//glColor3f(0.0,1.0,1.0);
glBegin(GL_LINES);
{
int num_segments = 200;
for(int r = 10; r < 20; r++)
for(int ii = 0; ii < num_segments; ii++)
{
bool found = false;
if (_counter > 490)
{
_counter = 0;
rot++;
if (_open)
_smax++;
else
_smax--;
if (_smax == 51)
_open = false;
else if (_smax == 0)
_open = true;
}
else
{
_counter++;
}
for (uint8 splint = 0; splint < _smax; splint++)
{
if (ii == 00+splint ||
ii == 50+splint ||
ii == 100+splint ||
ii == 150+splint)
{
found = true;
break;
}
}
if (found)
continue;
float theta = rot *2.0f * 3.1415926f * float(ii) / float(num_segments); //get the current angle
float x = ((float)r/100) * cosf(theta); //calculate the x component
float y = ((float)r/100) * sinf(theta); //calculate the y component
glVertex2f(x + _x, y + _y); //output vertex
}
}
glEnd();
}
glGetFloatv (GL_MODELVIEW_MATRIX, _matrix);
glPopMatrix(); //pop the matrix
/* glEnable(GL_TEXTURE_2D);
{
glEnable(GL_BLEND);
{
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBindTexture(GL_TEXTURE_2D, _texture); //get the texture for the actual quad
glPushMatrix(); //push the matrix so that our translations only affect
{
glTranslatef(_x, _y, z); //translate the tile to where it should belong
glColor4f(_Colr,_Colg,_Colb,_Cola);
glBegin(GL_QUADS); //begin drawing our quads
{
glTexCoord2d(0.0, 1.0);
glVertex2d((-1.0) * width, 1.0);
glTexCoord2d(1.0, 1.0);
glVertex2d((1.0) * width, 1.0);
glTexCoord2d(1.0, 0.0);
glVertex2d((1.0) * width, 0.9);
glTexCoord2d(0.0, 0.0);
glVertex2d((-1.0) * width, 0.9);
}
glEnd();
}
glGetFloatv (GL_MODELVIEW_MATRIX, _matrix);
glPopMatrix(); //pop the matrix
glPushMatrix(); //push the matrix so that our translations only affect
{
glTranslatef(_x, _y, z);
glColor4f(1,1,1,1);
glBegin(GL_QUADS); //begin drawing our quads
{
float width = 3;
//TOP
glTexCoord2d(0.0, 1.0); glVertex2d(-1.0*width, 1.0);
glTexCoord2d(1.0, 1.0); glVertex2d(1.0*width, 1.0);
glTexCoord2d(1.0, 0.0); glVertex2d(1.0*width, 0.99);
glTexCoord2d(0.0, 0.0); glVertex2d(-1.0*width, 0.99);
//Bottom
glTexCoord2d(0.0, 1.0); glVertex2d(-1.0*width, 0.89);
glTexCoord2d(1.0, 1.0); glVertex2d(1.0*width, 0.89);
glTexCoord2d(1.0, 0.0); glVertex2d(1.0*width, 0.88);
glTexCoord2d(0.0, 0.0); glVertex2d(-1.0*width, 0.88);
//Left
glTexCoord2d(0.0, 1.0); glVertex2d(-1.0*width, 0.99);
glTexCoord2d(1.0, 1.0); glVertex2d(-0.99*width, 0.99);
glTexCoord2d(1.0, 0.0); glVertex2d(-0.99*width, 0.88);
glTexCoord2d(0.0, 0.0); glVertex2d(-1.0*width, 0.88);
//Right
glTexCoord2d(0.0, 1.0); glVertex2d(1.0*width, 0.99);
glTexCoord2d(1.0, 1.0); glVertex2d(0.99*width, 0.99);
glTexCoord2d(1.0, 0.0); glVertex2d(0.99*width, 0.88);
glTexCoord2d(0.0, 0.0); glVertex2d(1.0*width, 0.88);
}
glEnd();
}
glPopMatrix(); //pop the matrix
}
glDisable(GL_BLEND);
}
glDisable(GL_TEXTURE_2D);*/
if(_depth)
{
glDisable (GL_ALPHA_TEST) ;
glDisable(GL_DEPTH_TEST);
}
}
bool checkGLState(GLenum pname, GLfloat value)
{
GLfloat f;
glGetFloatv(pname, &f);
return (f == value);
}
void SGCanvasMouseHandler::OnMouse(wxMouseEvent& event)
{
vec3 cursor = canvas->GetWorldSpace(event.GetX(), event.GetY());
if (event.LeftDown())
{
if (!event.ControlDown())
{
Stop();
}
vStart = cursor;
memcpy((float*) &mStart, (float*) &xform, sizeof(xform));
startZoom = canvas->GetZoom();
vPrev = cursor;
validStart = true;
}
else if (event.LeftUp() && validStart)
{
float theta = 180 * vInc.magnitude();
if (theta < -InertiaThreshold || theta > InertiaThreshold)
{
inertiaAxis = cross(vStart, cursor);
if (inertiaAxis.magnitude())
{
inertiaAxis.unitize();
inertiaTheta = theta;
}
}
else if (!event.ControlDown())
{
Stop();
}
validStart = false;
}
else if (event.Moving() && event.LeftIsDown())
{
if (!validStart)
{
vInc = vec3(0.0f, 0.0f, 0.0f);
}
else
{
if (event.ControlDown())
{
float delta = cursor.y - vStart.y;
if (delta)
{
canvas->SetZoom(startZoom + delta);
canvas->Update();
}
}
else
{
float theta = 180 * (cursor - vStart).magnitude();
if (theta)
{
vec3 axis = cross(vStart, cursor);
axis.unitize();
glLoadIdentity();
glRotatef(-theta, axis.x, axis.y, axis.z);
glMultMatrixf((float*) &mStart);
glGetFloatv(GL_MODELVIEW_MATRIX, (float*) &xform);
canvas->Update();
}
}
vInc = cursor - vPrev;
}
vPrev = cursor;
}
// Right mouse button zooms.
else if (event.RightDown())
{
vStart = cursor;
startZoom = canvas->GetZoom();
validStart = true;
}
else if (event.RightUp() && validStart)
{
validStart = false;
}
else if (event.Moving() && event.RightIsDown())
{
if (validStart)
{
float delta = cursor.y - vStart.y;
if (delta)
{
canvas->SetZoom(startZoom + delta);
canvas->Update();
}
}
}
event.Skip();
}
void Example::render()
{
float modelviewMatrix[16];
float projectionMatrix[16];
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(m_CamX, m_CamY, m_CamZ, 0.0, 0.0, 0.0f, 0.0f, 1.0f, 0.0f);
glRotatef(m_rotationAngle, 0, 1, 0);
glGetFloatv(GL_MODELVIEW_MATRIX, modelviewMatrix);
glGetFloatv(GL_PROJECTION_MATRIX, projectionMatrix);
m_GLSLProgram->sendUniform4x4("projection_matrix", projectionMatrix);
vector<float> normalMatrix = calculateNormalMatrix(modelviewMatrix);
m_GLSLProgram->sendUniform3x3("normal_matrix", &normalMatrix[0]);
m_GLSLProgram->sendUniform("material_ambient", 0.2f, 0.2f, 0.2f, 1.0f);
m_GLSLProgram->sendUniform("material_diffuse", 0.8f, 0.8f, 0.8f, 1.0f);
m_GLSLProgram->sendUniform("material_specular", 0.6f, 0.6f, 0.6f, 1.0f);
m_GLSLProgram->sendUniform("material_emissive", 0.0f, 0.0f, 0.0f, 1.0f);
m_GLSLProgram->sendUniform("lights[0].ambient", 0.0f, 0.0f, 0.0f, 1.0f);
m_GLSLProgram->sendUniform("lights[0].diffuse", 1.0f, 1.0f, 1.0f, 1.0f);
m_GLSLProgram->sendUniform("lights[0].specular", 1.0f, 1.0f, 1.0f, 1.0f);
m_GLSLProgram->sendUniform("lights[0].constant_attenuation", 1.0f);
m_GLSLProgram->sendUniform("lights[0].linear_attenuation", 0.0f);
m_GLSLProgram->sendUniform("lights[0].quadratic_attenuation", 0.0001f);
m_GLSLProgram->sendUniform("lights[0].position", 0.0f, 30.0f, 0, 1.0f);
m_GLSLProgram->sendUniform("lights[1].ambient", 0.0f, 0.0f, 0.0f, 1.0f);
m_GLSLProgram->sendUniform("lights[1].diffuse", 1.0f, 1.0f, 1.0f, 1.0f);
m_GLSLProgram->sendUniform("lights[1].specular", 1.0f, 1.0f, 1.0f, 1.0f);
m_GLSLProgram->sendUniform("lights[1].constant_attenuation", 1.0f);
m_GLSLProgram->sendUniform("lights[1].linear_attenuation", 0.0f);
m_GLSLProgram->sendUniform("lights[1].quadratic_attenuation", 0.0001f);
m_GLSLProgram->sendUniform("lights[1].position", 41, 30.0f,41, 1.0f);
m_GLSLProgram->sendUniform("lights[2].ambient", 0.0f, 0.0f, 0.0f, 1.0f);
m_GLSLProgram->sendUniform("lights[2].diffuse", HackyRearLights, 0.0f, 0.0f, HackyRearLights);
m_GLSLProgram->sendUniform("lights[2].specular", HackyRearLights, HackyRearLights, HackyRearLights, HackyRearLights);
m_GLSLProgram->sendUniform("lights[2].constant_attenuation", 1.0f);
m_GLSLProgram->sendUniform("lights[2].linear_attenuation", 0.0f);
m_GLSLProgram->sendUniform("lights[2].quadratic_attenuation", 0.001f);
m_GLSLProgram->sendUniform("lights[2].position", ModelBase->m_offsetX, ModelBase->m_offsetY,ModelBase->m_offsetZ - 10, 1.0f);
m_GLSLProgram->sendUniform("lights[3].ambient", 0.0f, 0.0f, 0.0f, 1.0f);
m_GLSLProgram->sendUniform("lights[3].diffuse", HackyFrontLights, HackyFrontLights, HackyFrontLights, HackyFrontLights);
m_GLSLProgram->sendUniform("lights[3].specular", HackyFrontLights, HackyFrontLights, HackyFrontLights, HackyFrontLights);
m_GLSLProgram->sendUniform("lights[3].constant_attenuation", 1.0f);
m_GLSLProgram->sendUniform("lights[3].linear_attenuation", 0.0f);
m_GLSLProgram->sendUniform("lights[3].quadratic_attenuation", 0.001f);
m_GLSLProgram->sendUniform("lights[3].position", ModelBase->m_offsetX, ModelBase->m_offsetY,ModelBase->m_offsetZ + 10, 1.0f);
Models[6]->Draw(m_GLSLProgram);
glBindTexture(GL_TEXTURE_2D, m_BaseTexID);
m_GLSLProgram->sendUniform("texture0", 0);
Models[0]->Draw(m_GLSLProgram);
}
void
display(void)
{
/*
* save the viewing transform by saving a copy of the
* modelview matrix at the right place, then undo the
* rotation by calling calcMatrix() at the right time to
* billboard the tree. Billboarding should only happen
* if the billboard variable is not zero.
*/
float mat[16];
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(-sinf(RAD(rotx))*5.5,
transy,
cosf(RAD(rotx))*5.5,
0. ,0. ,0.,
0. ,1. ,0.);
/* save the viewing tranform */
glGetFloatv(GL_MODELVIEW_MATRIX, mat);
/* change the brightness of the flame light */
glLightfv(GL_LIGHT0, GL_DIFFUSE, &firelight[flames * 4]);
/* ground */
glDisable(GL_TEXTURE_2D);
glCallList(GROUND);
glPushMatrix();
glTranslatef(0.f, 0.f, -transx);
/* base of flame */
glCallList(FLAME_BASE);
/* undo the rotation in the viewing transform */
if (billboard)
calcMatrix();
/* flame polygon */
/*
* position the flame light in the center of the flame polygon
* turn off lighting, turn on texturing, bind the proper flame
* texture, and draw the flame polygon.
*/
glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, flames);
glColor4f(1.f, 1.f, 1.f, 1.f);
glBegin(GL_POLYGON);
glTexCoord2f(0.0, 0.0);
glVertex2f(-1.0, -1.0);
glTexCoord2f(1.0, 0.0);
glVertex2f(1.0, -1.0);
glTexCoord2f(1.0, 1.0);
glVertex2f(1.0, 1.0);
glTexCoord2f(0.0, 1.0);
glVertex2f(-1.0, 1.0);
glEnd();
glPopMatrix();
/* turn lighting back on */
glEnable(GL_LIGHTING);
glutSwapBuffers();
}
void GLTexture_setImage(void * selfPtr, GLint mipmapLevel, GLsizei width, GLsizei height, unsigned int bytesPerRow, void * bitmapData) {
GLTexture * self = selfPtr;
if (self->textureName == 0) {
glGenTextures(1, &self->textureName);
}
self->pixelWidth = width;
self->pixelHeight = height;
glBindTexture(GL_TEXTURE_2D, self->textureName);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, self->wrapS);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, self->wrapT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, self->magFilter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, self->minFilter);
#if defined(GL_EXT_texture_filter_anisotropic) && GL_EXT_texture_filter_anisotropic
if (self->anisotropicFilter) {
GLfloat maxAnisotropy;
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy);
}
#endif
if (bytesPerRow % 4 == 0) {
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
} else if (bytesPerRow % 2 == 0) {
glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
} else {
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
}
#if !TARGET_OPENGL_ES
if (self->autoMipmap) {
switch (GLGraphics_getOpenGLAPIVersion()) {
case GL_API_VERSION_DESKTOP_1:
case GL_API_VERSION_DESKTOP_2:
case GL_API_VERSION_DESKTOP_3:
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
break;
default:
break;
}
}
#endif
glTexImage2D(GL_TEXTURE_2D, mipmapLevel, self->bitmapDataFormat, width, height, 0, self->bitmapDataFormat, self->bitmapDataType, bitmapData);
#if TARGET_OPENGL_ES
if (self->autoMipmap) {
switch (GLGraphics_getOpenGLAPIVersion()) {
case GL_API_VERSION_ES1:
glGenerateMipmapOES(GL_TEXTURE_2D);
break;
case GL_API_VERSION_ES2:
glGenerateMipmap(GL_TEXTURE_2D);
break;
default:
break;
}
}
#endif
}
MeshRenderProcessorGLSR::MeshRenderProcessorGLSR()
: Processor()
, inport_("geometryInport")
//, imageInport_("imageInport")
, meshName_("meshName")
, outport_("imageOutport") //,DataFormatBase::get(DataFormatId::UInt16))
//, declarationsOutport_("declarationsOutport")
, sceneDescOutport_("sceneDescriptionOutport")
, camera_("camera", "Camera")
, centerViewOnGeometry_("centerView", "Center view on geometry")
, setNearFarPlane_("setNearFarPlane", "Calculate Near and Far Plane")
, resetViewParams_("resetView", "Reset Camera")
, trackball_(&camera_)
, overrideColorBuffer_("overrideColorBuffer", "Override Color Buffer", false,
InvalidationLevel::InvalidResources)
, overrideColor_("overrideColor", "Override Color", vec4(0.75f, 0.75f, 0.75f, 1.0f), vec4(0.0f),
vec4(1.0f))
, geomProperties_("geometry", "Geometry Rendering Properties")
, cullFace_("cullFace", "Cull Face")
, polygonMode_("polygonMode", "Polygon Mode")
, renderPointSize_("renderPointSize", "Point Size", 1.0f, 0.001f, 15.0f, 0.001f)
, renderLineWidth_("renderLineWidth", "Line Width", 1.0f, 0.001f, 15.0f, 0.001f)
, enableDepthTest_("enableDepthTest_", "Enable Depth Test", true)
, lightingProperty_("lighting", "Lighting", &camera_)
, layers_("layers", "Layers (max 8)")
, fragcolorLayer_("fragcolorLayer", "Frag Color", true, InvalidationLevel::InvalidResources)
, cameraDirLayer_("cameraDirLayer", "Camera Direction", false,
InvalidationLevel::InvalidResources)
, normalsLayer_("normalsLayer", "Normals (World Space)", false,
InvalidationLevel::InvalidResources)
, lightDirLayer_("lightDirLayer", "Light Direction", false, InvalidationLevel::InvalidResources)
, thresholdLayer_("thresholdLayer", "Silhouette Threshold", false, InvalidationLevel::InvalidResources)
, thresholdDepthLayer_("thresholdDepthLayer", "Depth Threshold", false, InvalidationLevel::InvalidResources)
, materialColLayer_("materialColor", "Material Specular Color", false, InvalidationLevel::InvalidResources)
, lightSpecColLayer_("lightSpecularColor", "Light Specular Color", false, InvalidationLevel::InvalidResources)
, shininessLayer_("shininess", "Specular Shininess Factor", false, InvalidationLevel::InvalidResources)
, debugval1Layer_("debugval1Layer", "Debug Val 1", false, InvalidationLevel::InvalidResources)
, debugval2Layer_("debugval2Layer", "Debug Val 2", false, InvalidationLevel::InvalidResources)
// , colorLayer_("colorLayer", "Color", true, InvalidationLevel::InvalidResources)
// , texCoordLayer_("texCoordLayer", "Texture Coordinates", false,
// InvalidationLevel::InvalidResources)
// , viewNormalsLayer_("viewNormalsLayer", "View Normals", false,
// InvalidationLevel::InvalidResources)
// , worldPosLayer_("worldPosLayer", "World Position Coordinates", false,
// InvalidationLevel::InvalidResources)
// , unnormalizedNormalsLayer_("notnormalizedNormalsLayer", "Normals (not normalised)", false,
// InvalidationLevel::InvalidResources)
// , fragDepthLayer_("fragDepthLayer", "Frag Depth", false,
// InvalidationLevel::InvalidResources)
// , viewNormalsNotLayer_("viewNormalsNotLayer", "View Normals (nor normalised)", false,
// InvalidationLevel::InvalidResources)
// , lightColorLayer_("lightColorLayer", "Light Color", false, InvalidationLevel::InvalidResources)
//, layerDec_(std::make_shared<Declarations>())
, sceneDesc_(std::make_shared<SceneDescription>())
, shader_("silhouette.vert", "silhouette.frag", false)
{
addPort(inport_);
//addPort(imageInport_);
addPort(meshName_);
addPort(outport_);
//addPort(declarationsOutport_);
addPort(sceneDescOutport_);
//declarationsOutport_.setData(layerDec_);
sceneDescOutport_.setData(sceneDesc_);
// imageInport_.setOptional(true);
addProperty(lightingProperty_);
addProperty(layers_);
layers_.addProperty(fragcolorLayer_);
layers_.addProperty(normalsLayer_);
layers_.addProperty(cameraDirLayer_);
layers_.addProperty(lightDirLayer_);
layers_.addProperty(thresholdLayer_);
layers_.addProperty(thresholdDepthLayer_);
layers_.addProperty(materialColLayer_);
layers_.addProperty(lightSpecColLayer_);
layers_.addProperty(shininessLayer_);
//layers_.addProperty(colorLayer_);
//layers_.addProperty(texCoordLayer_);
//layers_.addProperty(viewNormalsLayer_);
//layers_.addProperty(worldPosLayer_);
//layers_.addProperty(unnormalizedNormalsLayer_);
//layers_.addProperty(fragDepthLayer_);
//layers_.addProperty(viewNormalsNotLayer_);
//layers_.addProperty(lightColorLayer_);
layers_.addProperty(debugval1Layer_);
layers_.addProperty(debugval2Layer_);
addProperty(camera_);
centerViewOnGeometry_.onChange(this, &MeshRenderProcessorGLSR::centerViewOnGeometry);
addProperty(centerViewOnGeometry_);
setNearFarPlane_.onChange(this, &MeshRenderProcessorGLSR::setNearFarPlane);
addProperty(setNearFarPlane_);
resetViewParams_.onChange([this]() { camera_.resetCamera(); });
addProperty(resetViewParams_);
outport_.addResizeEventListener(&camera_);
inport_.onChange(this, &MeshRenderProcessorGLSR::updateDrawers);
//meshName_.onChange(this, &MeshRenderProcessorGLSR::setSceneDesc);
LogInfo(outport_.getData()->getDataFormat()->getString());
cullFace_.addOption("culldisable", "Disable", GL_NONE);
cullFace_.addOption("cullfront", "Front", GL_FRONT);
cullFace_.addOption("cullback", "Back", GL_BACK);
cullFace_.addOption("cullfrontback", "Front & Back", GL_FRONT_AND_BACK);
cullFace_.set(GL_NONE);
polygonMode_.addOption("polypoint", "Points", GL_POINT);
polygonMode_.addOption("polyline", "Lines", GL_LINE);
polygonMode_.addOption("polyfill", "Fill", GL_FILL);
polygonMode_.set(GL_FILL);
polygonMode_.onChange(this, &MeshRenderProcessorGLSR::changeRenderMode);
geomProperties_.addProperty(cullFace_);
geomProperties_.addProperty(polygonMode_);
geomProperties_.addProperty(renderPointSize_);
geomProperties_.addProperty(renderLineWidth_);
geomProperties_.addProperty(enableDepthTest_);
geomProperties_.addProperty(overrideColorBuffer_);
geomProperties_.addProperty(overrideColor_);
overrideColor_.setSemantics(PropertySemantics::Color);
overrideColor_.setVisible(false);
overrideColorBuffer_.onChange([&]() { overrideColor_.setVisible(overrideColorBuffer_.get()); });
float lineWidthRange[2];
float increment;
glGetFloatv(GL_LINE_WIDTH_RANGE, lineWidthRange);
glGetFloatv(GL_LINE_WIDTH_GRANULARITY, &increment);
renderLineWidth_.setMinValue(lineWidthRange[0]);
renderLineWidth_.setMaxValue(lineWidthRange[1]);
renderLineWidth_.setIncrement(increment);
renderLineWidth_.setVisible(false);
renderPointSize_.setVisible(false);
addProperty(geomProperties_);
addProperty(trackball_);
setAllPropertiesCurrentStateAsDefault();
}
void glaDrawPixelsSafe(float x, float y, int img_w, int img_h, int row_w, int format, int type, void *rect)
{
float xzoom = glaGetOneFloat(GL_ZOOM_X);
float yzoom = glaGetOneFloat(GL_ZOOM_Y);
/* The pixel space coordinate of the intersection of
* the [zoomed] image with the origin.
*/
float ix = -x / xzoom;
float iy = -y / yzoom;
/* The maximum pixel amounts the image can be cropped
* at the lower left without exceeding the origin.
*/
int off_x = floor(max_ff(ix, 0.0f));
int off_y = floor(max_ff(iy, 0.0f));
/* The zoomed space coordinate of the raster position
* (starting at the lower left most unclipped pixel).
*/
float rast_x = x + off_x * xzoom;
float rast_y = y + off_y * yzoom;
GLfloat scissor[4];
int draw_w, draw_h;
/* Determine the smallest number of pixels we need to draw
* before the image would go off the upper right corner.
*
* It may seem this is just an optimization but some graphics
* cards (ATI) freak out if there is a large zoom factor and
* a large number of pixels off the screen (probably at some
* level the number of image pixels to draw is getting multiplied
* by the zoom and then clamped). Making sure we draw the
* fewest pixels possible keeps everyone mostly happy (still
* fails if we zoom in on one really huge pixel so that it
* covers the entire screen).
*/
glGetFloatv(GL_SCISSOR_BOX, scissor);
draw_w = min_ii(img_w - off_x, ceil((scissor[2] - rast_x) / xzoom));
draw_h = min_ii(img_h - off_y, ceil((scissor[3] - rast_y) / yzoom));
if (draw_w > 0 && draw_h > 0) {
int old_row_length = glaGetOneInteger(GL_UNPACK_ROW_LENGTH);
/* Don't use safe RasterPos (slower) if we can avoid it. */
if (rast_x >= 0 && rast_y >= 0) {
glRasterPos2f(rast_x, rast_y);
}
else {
glaRasterPosSafe2f(rast_x, rast_y, 0, 0);
}
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_w);
if (format == GL_LUMINANCE || format == GL_RED) {
if (type == GL_FLOAT) {
float *f_rect = (float *)rect;
glDrawPixels(draw_w, draw_h, format, type, f_rect + (off_y * row_w + off_x));
}
else if (type == GL_INT || type == GL_UNSIGNED_INT) {
int *i_rect = (int *)rect;
glDrawPixels(draw_w, draw_h, format, type, i_rect + (off_y * row_w + off_x));
}
}
else { /* RGBA */
if (type == GL_FLOAT) {
float *f_rect = (float *)rect;
glDrawPixels(draw_w, draw_h, format, type, f_rect + (off_y * row_w + off_x) * 4);
}
else if (type == GL_UNSIGNED_BYTE) {
unsigned char *uc_rect = (unsigned char *) rect;
glDrawPixels(draw_w, draw_h, format, type, uc_rect + (off_y * row_w + off_x) * 4);
}
}
glPixelStorei(GL_UNPACK_ROW_LENGTH, old_row_length);
}
}
static void
print_limits(Q3ListViewItem *l1, const char * glExtensions, bool GetProcAddress)
{
/* TODO
GL_SAMPLE_BUFFERS
GL_SAMPLES
GL_COMPRESSED_TEXTURE_FORMATS
*/
if (!glExtensions)
return;
struct token_name {
GLuint type; // count and flags, !!! count must be <=2 for now
GLenum token;
const QString name;
};
struct token_group {
int count;
int type;
const token_name *group;
const QString descr;
const char *ext;
};
Q3ListViewItem *l2 = NULL, *l3 = NULL;
#if defined(PFNGLGETPROGRAMIVARBPROC)
PFNGLGETPROGRAMIVARBPROC kcm_glGetProgramivARB = NULL;
#endif
#define KCMGL_FLOAT 128
#define KCMGL_PROG 256
#define KCMGL_COUNT_MASK(x) (x & 127)
#define KCMGL_SIZE(x) (sizeof(x)/sizeof(x[0]))
const struct token_name various_limits[] = {
{ 1, GL_MAX_LIGHTS, i18n("Max. number of light sources") },
{ 1, GL_MAX_CLIP_PLANES, i18n("Max. number of clipping planes") },
{ 1, GL_MAX_PIXEL_MAP_TABLE, i18n("Max. pixel map table size") },
{ 1, GL_MAX_LIST_NESTING, i18n("Max. display list nesting level") },
{ 1, GL_MAX_EVAL_ORDER, i18n("Max. evaluator order") },
{ 1, GL_MAX_ELEMENTS_VERTICES, i18n("Max. recommended vertex count") },
{ 1, GL_MAX_ELEMENTS_INDICES, i18n("Max. recommended index count") },
#ifdef GL_QUERY_COUNTER_BITS
{ 1, GL_QUERY_COUNTER_BITS, i18n("Occlusion query counter bits")},
#endif
#ifdef GL_MAX_VERTEX_UNITS_ARB
{ 1, GL_MAX_VERTEX_UNITS_ARB, i18n("Max. vertex blend matrices") },
#endif
#ifdef GL_MAX_PALETTE_MATRICES_ARB
{ 1, GL_MAX_PALETTE_MATRICES_ARB, i18n("Max. vertex blend matrix palette size") },
#endif
{0,0,0}
};
const struct token_name texture_limits[] = {
{ 1, GL_MAX_TEXTURE_SIZE, i18n("Max. texture size") },
{ 1, GL_MAX_TEXTURE_UNITS_ARB, i18n("Num. of texture units") },
{ 1, GL_MAX_3D_TEXTURE_SIZE, i18n("Max. 3D texture size") },
{ 1, GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, i18n("Max. cube map texture size") },
#ifdef GL_MAX_RECTANGLE_TEXTURE_SIZE_NV
{ 1, GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, i18n("Max. rectangular texture size") },
#endif
{ 1 | KCMGL_FLOAT, GL_MAX_TEXTURE_LOD_BIAS_EXT, i18n("Max. texture LOD bias") },
{ 1, GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, i18n("Max. anisotropy filtering level") },
{ 1, GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, i18n("Num. of compressed texture formats") },
{0,0,0}
};
const struct token_name float_limits[] = {
{ 2 | KCMGL_FLOAT, GL_ALIASED_POINT_SIZE_RANGE, "ALIASED_POINT_SIZE_RANGE" },
{ 2 | KCMGL_FLOAT, GL_SMOOTH_POINT_SIZE_RANGE, "SMOOTH_POINT_SIZE_RANGE" },
{ 1 | KCMGL_FLOAT, GL_SMOOTH_POINT_SIZE_GRANULARITY,"SMOOTH_POINT_SIZE_GRANULARITY"},
{ 2 | KCMGL_FLOAT, GL_ALIASED_LINE_WIDTH_RANGE, "ALIASED_LINE_WIDTH_RANGE" },
{ 2 | KCMGL_FLOAT, GL_SMOOTH_LINE_WIDTH_RANGE, "SMOOTH_LINE_WIDTH_RANGE" },
{ 1 | KCMGL_FLOAT, GL_SMOOTH_LINE_WIDTH_GRANULARITY,"SMOOTH_LINE_WIDTH_GRANULARITY"},
{0,0,0}
};
const struct token_name stack_depth[] = {
{ 1, GL_MAX_MODELVIEW_STACK_DEPTH, "MAX_MODELVIEW_STACK_DEPTH" },
{ 1, GL_MAX_PROJECTION_STACK_DEPTH, "MAX_PROJECTION_STACK_DEPTH" },
{ 1, GL_MAX_TEXTURE_STACK_DEPTH, "MAX_TEXTURE_STACK_DEPTH" },
{ 1, GL_MAX_NAME_STACK_DEPTH, "MAX_NAME_STACK_DEPTH" },
{ 1, GL_MAX_ATTRIB_STACK_DEPTH, "MAX_ATTRIB_STACK_DEPTH" },
{ 1, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, "MAX_CLIENT_ATTRIB_STACK_DEPTH" },
{ 1, GL_MAX_COLOR_MATRIX_STACK_DEPTH, "MAX_COLOR_MATRIX_STACK_DEPTH" },
#ifdef GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB
{ 1, GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB,"MAX_MATRIX_PALETTE_STACK_DEPTH"},
#endif
{0,0,0}
};
#ifdef GL_ARB_fragment_program
const struct token_name arb_fp[] = {
{ 1, GL_MAX_TEXTURE_COORDS_ARB, "MAX_TEXTURE_COORDS" },
{ 1, GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "MAX_TEXTURE_IMAGE_UNITS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, "MAX_PROGRAM_ENV_PARAMETERS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, "MAX_PROGRAM_LOCAL_PARAMETERS" },
{ 1, GL_MAX_PROGRAM_MATRICES_ARB, "MAX_PROGRAM_MATRICES" },
{ 1, GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, "MAX_PROGRAM_MATRIX_STACK_DEPTH" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, "MAX_PROGRAM_INSTRUCTIONS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, "MAX_PROGRAM_ALU_INSTRUCTIONS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, "MAX_PROGRAM_TEX_INSTRUCTIONS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, "MAX_PROGRAM_TEX_INDIRECTIONS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEMPORARIES_ARB, "MAX_PROGRAM_TEMPORARIES" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_PARAMETERS_ARB, "MAX_PROGRAM_PARAMETERS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_ATTRIBS_ARB, "MAX_PROGRAM_ATTRIBS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, "MAX_PROGRAM_NATIVE_INSTRUCTIONS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, "MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, "MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, "MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, "MAX_PROGRAM_NATIVE_TEMPORARIES" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, "MAX_PROGRAM_NATIVE_PARAMETERS" },
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, "MAX_PROGRAM_NATIVE_ATTRIBS" },
{0,0,0}
};
#endif
#ifdef GL_ARB_vertex_program
const struct token_name arb_vp[] = {
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB,"MAX_PROGRAM_ENV_PARAMETERS"},
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB,"MAX_PROGRAM_LOCAL_PARAMETERS"},
{ 1, GL_MAX_VERTEX_ATTRIBS_ARB, "MAX_VERTEX_ATTRIBS"},
{ 1, GL_MAX_PROGRAM_MATRICES_ARB,"MAX_PROGRAM_MATRICES"},
{ 1, GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB,"MAX_PROGRAM_MATRIX_STACK_DEPTH"},
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_INSTRUCTIONS_ARB,"MAX_PROGRAM_INSTRUCTIONS"},
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEMPORARIES_ARB,"MAX_PROGRAM_TEMPORARIES"},
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_PARAMETERS_ARB,"MAX_PROGRAM_PARAMETERS"},
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_ATTRIBS_ARB,"MAX_PROGRAM_ATTRIBS"},
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB,"MAX_PROGRAM_ADDRESS_REGISTERS"},
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB,"MAX_PROGRAM_NATIVE_INSTRUCTIONS"},
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB,"MAX_PROGRAM_NATIVE_TEMPORARIES"},
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB,"MAX_PROGRAM_NATIVE_PARAMETERS"},
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB,"MAX_PROGRAM_NATIVE_ATTRIBS"},
{ 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB ,"MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS"},
{0,0,0}
};
#endif
#ifdef GL_ARB_vertex_shader
const struct token_name arb_vs[] = {
{ 1, GL_MAX_VERTEX_ATTRIBS_ARB,"MAX_VERTEX_ATTRIBS"},
{ 1, GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB,"MAX_VERTEX_UNIFORM_COMPONENTS"},
{ 1, GL_MAX_VARYING_FLOATS_ARB,"MAX_VARYING_FLOATS"},
{ 1, GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB,"MAX_COMBINED_TEXTURE_IMAGE_UNITS"},
{ 1, GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB,"MAX_VERTEX_TEXTURE_IMAGE_UNITS"},
{ 1, GL_MAX_TEXTURE_IMAGE_UNITS_ARB,"MAX_TEXTURE_IMAGE_UNITS"},
{ 1, GL_MAX_TEXTURE_COORDS_ARB,"MAX_TEXTURE_COORDS"},
{0,0,0}
};
#endif
#ifdef GL_ARB_fragment_shader
const struct token_name arb_fs[] = {
{ 1, GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB,"MAX_FRAGMENT_UNIFORM_COMPONENTS"},
{ 1, GL_MAX_TEXTURE_IMAGE_UNITS_ARB,"MAX_TEXTURE_IMAGE_UNITS"},
{ 1, GL_MAX_TEXTURE_COORDS_ARB,"MAX_TEXTURE_COORDS"},
{0,0,0}
};
#endif
const struct token_name frame_buffer_props[] = {
{ 2, GL_MAX_VIEWPORT_DIMS, i18n("Max. viewport dimensions") },
{ 1, GL_SUBPIXEL_BITS, i18n("Subpixel bits") },
{ 1, GL_AUX_BUFFERS, i18n("Aux. buffers")},
{0,0,0}
};
const struct token_group groups[] =
{
{KCMGL_SIZE(frame_buffer_props), 0, frame_buffer_props, i18n("Frame buffer properties"), NULL},
{KCMGL_SIZE(various_limits), 0, texture_limits, i18n("Texturing"), NULL},
{KCMGL_SIZE(various_limits), 0, various_limits, i18n("Various limits"), NULL},
{KCMGL_SIZE(float_limits), 0, float_limits, i18n("Points and lines"), NULL},
{KCMGL_SIZE(stack_depth), 0, stack_depth, i18n("Stack depth limits"), NULL},
#ifdef GL_ARB_vertex_program
{KCMGL_SIZE(arb_vp), GL_VERTEX_PROGRAM_ARB, arb_vp, "ARB_vertex_program", "GL_ARB_vertex_program"},
#endif
#ifdef GL_ARB_fragment_program
{KCMGL_SIZE(arb_fp), GL_FRAGMENT_PROGRAM_ARB, arb_fp, "ARB_fragment_program", "GL_ARB_fragment_program"},
#endif
#ifdef GL_ARB_vertex_shader
{KCMGL_SIZE(arb_vs), 0, arb_vs, "ARB_vertex_shader", "GL_ARB_vertex_shader"},
#endif
#ifdef GL_ARB_fragment_shader
{KCMGL_SIZE(arb_fs), 0, arb_fs, "ARB_fragment_shader", "GL_ARB_fragment_shader"},
#endif
};
#if defined(GLX_ARB_get_proc_address) && defined(PFNGLGETPROGRAMIVARBPROC)
if (GetProcAddress && strstr(glExtensions, "GL_ARB_vertex_program"))
kcm_glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC) glXGetProcAddressARB((const GLubyte *)"glGetProgramivARB");
#endif
for (uint i = 0; i<KCMGL_SIZE(groups); i++) {
if (groups[i].ext && !strstr(glExtensions, groups[i].ext)) continue;
if (l2) l2 = new Q3ListViewItem(l1, l2, groups[i].descr);
else l2 = new Q3ListViewItem(l1, groups[i].descr);
l3 = NULL;
const struct token_name *cur_token;
for (cur_token = groups[i].group; cur_token->type; cur_token++) {
bool tfloat = cur_token->type & KCMGL_FLOAT;
int count = KCMGL_COUNT_MASK(cur_token->type);
GLint max[2]={0,0};
GLfloat fmax[2]={0.0,0.0};
#if defined(PFNGLGETPROGRAMIVARBPROC) && defined(GL_ARB_vertex_program)
bool tprog = cur_token->type & KCMGL_PROG;
if (tprog && kcm_glGetProgramivARB)
kcm_glGetProgramivARB(groups[i].type, cur_token->token, max);
else
#endif
if (tfloat) glGetFloatv(cur_token->token, fmax);
else glGetIntegerv(cur_token->token, max);
if (glGetError() == GL_NONE) {
QString s;
if (!tfloat && count == 1) s = QString::number(max[0]); else
if (!tfloat && count == 2) s = QString("%1, %2").arg(max[0]).arg(max[1]); else
if (tfloat && count == 2) s = QString("%1 - %2").arg(fmax[0],0,'f',6).arg(fmax[1],0,'f',6); else
if (tfloat && count == 1) s = QString::number(fmax[0],'f',6);
if (l3) l3 = new Q3ListViewItem(l2, l3, cur_token->name, s);
else l3 = new Q3ListViewItem(l2, cur_token->name, s);
}
}
}
}
/*
=============
R_SetupGL
=============
*/
void R_SetupGL (void)
{
float screenaspect;
float yfov;
int i;
extern int glwidth, glheight;
int x, x2, y2, y, w, h;
//
// set up viewpoint
//
glMatrixMode(GL_PROJECTION);
glLoadIdentity ();
x = r_refdef.vrect.x * glwidth/vid.width;
x2 = (r_refdef.vrect.x + r_refdef.vrect.width) * glwidth/vid.width;
y = (vid.height-r_refdef.vrect.y) * glheight/vid.height;
y2 = (vid.height - (r_refdef.vrect.y + r_refdef.vrect.height)) * glheight/vid.height;
// fudge around because of frac screen scale
if (x > 0)
x--;
if (x2 < glwidth)
x2++;
if (y2 < 0)
y2--;
if (y < glheight)
y++;
w = x2 - x;
h = y - y2;
if (envmap)
{
x = y2 = 0;
w = h = 256;
}
glViewport (glx + x, gly + y2, w, h);
screenaspect = (float)r_refdef.vrect.width/r_refdef.vrect.height;
// yfov = 2*atan((float)r_refdef.vrect.height/r_refdef.vrect.width)*180/M_PI;
MYgluPerspective (r_refdef.fov_y, screenaspect, 4, 4096);
if (mirror)
{
if (mirror_plane->normal[2])
glScalef (1, -1, 1);
else
glScalef (-1, 1, 1);
glCullFace(GL_BACK);
}
else
glCullFace(GL_FRONT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity ();
glRotatef (-90, 1, 0, 0); // put Z going up
glRotatef (90, 0, 0, 1); // put Z going up
glRotatef (-r_refdef.viewangles[2], 1, 0, 0);
glRotatef (-r_refdef.viewangles[0], 0, 1, 0);
glRotatef (-r_refdef.viewangles[1], 0, 0, 1);
glTranslatef (-r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]);
glGetFloatv (GL_MODELVIEW_MATRIX, r_world_matrix);
//
// set drawing parms
//
if (gl_cull.value)
glEnable(GL_CULL_FACE);
else
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
glEnable(GL_DEPTH_TEST);
}
void OpenGL3Driver::setup_caps(DriverRenderingCapabilities& caps)
{
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &caps.max_anisotropic_level);
}
void C3dCamera::ExtractFrustum()
{
// Extracts The Current View m_fFrustum Plane Equations
float proj[16]; // For Grabbing The PROJECTION Matrix
float modl[16]; // For Grabbing The MODELVIEW Matrix
double clip[16]; // Result Of Concatenating PROJECTION and MODELVIEW
double t; // Temporary Work Variable
glGetFloatv( GL_PROJECTION_MATRIX, proj ); // Grab The Current PROJECTION Matrix
glGetFloatv( GL_MODELVIEW_MATRIX, modl ); // Grab The Current MODELVIEW Matrix
// Concatenate (Multiply) The Two Matricies
clip[ 0] = modl[ 0] * proj[ 0] + modl[ 1] * proj[ 4] + modl[ 2] * proj[ 8] + modl[ 3] * proj[12];
clip[ 1] = modl[ 0] * proj[ 1] + modl[ 1] * proj[ 5] + modl[ 2] * proj[ 9] + modl[ 3] * proj[13];
clip[ 2] = modl[ 0] * proj[ 2] + modl[ 1] * proj[ 6] + modl[ 2] * proj[10] + modl[ 3] * proj[14];
clip[ 3] = modl[ 0] * proj[ 3] + modl[ 1] * proj[ 7] + modl[ 2] * proj[11] + modl[ 3] * proj[15];
clip[ 4] = modl[ 4] * proj[ 0] + modl[ 5] * proj[ 4] + modl[ 6] * proj[ 8] + modl[ 7] * proj[12];
clip[ 5] = modl[ 4] * proj[ 1] + modl[ 5] * proj[ 5] + modl[ 6] * proj[ 9] + modl[ 7] * proj[13];
clip[ 6] = modl[ 4] * proj[ 2] + modl[ 5] * proj[ 6] + modl[ 6] * proj[10] + modl[ 7] * proj[14];
clip[ 7] = modl[ 4] * proj[ 3] + modl[ 5] * proj[ 7] + modl[ 6] * proj[11] + modl[ 7] * proj[15];
clip[ 8] = modl[ 8] * proj[ 0] + modl[ 9] * proj[ 4] + modl[10] * proj[ 8] + modl[11] * proj[12];
clip[ 9] = modl[ 8] * proj[ 1] + modl[ 9] * proj[ 5] + modl[10] * proj[ 9] + modl[11] * proj[13];
clip[10] = modl[ 8] * proj[ 2] + modl[ 9] * proj[ 6] + modl[10] * proj[10] + modl[11] * proj[14];
clip[11] = modl[ 8] * proj[ 3] + modl[ 9] * proj[ 7] + modl[10] * proj[11] + modl[11] * proj[15];
clip[12] = modl[12] * proj[ 0] + modl[13] * proj[ 4] + modl[14] * proj[ 8] + modl[15] * proj[12];
clip[13] = modl[12] * proj[ 1] + modl[13] * proj[ 5] + modl[14] * proj[ 9] + modl[15] * proj[13];
clip[14] = modl[12] * proj[ 2] + modl[13] * proj[ 6] + modl[14] * proj[10] + modl[15] * proj[14];
clip[15] = modl[12] * proj[ 3] + modl[13] * proj[ 7] + modl[14] * proj[11] + modl[15] * proj[15];
// Extract the RIGHT clipping plane
m_fFrustum[0][0] = clip[ 3] - clip[ 0];
m_fFrustum[0][1] = clip[ 7] - clip[ 4];
m_fFrustum[0][2] = clip[11] - clip[ 8];
m_fFrustum[0][3] = clip[15] - clip[12];
// Normalize it
t = (double) sqrt( m_fFrustum[0][0] * m_fFrustum[0][0] + m_fFrustum[0][1] * m_fFrustum[0][1] + m_fFrustum[0][2] * m_fFrustum[0][2] );
m_fFrustum[0][0] /= t;
m_fFrustum[0][1] /= t;
m_fFrustum[0][2] /= t;
m_fFrustum[0][3] /= t;
// Extract the LEFT clipping plane
m_fFrustum[1][0] = clip[ 3] + clip[ 0];
m_fFrustum[1][1] = clip[ 7] + clip[ 4];
m_fFrustum[1][2] = clip[11] + clip[ 8];
m_fFrustum[1][3] = clip[15] + clip[12];
// Normalize it
t = (double) sqrt( m_fFrustum[1][0] * m_fFrustum[1][0] + m_fFrustum[1][1] * m_fFrustum[1][1] + m_fFrustum[1][2] * m_fFrustum[1][2] );
m_fFrustum[1][0] /= t;
m_fFrustum[1][1] /= t;
m_fFrustum[1][2] /= t;
m_fFrustum[1][3] /= t;
// Extract the BOTTOM clipping plane
m_fFrustum[2][0] = clip[ 3] + clip[ 1];
m_fFrustum[2][1] = clip[ 7] + clip[ 5];
m_fFrustum[2][2] = clip[11] + clip[ 9];
m_fFrustum[2][3] = clip[15] + clip[13];
// Normalize it
t = (double) sqrt( m_fFrustum[2][0] * m_fFrustum[2][0] + m_fFrustum[2][1] * m_fFrustum[2][1] + m_fFrustum[2][2] * m_fFrustum[2][2] );
m_fFrustum[2][0] /= t;
m_fFrustum[2][1] /= t;
m_fFrustum[2][2] /= t;
m_fFrustum[2][3] /= t;
// Extract the TOP clipping plane
m_fFrustum[3][0] = clip[ 3] - clip[ 1];
m_fFrustum[3][1] = clip[ 7] - clip[ 5];
m_fFrustum[3][2] = clip[11] - clip[ 9];
m_fFrustum[3][3] = clip[15] - clip[13];
// Normalize it
t = sqrt( m_fFrustum[3][0] * m_fFrustum[3][0] + m_fFrustum[3][1] * m_fFrustum[3][1] + m_fFrustum[3][2] * m_fFrustum[3][2] );
m_fFrustum[3][0] /= t;
m_fFrustum[3][1] /= t;
m_fFrustum[3][2] /= t;
m_fFrustum[3][3] /= t;
// Extract the FAR clipping plane
m_fFrustum[4][0] = clip[ 3] - clip[ 2];
m_fFrustum[4][1] = clip[ 7] - clip[ 6];
m_fFrustum[4][2] = clip[11] - clip[10];
m_fFrustum[4][3] = clip[15] - clip[14];
// Normalize it
t = sqrt( m_fFrustum[4][0] * m_fFrustum[4][0] + m_fFrustum[4][1] * m_fFrustum[4][1] + m_fFrustum[4][2] * m_fFrustum[4][2] );
m_fFrustum[4][0] /= t;
m_fFrustum[4][1] /= t;
m_fFrustum[4][2] /= t;
m_fFrustum[4][3] /= t;
// Extract the NEAR clipping plane.
m_fFrustum[5][0] = clip[ 3] + clip[ 2];
m_fFrustum[5][1] = clip[ 7] + clip[ 6];
m_fFrustum[5][2] = clip[11] + clip[10];
m_fFrustum[5][3] = clip[15] + clip[14];
// Normalize it
t = (double) sqrt( m_fFrustum[5][0] * m_fFrustum[5][0] + m_fFrustum[5][1] * m_fFrustum[5][1] + m_fFrustum[5][2] * m_fFrustum[5][2] );
m_fFrustum[5][0] /= t;
m_fFrustum[5][1] /= t;
m_fFrustum[5][2] /= t;
m_fFrustum[5][3] /= t;
}
/// <summary>
/// Execute http get request
/// </summary>
/// <param name="idstr">OpenGL enum as string</param>
/// <param name="id">OpenGL enum to query</param>
/// <param name="type">Internal OpenGL enum type (glint, glstring)</param>
/// <param name="dim">No of dimensions to query</param>
void capsGroup::addCapability(string idstr, GLenum id, string type, int dim)
{
string errorValue = "n/a";
// Clear last OpenGL error
GLint dummyError = glGetError();
if (type == "glint") {
GLint* intVal;
intVal = new GLint[dim];
glGetIntegerv(id, intVal);
string valString = "";
for (int i = 0; i < dim; i++) {
if (i > 0) {
valString += " ,";
}
valString += to_string(intVal[i]);
}
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = errorValue;
}
delete[] intVal;
}
if (type == "glint64") {
GLint64* intVal;
intVal = new GLint64[dim];
glGetInteger64v(id, intVal);
string valString = "";
for (int i = 0; i < dim; i++) {
if (i > 0) {
valString += " ,";
}
valString += to_string(intVal[i]);
}
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = errorValue;
}
delete[] intVal;
}
if (type == "glintindex") {
GLint intVal;
string valString = "";
for (int i = 0; i < dim; i++) {
if (i > 0) {
valString += " ,";
}
glGetIntegeri_v(id, i, &intVal);
valString += to_string(intVal);
}
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = errorValue;
}
}
if (type == "glintfragmentprogram") {
GLint* intVal;
intVal = new GLint[dim];
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, id, intVal);
string valString = "";
for (int i = 0; i < dim; i++) {
if (i > 0) {
valString += " ,";
}
valString += to_string(intVal[i]);
}
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = errorValue;
}
delete[] intVal;
}
if (type == "glintvertexprogram") {
GLint* intVal;
intVal = new GLint[dim];
glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, id, intVal);
string valString = "";
for (int i = 0; i < dim; i++) {
if (i > 0) {
valString += " ,";
}
valString += to_string(intVal[i]);
}
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = errorValue;
}
delete[] intVal;
}
if (type == "glfloat") {
GLfloat* floatVal;
floatVal = new GLfloat[dim];
glGetFloatv(id, floatVal);
string valString = "";
for (int i = 0; i < dim; i++) {
if (i > 0) {
valString += " ,";
}
valString += to_string(floatVal[i]);
}
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = errorValue;
}
delete[] floatVal;
}
if (type == "glstring") {
string valString = reinterpret_cast<const char*>(glGetString(id));
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = "";
}
}
}
// JMQTODO: really need a platform-shared version of this nastiness
bool GL_EXT_Init( )
{
// Load extensions...
//
const char* pExtString = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
gGLState.primMode = 0;
U32 extBitMask = 0;
// GL_EXT_paletted_texture
if (pExtString && dStrstr(pExtString, (const char*)"GL_EXT_paletted_texture") != NULL)
{
extBitMask |= EXT_paletted_texture;
gGLState.suppPalettedTexture = true;
}
else
gGLState.suppPalettedTexture = false;
// EXT_compiled_vertex_array
if (pExtString && dStrstr(pExtString, (const char*)"GL_EXT_compiled_vertex_array") != NULL)
{
extBitMask |= EXT_compiled_vertex_array;
gGLState.suppLockedArrays = true;
}
else
{
gGLState.suppLockedArrays = false;
}
// ARB_multitexture
if (pExtString && dStrstr(pExtString, (const char*)"GL_ARB_multitexture") != NULL)
{
extBitMask |= ARB_multitexture;
gGLState.suppARBMultitexture = true;
} else {
gGLState.suppARBMultitexture = false;
}
// EXT_blend_color
if(pExtString && dStrstr(pExtString, (const char*)"GL_EXT_blend_color") != NULL)
{
extBitMask |= EXT_blend_color;
gGLState.suppEXTblendcolor = true;
} else {
gGLState.suppEXTblendcolor = false;
}
// EXT_blend_minmax
if(pExtString && dStrstr(pExtString, (const char*)"GL_EXT_blend_minmax") != NULL)
{
extBitMask |= EXT_blend_color;
gGLState.suppEXTblendminmax = true;
} else {
gGLState.suppEXTblendminmax = false;
}
// EXT_fog_coord
if (pExtString && dStrstr(pExtString, (const char*)"GL_EXT_fog_coord") != NULL)
{
extBitMask |= EXT_fog_coord;
gGLState.suppFogCoord = true;
} else {
gGLState.suppFogCoord = false;
}
// EXT_texture_compression_s3tc
if (pExtString && dStrstr(pExtString, (const char*)"GL_EXT_texture_compression_s3tc") != NULL)
gGLState.suppS3TC = true;
else
gGLState.suppS3TC = false;
// ARB_texture_compression
if (pExtString && dStrstr(pExtString, (const char*)"GL_ARB_texture_compression") != NULL)
{
extBitMask |= ARB_texture_compression;
gGLState.suppTextureCompression = true;
} else {
gGLState.suppTextureCompression = false;
}
// NV_vertex_array_range (not on *nix)
gGLState.suppVertexArrayRange = false;
// 3DFX_texture_compression_FXT1
if (pExtString && dStrstr(pExtString, (const char*)"3DFX_texture_compression_FXT1") != NULL)
gGLState.suppFXT1 = true;
else
gGLState.suppFXT1 = false;
if (!bindEXTFunctions(extBitMask))
Con::warnf("You are missing some OpenGL Extensions. You may experience rendering problems.");
// Binary states, i.e., no supporting functions
// EXT_packed_pixels
// EXT_texture_env_combine
//
// dhc note: a number of these can have multiple matching 'versions', private, ext, and arb.
gGLState.suppPackedPixels = pExtString? (dStrstr(pExtString, (const char*)"GL_EXT_packed_pixels") != NULL) : false;
gGLState.suppTextureEnvCombine = pExtString? (dStrstr(pExtString, (const char*)"GL_EXT_texture_env_combine") != NULL) : false;
gGLState.suppEdgeClamp = pExtString? (dStrstr(pExtString, (const char*)"GL_EXT_texture_edge_clamp") != NULL) : false;
gGLState.suppEdgeClamp |= pExtString? (dStrstr(pExtString, (const char*)"GL_SGIS_texture_edge_clamp") != NULL) : false;
gGLState.suppTexEnvAdd = pExtString? (dStrstr(pExtString, (const char*)"GL_ARB_texture_env_add") != NULL) : false;
gGLState.suppTexEnvAdd |= pExtString? (dStrstr(pExtString, (const char*)"GL_EXT_texture_env_add") != NULL) : false;
// Anisotropic filtering
gGLState.suppTexAnisotropic = pExtString? (dStrstr(pExtString, (const char*)"GL_EXT_texture_filter_anisotropic") != NULL) : false;
if (gGLState.suppTexAnisotropic)
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gGLState.maxAnisotropy);
if (gGLState.suppARBMultitexture)
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gGLState.maxTextureUnits);
else
gGLState.maxTextureUnits = 1;
// JMQ: vsync/swap interval skipped
gGLState.suppSwapInterval = false;
Con::printf("OpenGL Init: Enabled Extensions");
if (gGLState.suppARBMultitexture) Con::printf(" ARB_multitexture (Max Texture Units: %d)", gGLState.maxTextureUnits);
if (gGLState.suppEXTblendcolor) Con::printf(" EXT_blend_color");
if (gGLState.suppEXTblendminmax) Con::printf(" EXT_blend_minmax");
if (gGLState.suppPalettedTexture) Con::printf(" EXT_paletted_texture");
if (gGLState.suppLockedArrays) Con::printf(" EXT_compiled_vertex_array");
if (gGLState.suppVertexArrayRange) Con::printf(" NV_vertex_array_range");
if (gGLState.suppTextureEnvCombine) Con::printf(" EXT_texture_env_combine");
if (gGLState.suppPackedPixels) Con::printf(" EXT_packed_pixels");
if (gGLState.suppFogCoord) Con::printf(" EXT_fog_coord");
if (gGLState.suppTextureCompression) Con::printf(" ARB_texture_compression");
if (gGLState.suppS3TC) Con::printf(" EXT_texture_compression_s3tc");
if (gGLState.suppFXT1) Con::printf(" 3DFX_texture_compression_FXT1");
if (gGLState.suppTexEnvAdd) Con::printf(" (ARB|EXT)_texture_env_add");
if (gGLState.suppTexAnisotropic) Con::printf(" EXT_texture_filter_anisotropic (Max anisotropy: %f)", gGLState.maxAnisotropy);
if (gGLState.suppSwapInterval) Con::printf(" WGL_EXT_swap_control");
Con::warnf("OpenGL Init: Disabled Extensions");
if (!gGLState.suppARBMultitexture) Con::warnf(" ARB_multitexture");
if (!gGLState.suppEXTblendcolor) Con::warnf(" EXT_blend_color");
if (!gGLState.suppEXTblendminmax) Con::warnf(" EXT_blend_minmax");
if (!gGLState.suppPalettedTexture) Con::warnf(" EXT_paletted_texture");
if (!gGLState.suppLockedArrays) Con::warnf(" EXT_compiled_vertex_array");
if (!gGLState.suppVertexArrayRange) Con::warnf(" NV_vertex_array_range");
if (!gGLState.suppTextureEnvCombine) Con::warnf(" EXT_texture_env_combine");
if (!gGLState.suppPackedPixels) Con::warnf(" EXT_packed_pixels");
if (!gGLState.suppFogCoord) Con::warnf(" EXT_fog_coord");
if (!gGLState.suppTextureCompression) Con::warnf(" ARB_texture_compression");
if (!gGLState.suppS3TC) Con::warnf(" EXT_texture_compression_s3tc");
if (!gGLState.suppFXT1) Con::warnf(" 3DFX_texture_compression_FXT1");
if (!gGLState.suppTexEnvAdd) Con::warnf(" (ARB|EXT)_texture_env_add");
if (!gGLState.suppTexAnisotropic) Con::warnf(" EXT_texture_filter_anisotropic");
if (!gGLState.suppSwapInterval) Con::warnf(" WGL_EXT_swap_control");
Con::printf(" ");
// Set some console variables:
Con::setBoolVariable( "$FogCoordSupported", gGLState.suppFogCoord );
Con::setBoolVariable( "$TextureCompressionSupported", gGLState.suppTextureCompression );
Con::setBoolVariable( "$AnisotropySupported", gGLState.suppTexAnisotropic );
Con::setBoolVariable( "$PalettedTextureSupported", gGLState.suppPalettedTexture );
Con::setBoolVariable( "$SwapIntervalSupported", gGLState.suppSwapInterval );
if (!gGLState.suppPalettedTexture && Con::getBoolVariable("$pref::OpenGL::forcePalettedTexture",false))
{
Con::setBoolVariable("$pref::OpenGL::forcePalettedTexture", false);
Con::setBoolVariable("$pref::OpenGL::force16BitTexture", true);
}
return true;
}
void ApplyShadowMaps (short nStartSeg, fix nEyeOffset, int nWindow)
{
static float mTexBiasf [] = {
0.5f, 0.0f, 0.0f, 0.0f,
0.0f, 0.5f, 0.0f, 0.0f,
0.0f, 0.0f, 0.5f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f};
static float mPlanef [] = {
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f};
static GLenum nTexCoord [] = {GL_S, GL_T, GL_R, GL_Q};
CFloatMatrix mProjection;
CFloatMatrix mModelView;
int i;
CCamera *cameraP;
#if 1
OglActiveTexture (GL_TEXTURE0, 0);
glEnable (GL_TEXTURE_2D);
glEnable (GL_TEXTURE_GEN_S);
glEnable (GL_TEXTURE_GEN_T);
glEnable (GL_TEXTURE_GEN_R);
glEnable (GL_TEXTURE_GEN_Q);
for (i = 0; i < 4; i++)
glTexGeni (nTexCoord [i], GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
for (i = 0; i < 4; i++)
glTexGenfv (nTexCoord [i], GL_EYE_PLANE, mPlanef + 4 * i);
glGetFloatv (GL_PROJECTION_MATRIX, mProjection.Vec ());
glMatrixMode (GL_TEXTURE);
for (i = 0, cameraP = gameData.render.shadows.shadowMaps; i < 1/*gameData.render.shadows.nShadowMaps*/; i++) {
glBindTexture (GL_TEXTURE_2D, cameraP->FrameBuffer ().RenderBuffer ());
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
glLoadMatrixf (mTexBiasf);
glMultMatrixf (mProjection.Vec ());
CFixMatrix::Transpose (mModelView, cameraP->GetObject ()->info.position.mOrient);
glMultMatrixf (mModelView.Vec ());
}
glMatrixMode (GL_MODELVIEW);
#endif
RenderMine (nStartSeg, nEyeOffset, nWindow);
#if 1
glMatrixMode (GL_TEXTURE);
glLoadIdentity ();
glMatrixMode (GL_MODELVIEW);
glDisable (GL_TEXTURE_GEN_S);
glDisable (GL_TEXTURE_GEN_T);
glDisable (GL_TEXTURE_GEN_R);
glDisable (GL_TEXTURE_GEN_Q);
OglActiveTexture (GL_TEXTURE0, 0);
glDisable (GL_TEXTURE_2D);
#endif
DestroyShadowMaps ();
}