/* Draw a 4d embedding of the projective plane projected into 3D. */
static int projective_plane(ModeInfo *mi, double umin, double umax,
double vmin, double vmax)
{
int polys = 0;
static const GLfloat mat_diff_red[] = { 1.0, 0.0, 0.0, 1.0 };
static const GLfloat mat_diff_green[] = { 0.0, 1.0, 0.0, 1.0 };
static const GLfloat mat_diff_trans_red[] = { 1.0, 0.0, 0.0, 0.7 };
static const GLfloat mat_diff_trans_green[] = { 0.0, 1.0, 0.0, 0.7 };
float p[3], pu[3], pv[3], pm[3], n[3], b[3], mat[4][4];
int i, j, k, l, m, o;
double u, v;
double xx[4], xxu[4], xxv[4], y[4], yu[4], yv[4];
double q, r, s, t;
double cu, su, cv2, sv2, cv4, sv4, c2u, s2u;
float q1[4], q2[4], r1[4][4], r2[4][4];
projectiveplanestruct *pp = &projectiveplane[MI_SCREEN(mi)];
if (view == VIEW_WALK || view == VIEW_WALKTURN)
{
/* Compute the rotation that rotates the projective plane in 4D without
the trackball rotations. */
rotateall4d(pp->zeta,pp->eta,pp->theta,mat);
u = pp->umove;
v = pp->vmove;
cu = cos(u);
su = sin(u);
c2u = cos(2.0*u);
s2u = sin(2.0*u);
sv2 = sin(0.5*v);
cv4 = cos(0.25*v);
sv4 = sin(0.25*v);
xx[0] = 0.5*s2u*sv4*sv4;
xx[1] = 0.5*su*sv2;
xx[2] = 0.5*cu*sv2;
xx[3] = 0.5*(su*su*sv4*sv4-cv4*cv4);
/* Avoid degenerate tangential plane basis vectors. */
if (v < FLT_EPSILON)
v = FLT_EPSILON;
cv2 = cos(0.5*v);
sv2 = sin(0.5*v);
sv4 = sin(0.25*v);
xxu[0] = c2u*sv4*sv4;
xxu[1] = 0.5*cu*sv2;
xxu[2] = -0.5*su*sv2;
xxu[3] = 0.5*s2u*sv4*sv4;
xxv[0] = 0.125*s2u*sv2;
xxv[1] = 0.25*su*cv2;
xxv[2] = 0.25*cu*cv2;
xxv[3] = 0.125*(su*su+1.0)*sv2;
for (l=0; l<4; l++)
{
y[l] = (mat[l][0]*xx[0]+mat[l][1]*xx[1]+
mat[l][2]*xx[2]+mat[l][3]*xx[3]);
yu[l] = (mat[l][0]*xxu[0]+mat[l][1]*xxu[1]+
mat[l][2]*xxu[2]+mat[l][3]*xxu[3]);
yv[l] = (mat[l][0]*xxv[0]+mat[l][1]*xxv[1]+
mat[l][2]*xxv[2]+mat[l][3]*xxv[3]);
}
if (projection_4d == DISP_4D_ORTHOGRAPHIC)
{
for (l=0; l<3; l++)
{
p[l] = y[l]+pp->offset4d[l];
pu[l] = yu[l];
pv[l] = yv[l];
}
}
else
{
s = y[3]+pp->offset4d[3];
q = 1.0/s;
t = q*q;
for (l=0; l<3; l++)
{
r = y[l]+pp->offset4d[l];
p[l] = r*q;
pu[l] = (yu[l]*s-r*yu[3])*t;
pv[l] = (yv[l]*s-r*yv[3])*t;
}
}
n[0] = pu[1]*pv[2]-pu[2]*pv[1];
n[1] = pu[2]*pv[0]-pu[0]*pv[2];
n[2] = pu[0]*pv[1]-pu[1]*pv[0];
t = 1.0/(pp->side*4.0*sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2]));
n[0] *= t;
n[1] *= t;
n[2] *= t;
pm[0] = pu[0]*pp->dumove+pv[0]*pp->dvmove;
pm[1] = pu[1]*pp->dumove+pv[1]*pp->dvmove;
pm[2] = pu[2]*pp->dumove+pv[2]*pp->dvmove;
t = 1.0/(4.0*sqrt(pm[0]*pm[0]+pm[1]*pm[1]+pm[2]*pm[2]));
pm[0] *= t;
pm[1] *= t;
pm[2] *= t;
b[0] = n[1]*pm[2]-n[2]*pm[1];
b[1] = n[2]*pm[0]-n[0]*pm[2];
b[2] = n[0]*pm[1]-n[1]*pm[0];
t = 1.0/(4.0*sqrt(b[0]*b[0]+b[1]*b[1]+b[2]*b[2]));
b[0] *= t;
b[1] *= t;
b[2] *= t;
/* Compute alpha, beta, delta from the three basis vectors.
| -b[0] -b[1] -b[2] |
m = | n[0] n[1] n[2] |
| -pm[0] -pm[1] -pm[2] |
*/
pp->alpha = atan2(-n[2],-pm[2])*180/M_PI;
pp->beta = atan2(-b[2],sqrt(b[0]*b[0]+b[1]*b[1]))*180/M_PI;
pp->delta = atan2(b[1],-b[0])*180/M_PI;
/* Compute the rotation that rotates the projective plane in 4D. */
rotateall(pp->alpha,pp->beta,pp->delta,pp->zeta,pp->eta,pp->theta,mat);
u = pp->umove;
v = pp->vmove;
cu = cos(u);
su = sin(u);
s2u = sin(2.0*u);
sv2 = sin(0.5*v);
cv4 = cos(0.25*v);
sv4 = sin(0.25*v);
xx[0] = 0.5*s2u*sv4*sv4;
xx[1] = 0.5*su*sv2;
xx[2] = 0.5*cu*sv2;
xx[3] = 0.5*(su*su*sv4*sv4-cv4*cv4);
for (l=0; l<4; l++)
{
r = 0.0;
for (m=0; m<4; m++)
r += mat[l][m]*xx[m];
y[l] = r;
}
if (projection_4d == DISP_4D_ORTHOGRAPHIC)
{
for (l=0; l<3; l++)
p[l] = y[l]+pp->offset4d[l];
}
else
{
s = y[3]+pp->offset4d[3];
for (l=0; l<3; l++)
p[l] = (y[l]+pp->offset4d[l])/s;
}
pp->offset3d[0] = -p[0];
pp->offset3d[1] = -p[1]-DELTAY;
pp->offset3d[2] = -p[2];
}
else
{
/* Compute the rotation that rotates the projective plane in 4D,
including the trackball rotations. */
rotateall(pp->alpha,pp->beta,pp->delta,pp->zeta,pp->eta,pp->theta,r1);
gltrackball_get_quaternion(pp->trackballs[0],q1);
gltrackball_get_quaternion(pp->trackballs[1],q2);
quats_to_rotmat(q1,q2,r2);
mult_rotmat(r2,r1,mat);
}
/* Project the points from 4D to 3D. */
for (i=0; i<=NUMV; i++)
{
for (j=0; j<=NUMU; j++)
{
o = i*(NUMU+1)+j;
for (l=0; l<4; l++)
{
y[l] = (mat[l][0]*pp->x[o][0]+mat[l][1]*pp->x[o][1]+
mat[l][2]*pp->x[o][2]+mat[l][3]*pp->x[o][3]);
yu[l] = (mat[l][0]*pp->xu[o][0]+mat[l][1]*pp->xu[o][1]+
mat[l][2]*pp->xu[o][2]+mat[l][3]*pp->xu[o][3]);
yv[l] = (mat[l][0]*pp->xv[o][0]+mat[l][1]*pp->xv[o][1]+
mat[l][2]*pp->xv[o][2]+mat[l][3]*pp->xv[o][3]);
}
if (projection_4d == DISP_4D_ORTHOGRAPHIC)
{
for (l=0; l<3; l++)
{
pp->pp[o][l] = (y[l]+pp->offset4d[l])+pp->offset3d[l];
pu[l] = yu[l];
pv[l] = yv[l];
}
}
else
{
s = y[3]+pp->offset4d[3];
q = 1.0/s;
t = q*q;
for (l=0; l<3; l++)
{
r = y[l]+pp->offset4d[l];
pp->pp[o][l] = r*q+pp->offset3d[l];
pu[l] = (yu[l]*s-r*yu[3])*t;
pv[l] = (yv[l]*s-r*yv[3])*t;
}
}
pp->pn[o][0] = pu[1]*pv[2]-pu[2]*pv[1];
pp->pn[o][1] = pu[2]*pv[0]-pu[0]*pv[2];
pp->pn[o][2] = pu[0]*pv[1]-pu[1]*pv[0];
t = 1.0/sqrt(pp->pn[o][0]*pp->pn[o][0]+pp->pn[o][1]*pp->pn[o][1]+
pp->pn[o][2]*pp->pn[o][2]);
pp->pn[o][0] *= t;
pp->pn[o][1] *= t;
pp->pn[o][2] *= t;
}
}
if (colors == COLORS_TWOSIDED)
{
glColor3fv(mat_diff_red);
if (display_mode == DISP_TRANSPARENT)
{
glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,mat_diff_trans_red);
glMaterialfv(GL_BACK,GL_AMBIENT_AND_DIFFUSE,mat_diff_trans_green);
}
else
{
glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,mat_diff_red);
glMaterialfv(GL_BACK,GL_AMBIENT_AND_DIFFUSE,mat_diff_green);
}
}
glBindTexture(GL_TEXTURE_2D,pp->tex_name);
if (appearance != APPEARANCE_DIRECTION_BANDS)
{
for (i=0; i<NUMV; i++)
{
if (appearance == APPEARANCE_DISTANCE_BANDS &&
((i & (NUMB-1)) >= NUMB/4) && ((i & (NUMB-1)) < 3*NUMB/4))
continue;
if (display_mode == DISP_WIREFRAME)
glBegin(GL_QUAD_STRIP);
else
glBegin(GL_TRIANGLE_STRIP);
for (j=0; j<=NUMU; j++)
{
for (k=0; k<=1; k++)
{
l = (i+k);
m = j;
o = l*(NUMU+1)+m;
glNormal3fv(pp->pn[o]);
glTexCoord2fv(pp->tex[o]);
if (colors != COLORS_TWOSIDED)
{
glColor3fv(pp->col[o]);
glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,pp->col[o]);
}
glVertex3fv(pp->pp[o]);
polys++;
}
}
glEnd();
}
}
else /* appearance == APPEARANCE_DIRECTION_BANDS */
{
for (j=0; j<NUMU; j++)
{
if ((j & (NUMB-1)) >= NUMB/2)
continue;
if (display_mode == DISP_WIREFRAME)
glBegin(GL_QUAD_STRIP);
else
glBegin(GL_TRIANGLE_STRIP);
for (i=0; i<=NUMV; i++)
{
for (k=0; k<=1; k++)
{
l = i;
m = (j+k);
o = l*(NUMU+1)+m;
glNormal3fv(pp->pn[o]);
glTexCoord2fv(pp->tex[o]);
if (colors != COLORS_TWOSIDED)
{
glColor3fv(pp->col[o]);
glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,pp->col[o]);
}
glVertex3fv(pp->pp[o]);
polys++;
}
}
glEnd();
}
}
polys /= 2;
return polys;
}
void hack_draw (xstuff_t * XStuff, double currentTime, float frameTime)
{
int i;
static int ionsReleased = 0;
static float releaseTime = 0.0f;
Display *dpy = XStuff->display;
#ifdef BENCHMARK
static int a = 1;
#endif
Window window = XStuff->window;
elapsedTime = frameTime;
#ifdef BENCHMARK
if (a++ == 1000)
exit(0);
elapsedTime = 0.1f;
#endif
// Camera movements
// first do translation (distance from center)
static float oldCameraDistance;
static float cameraDistance;
static float targetCameraDistance = -1000.0f;
static float preCameraInterp = PI;
float cameraInterp;
preCameraInterp += float (dCameraspeed) * elapsedTime * 0.01f;
cameraInterp = 0.5f - (0.5f * cos (preCameraInterp));
cameraDistance = (1.0f - cameraInterp) * oldCameraDistance + cameraInterp * targetCameraDistance;
if (preCameraInterp >= PI) {
oldCameraDistance = targetCameraDistance;
targetCameraDistance = -rsRandf (1300.0f) - 200.0f;
preCameraInterp = 0.0f;
}
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
glTranslatef (0.0, 0.0, cameraDistance);
// then do rotation
static rsVec radialVel = rsVec (0.0f, 0.0f, 0.0f);
static rsVec targetRadialVel = radialVel;
static rsQuat rotQuat = rsQuat (0.0f, 0.0f, 0.0f, 1.0f);
rsVec radialVelDiff = targetRadialVel - radialVel;
float changeRemaining = radialVelDiff.normalize ();
float change = float (dCameraspeed) * 0.0002f * elapsedTime;
if (changeRemaining > change) {
radialVelDiff *= change;
radialVel += radialVelDiff;
} else {
radialVel = targetRadialVel;
if (rsRandi (2)) {
targetRadialVel = rsVec (rsRandf (1.0f), rsRandf (1.0f), rsRandf (1.0f));
targetRadialVel.normalize ();
targetRadialVel *= float (dCameraspeed) * rsRandf (0.002f);
} else
targetRadialVel = rsVec (0.0f, 0.0f, 0.0f);
}
rsVec tempRadialVel = radialVel;
float angle = tempRadialVel.normalize ();
rsQuat radialQuat;
radialQuat.make (angle, tempRadialVel[0], tempRadialVel[1], tempRadialVel[2]);
rotQuat.preMult (radialQuat);
rsMatrix rotMat;
rotMat.fromQuat (rotQuat);
// make billboard matrix for rotating particles when they are drawn
rotMat.get (billboardMat);
// Calculate new color
static rsVec oldHsl, newHsl = rsVec (rsRandf (1.0f), 1.0f, 1.0f), targetHsl;
static float colorInterp = 1.0f, colorChange;
colorInterp += elapsedTime * colorChange;
if (colorInterp >= 1.0f) {
if (!rsRandi (3) && dIons >= 100) // change color suddenly
newHsl = rsVec (rsRandf (1.0f), 1.0f - (rsRandf (1.0f) * rsRandf (1.0f)), 1.0f);
oldHsl = newHsl;
targetHsl = rsVec (rsRandf (1.0f), 1.0f - (rsRandf (1.0f) * rsRandf (1.0f)), 1.0f);
colorInterp = 0.0f;
// amount by which to change colorInterp each second
colorChange = rsRandf (0.005f * float (dSpeed)) + (0.002f * float (dSpeed));
} else {
float diff = targetHsl[0] - oldHsl[0];
if (diff < -0.5f || (diff > 0.0f && diff < 0.5f))
newHsl[0] = oldHsl[0] + colorInterp * diff;
else
newHsl[0] = oldHsl[0] - colorInterp * diff;
diff = targetHsl[1] - oldHsl[1];
newHsl[1] = oldHsl[1] + colorInterp * diff;
if (newHsl[0] < 0.0f)
newHsl[0] += 1.0f;
if (newHsl[0] > 1.0f)
newHsl[0] -= 1.0f;
hsl2rgb (newHsl[0], newHsl[1], 1.0f, newRgb[0], newRgb[1], newRgb[2]);
}
// Release ions
if (ionsReleased < dIons) {
releaseTime -= elapsedTime;
while (ionsReleased < dIons && releaseTime <= 0.0f) {
ilist[ionsReleased].start ();
ionsReleased++;
// all ions released after 2 minutes
releaseTime += 120.0f / float (dIons);
}
}
// Set interpolation value for emitters and attracters
static float wait = 0.0f;
static float preinterp = PI, interp;
static float interpconst = 0.001f;
wait -= elapsedTime;
if (wait <= 0.0f) {
preinterp += elapsedTime * float (dSpeed) * interpconst;
interp = 0.5f - (0.5f * cos (preinterp));
}
if (preinterp >= PI) {
// select new taget points (not the same pattern twice in a row)
static int newTarget = 0, lastTarget;
lastTarget = newTarget;
newTarget = rsRandi (10);
if (newTarget == lastTarget)
newTarget++;
setTargets (newTarget);
preinterp = 0.0f;
interp = 0.0f;
wait = 10.0f; // pause after forming each new pattern
interpconst = 0.001f;
if (!rsRandi (4)) // interpolate really fast sometimes
interpconst = 0.1f;
}
// Update particles
for (i = 0; i < dEmitters; i++) {
elist[i].interppos (interp);
elist[i].update ();
}
for (i = 0; i < dAttracters; i++) {
alist[i].interppos (interp);
alist[i].update ();
}
for (i = 0; i < ionsReleased; i++)
ilist[i].update ();
// Calculate surface
if (dSurface) {
for (i = 0; i < dEmitters; i++)
spheres[i].setPosition (elist[i].pos[0], elist[i].pos[1], elist[i].pos[2]);
for (i = 0; i < dAttracters; i++)
spheres[dEmitters + i].setPosition (alist[i].pos[0], alist[i].pos[1], alist[i].pos[2]);
impCrawlPointVector cpv;
for(i=0; i<dEmitters+dAttracters; i++)
spheres[i].addCrawlPoint(cpv);
surface->reset ();
static float valuetrig = 0.0f;
valuetrig += elapsedTime;
volume->setSurfaceValue(0.45f + 0.05f * cosf(valuetrig));
volume->makeSurface(cpv);
}
// Draw
// clear the screen
if (dBlur) { // partially
glMatrixMode (GL_PROJECTION);
glPushMatrix ();
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, 1.0, -1.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(0.0f, 0.0f, 0.0f, 0.5f - (float(sqrtf(sqrtf(float(dBlur)))) * 0.15495f));
glBegin(GL_TRIANGLE_STRIP);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(1.0f, 0.0f, 0.0f);
glVertex3f(0.0f, 1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glEnd();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
} else // completely
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Draw ions
glMatrixMode(GL_MODELVIEW);
glBlendFunc (GL_ONE, GL_ONE);
glBindTexture (GL_TEXTURE_2D, 1);
for (i = 0; i < ionsReleased; i++)
ilist[i].draw ();
// Draw surfaces
float brightFactor = 0;
float surfaceColor[3] = {
0.0f,
0.0f,
0.0f
};
if (dSurface) {
glBindTexture (GL_TEXTURE_2D, 2);
glEnable (GL_TEXTURE_GEN_S);
glEnable (GL_TEXTURE_GEN_T);
// find color for surfaces
if (dIons >= 100) {
if (dWireframe)
brightFactor = 2.0f / (float (dBlur + 30) * float (dBlur + 30));
else
brightFactor = 4.0f / (float (dBlur + 30) * float (dBlur + 30));
for (i = 0; i < 100; i++) {
surfaceColor[0] += ilist[i].rgb[0] * brightFactor;
surfaceColor[1] += ilist[i].rgb[1] * brightFactor;
surfaceColor[2] += ilist[i].rgb[2] * brightFactor;
}
glColor3fv (surfaceColor);
} else {
if (dWireframe)
brightFactor = 200.0f / (float (dBlur + 30) * float (dBlur + 30));
else
brightFactor = 400.0f / (float (dBlur + 30) * float (dBlur + 30));
glColor3f (newRgb[0] * brightFactor, newRgb[1] * brightFactor, newRgb[2] * brightFactor);
}
// draw the surface
glPushMatrix ();
glMultMatrixf (billboardMat);
if (dWireframe) {
glDisable (GL_TEXTURE_2D);
surface->draw_wireframe ();
glEnable (GL_TEXTURE_2D);
} else
surface->draw ();
glPopMatrix ();
glDisable (GL_TEXTURE_GEN_S);
glDisable (GL_TEXTURE_GEN_T);
}
// If graphics card does a true buffer swap instead of a copy swap
// then everything must get drawn on both buffers
if (dBlur & pfd_swap_exchange) {
glXSwapBuffers (dpy, window);
// wglSwapLayerBuffers(hdc, WGL_SWAP_MAIN_PLANE);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f (0.0f, 0.0f, 0.0f, 0.5f - (float (sqrt (sqrt (double (dBlur)))) * 0.15495f));
glPushMatrix ();
glLoadIdentity ();
glBegin (GL_TRIANGLE_STRIP);
glVertex3f (-5.0f, -4.0f, -3.0f);
glVertex3f (5.0f, -4.0f, -3.0f);
glVertex3f (-5.0f, 4.0f, -3.0f);
glVertex3f (5.0f, 4.0f, -3.0f);
glEnd ();
glPopMatrix ();
// Draw ions
glBlendFunc (GL_ONE, GL_ONE);
glBindTexture (GL_TEXTURE_2D, 1);
for (i = 0; i < ionsReleased; i++)
ilist[i].draw ();
// Draw surfaces
if (dSurface) {
glBindTexture (GL_TEXTURE_2D, 2);
glEnable (GL_TEXTURE_GEN_S);
glEnable (GL_TEXTURE_GEN_T);
if (dIons >= 100)
glColor3fv (surfaceColor);
else
glColor3f (newRgb[0] * brightFactor, newRgb[1] * brightFactor, newRgb[2] * brightFactor);
glPushMatrix ();
glMultMatrixf (billboardMat);
if (dWireframe) {
glDisable (GL_TEXTURE_2D);
surface->draw_wireframe ();
glEnable (GL_TEXTURE_2D);
} else
surface->draw ();
glPopMatrix ();
glDisable (GL_TEXTURE_GEN_S);
glDisable (GL_TEXTURE_GEN_T);
}
}
}
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
float array[] = {
10, 10, 1, 0, 0,
27, 10, 1, 0, 0,
10, 30, 1, 0, 0,
30, 10, 0, 1, 0,
47, 10, 0, 1, 0,
30, 30, 0, 1, 0,
50, 10, 0, 0, 1,
67, 10, 0, 0, 1,
50, 30, 0, 0, 1,
70, 10, 1, 0, 1,
87, 10, 1, 0, 1,
70, 30, 1, 0, 1
};
float seccol[] = {
0.2, 0.2, 0.2,
0.2, 0.2, 0.2,
0.2, 0.2, 0.2,
0.2, 0.2, 0.2,
0.2, 0.2, 0.2,
0.2, 0.2, 0.2,
0.2, 0.2, 0.2,
0.2, 0.2, 0.2,
0.2, 0.2, 0.2,
0.2, 0.2, 0.2,
0.2, 0.2, 0.2,
0.2, 0.2, 0.2,
};
float c0[] = {1, 0.2, 0.2};
float c1[] = {0.2, 1, 0.2};
float c2[] = {0.2, 0.2, 1};
float c3[] = {1, 0.2, 1};
short indices[] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
};
int i, j;
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
printf("From bottom to top:\n");
glEnable(GL_COLOR_SUM);
glLoadIdentity();
/* State change: Vertex arrays. */
glVertexPointer(2, GL_FLOAT, 20, array);
glColorPointer(3, GL_FLOAT, 20, array + 2);
glSecondaryColorPointer(3, GL_FLOAT, 0, seccol);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
/* The vertex array state should be preserved after glClear. */
glClear(GL_COLOR_BUFFER_BIT);
/* Draw. */
printf("DrawElements\n");
for (i = 0; i < 4; i++)
glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_SHORT, indices + i*3);
/* State change: Constant buffer. */
glTranslatef(0, 30, 0);
rotate_colors(array);
/* Draw. */
printf("DrawArrays\n");
for (i = 0; i < 4; i++)
glDrawArrays(GL_TRIANGLES, i*3, 3);
/* State change: Vertex arrays. */
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
/* State change: Constant buffer. */
glTranslatef(0, 30, 0);
rotate_colors(array);
/* Draw. */
printf("Begin/End\n");
for (i = 0; i < 4; i++) {
glBegin(GL_TRIANGLES);
for (j = 0; j < 3; j++) {
glColor3fv(array + i*15 + j*5 + 2);
glSecondaryColor3fv(seccol);
glVertex2fv(array + i*15 + j*5);
}
glEnd();
}
/* State change: Constant buffer. */
glTranslatef(0, 30, 0);
rotate_colors(array);
/* Create display lists. */
for (i = 0; i < 4; i++) {
glNewList(i+1, GL_COMPILE);
glBegin(GL_TRIANGLES);
for (j = 0; j < 3; j++) {
glColor3fv(array + i*15 + j*5 + 2);
glSecondaryColor3fv(seccol);
glVertex2fv(array + i*15 + j*5);
}
glEnd();
glEndList();
}
/* Draw. */
printf("CallList\n");
for (i = 0; i < 4; i++) {
glCallList(i+1);
}
pass = pass && piglit_probe_pixel_rgb(15, 15, c0);
pass = pass && piglit_probe_pixel_rgb(35, 15, c1);
pass = pass && piglit_probe_pixel_rgb(55, 15, c2);
pass = pass && piglit_probe_pixel_rgb(75, 15, c3);
pass = pass && piglit_probe_pixel_rgb(15, 45, c1);
pass = pass && piglit_probe_pixel_rgb(35, 45, c2);
pass = pass && piglit_probe_pixel_rgb(55, 45, c3);
pass = pass && piglit_probe_pixel_rgb(75, 45, c0);
pass = pass && piglit_probe_pixel_rgb(15, 75, c2);
pass = pass && piglit_probe_pixel_rgb(35, 75, c3);
pass = pass && piglit_probe_pixel_rgb(55, 75, c0);
pass = pass && piglit_probe_pixel_rgb(75, 75, c1);
pass = pass && piglit_probe_pixel_rgb(15, 105, c3);
pass = pass && piglit_probe_pixel_rgb(35, 105, c0);
pass = pass && piglit_probe_pixel_rgb(55, 105, c1);
pass = pass && piglit_probe_pixel_rgb(75, 105, c2);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void clip_draw_dopesheet_channels(const bContext *C, ARegion *ar)
{
ScrArea *sa = CTX_wm_area(C);
SpaceClip *sc = CTX_wm_space_clip(C);
View2D *v2d = &ar->v2d;
MovieClip *clip = ED_space_clip_get_clip(sc);
MovieTracking *tracking;
MovieTrackingDopesheet *dopesheet;
MovieTrackingDopesheetChannel *channel;
uiStyle *style = UI_style_get();
uiBlock *block;
int fontid = style->widget.uifont_id;
int height;
float y;
PropertyRNA *chan_prop_lock;
if (!clip)
return;
tracking = &clip->tracking;
dopesheet = &tracking->dopesheet;
height = (dopesheet->tot_channel * CHANNEL_STEP) + (CHANNEL_HEIGHT);
if (height > BLI_rcti_size_y(&v2d->mask)) {
/* don't use totrect set, as the width stays the same
* (NOTE: this is ok here, the configuration is pretty straightforward)
*/
v2d->tot.ymin = (float)(-height);
}
/* need to do a view-sync here, so that the keys area doesn't jump around (it must copy this) */
UI_view2d_sync(NULL, sa, v2d, V2D_LOCK_COPY);
/* loop through channels, and set up drawing depending on their type
* first pass: just the standard GL-drawing for backdrop + text
*/
y = (float) CHANNEL_FIRST;
BLF_size(fontid, 11.0f * U.pixelsize, U.dpi);
for (channel = dopesheet->channels.first; channel; channel = channel->next) {
float yminc = (float) (y - CHANNEL_HEIGHT_HALF);
float ymaxc = (float) (y + CHANNEL_HEIGHT_HALF);
/* check if visible */
if (IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax))
{
MovieTrackingTrack *track = channel->track;
float font_height, color[3];
bool sel = (track->flag & TRACK_DOPE_SEL) != 0;
track_channel_color(track, NULL, color);
glColor3fv(color);
glRectf(v2d->cur.xmin, (float) y - CHANNEL_HEIGHT_HALF,
v2d->cur.xmax + EXTRA_SCROLL_PAD, (float) y + CHANNEL_HEIGHT_HALF);
if (sel)
UI_ThemeColor(TH_TEXT_HI);
else
UI_ThemeColor(TH_TEXT);
font_height = BLF_height(fontid, channel->name, sizeof(channel->name));
BLF_position(fontid, v2d->cur.xmin + CHANNEL_PAD,
y - font_height / 2.0f, 0.0f);
BLF_draw(fontid, channel->name, strlen(channel->name));
}
/* adjust y-position for next one */
y -= CHANNEL_STEP;
}
/* second pass: widgets */
block = UI_block_begin(C, ar, __func__, UI_EMBOSS);
y = (float) CHANNEL_FIRST;
/* get RNA properties (once) */
chan_prop_lock = RNA_struct_type_find_property(&RNA_MovieTrackingTrack, "lock");
BLI_assert(chan_prop_lock);
glEnable(GL_BLEND);
for (channel = dopesheet->channels.first; channel; channel = channel->next) {
float yminc = (float)(y - CHANNEL_HEIGHT_HALF);
float ymaxc = (float)(y + CHANNEL_HEIGHT_HALF);
/* check if visible */
if (IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax))
{
MovieTrackingTrack *track = channel->track;
const int icon = (track->flag & TRACK_LOCKED) ? ICON_LOCKED : ICON_UNLOCKED;
PointerRNA ptr;
RNA_pointer_create(&clip->id, &RNA_MovieTrackingTrack, track, &ptr);
UI_block_emboss_set(block, UI_EMBOSS_NONE);
uiDefIconButR_prop(block, UI_BTYPE_ICON_TOGGLE, 1, icon,
v2d->cur.xmax - UI_UNIT_X - CHANNEL_PAD, y - UI_UNIT_Y / 2.0f,
UI_UNIT_X, UI_UNIT_Y, &ptr, chan_prop_lock, 0, 0, 0, 0, 0, NULL);
UI_block_emboss_set(block, UI_EMBOSS);
}
/* adjust y-position for next one */
y -= CHANNEL_STEP;
}
glDisable(GL_BLEND);
UI_block_end(C, block);
UI_block_draw(C, block);
}
/* draw method for ant */
static Bool draw_ant(antspotlightstruct *mp,
const GLfloat *Material, int mono, int shadow,
float ant_step, Bool (*sphere)(float), Bool (*cone)(float))
{
float cos1 = cos(ant_step);
float cos2 = cos(ant_step + 2 * Pi / 3);
float cos3 = cos(ant_step + 4 * Pi / 3);
float sin1 = sin(ant_step);
float sin2 = sin(ant_step + 2 * Pi / 3);
float sin3 = sin(ant_step + 4 * Pi / 3);
/* Apparently this is a performance killer on many systems...
glEnable(GL_POLYGON_SMOOTH);
*/
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mp->mono ? MaterialGray5 : Material);
glEnable(GL_CULL_FACE);
glPushMatrix();
glScalef(1, 1.3, 1);
if(!((*sphere)(0.18)))
return False;
glScalef(1, 1 / 1.3, 1);
glTranslatef(0.00, 0.30, 0.00);
if(!((*sphere)(0.2)))
return False;
glTranslatef(-0.05, 0.17, 0.05);
glRotatef(-90, 1, 0, 0);
glRotatef(-25, 0, 1, 0);
if(!((*cone)(0.05)))
return False;
glTranslatef(0.00, 0.10, 0.00);
if(!((*cone)(0.05)))
return False;
glRotatef(25, 0, 1, 0);
glRotatef(90, 1, 0, 0);
glScalef(1, 1.3, 1);
glTranslatef(0.15, -0.65, 0.05);
if(!((*sphere)(0.25)))
return False;
glScalef(1, 1 / 1.3, 1);
glPopMatrix();
glDisable(GL_CULL_FACE);
glDisable(GL_LIGHTING);
/* ANTENNAS */
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBegin(GL_LINES);
glColor3fv(mp->mono ? MaterialGray5 : Material);
glVertex3f(0.00, 0.30, 0.00);
glColor3fv(MaterialGray);
glVertex3f(0.40, 0.70, 0.40);
glColor3fv(mp->mono ? MaterialGray5 : Material);
glVertex3f(0.00, 0.30, 0.00);
glColor3fv(MaterialGray);
glVertex3f(0.40, 0.70, -0.40);
glEnd();
if(!shadow) {
glBegin(GL_POINTS);
glColor3fv(mp->mono ? MaterialGray6 : MaterialGray5);
glVertex3f(0.40, 0.70, 0.40);
glVertex3f(0.40, 0.70, -0.40);
glEnd();
}
/* LEFT-FRONT ARM */
glBegin(GL_LINE_STRIP);
glColor3fv(mp->mono ? MaterialGray5 : Material);
glVertex3f(0.00, 0.05, 0.18);
glVertex3f(0.35 + 0.05 * cos1, 0.15, 0.25);
glColor3fv(MaterialGray);
glVertex3f(-0.20 + 0.05 * cos1, 0.25 + 0.1 * sin1, 0.45);
glEnd();
/* LEFT-CENTER ARM */
glBegin(GL_LINE_STRIP);
glColor3fv(mp->mono ? MaterialGray5 : Material);
glVertex3f(0.00, 0.00, 0.18);
glVertex3f(0.35 + 0.05 * cos2, 0.00, 0.25);
glColor3fv(MaterialGray);
glVertex3f(-0.20 + 0.05 * cos2, 0.00 + 0.1 * sin2, 0.45);
glEnd();
/* LEFT-BACK ARM */
glBegin(GL_LINE_STRIP);
glColor3fv(mp->mono ? MaterialGray5 : Material);
glVertex3f(0.00, -0.05, 0.18);
glVertex3f(0.35 + 0.05 * cos3, -0.15, 0.25);
glColor3fv(MaterialGray);
glVertex3f(-0.20 + 0.05 * cos3, -0.25 + 0.1 * sin3, 0.45);
glEnd();
/* RIGHT-FRONT ARM */
glBegin(GL_LINE_STRIP);
glColor3fv(mp->mono ? MaterialGray5 : Material);
glVertex3f(0.00, 0.05, -0.18);
glVertex3f(0.35 - 0.05 * sin1, 0.15, -0.25);
glColor3fv(MaterialGray);
glVertex3f(-0.20 - 0.05 * sin1, 0.25 + 0.1 * cos1, -0.45);
glEnd();
/* RIGHT-CENTER ARM */
glBegin(GL_LINE_STRIP);
glColor3fv(mp->mono ? MaterialGray5 : Material);
glVertex3f(0.00, 0.00, -0.18);
glVertex3f(0.35 - 0.05 * sin2, 0.00, -0.25);
glColor3fv(MaterialGray);
glVertex3f(-0.20 - 0.05 * sin2, 0.00 + 0.1 * cos2, -0.45);
glEnd();
/* RIGHT-BACK ARM */
glBegin(GL_LINE_STRIP);
glColor3fv(mp->mono ? MaterialGray5 : Material);
glVertex3f(0.00, -0.05, -0.18);
glVertex3f(0.35 - 0.05 * sin3, -0.15, -0.25);
glColor3fv(MaterialGray);
glVertex3f(-0.20 - 0.05 * sin3, -0.25 + 0.1 * cos3, -0.45);
glEnd();
if(!shadow) {
glBegin(GL_POINTS);
glColor3fv(MaterialGray5);
glVertex3f(-0.20 + 0.05 * cos1, 0.25 + 0.1 * sin1, 0.45);
glVertex3f(-0.20 + 0.05 * cos2, 0.00 + 0.1 * sin2, 0.45);
glVertex3f(-0.20 + 0.05 * cos3, -0.25 + 0.1 * sin3, 0.45);
glVertex3f(-0.20 - 0.05 * sin1, 0.25 + 0.1 * cos1, -0.45);
glVertex3f(-0.20 - 0.05 * sin2, 0.00 + 0.1 * cos2, -0.45);
glVertex3f(-0.20 - 0.05 * sin3, -0.25 + 0.1 * cos3, -0.45);
glEnd();
}
glEnable(GL_LIGHTING);
return True;
}
static void SetColor(int c)
{
glColor3fv(RGBMap[c]);
}
void ColorModifier::begin() {
glPushAttrib(GL_CURRENT_BIT | GL_LIGHTING_BIT);
glColor3fv(color_);
}
void ApplicationOverlay::renderAudioMeter() {
Application* application = Application::getInstance();
GLCanvas* glWidget = application->getGLWidget();
Audio* audio = application->getAudio();
// Display a single screen-size quad to create an alpha blended 'collision' flash
if (audio->getCollisionFlashesScreen()) {
float collisionSoundMagnitude = audio->getCollisionSoundMagnitude();
const float VISIBLE_COLLISION_SOUND_MAGNITUDE = 0.5f;
if (collisionSoundMagnitude > VISIBLE_COLLISION_SOUND_MAGNITUDE) {
renderCollisionOverlay(glWidget->width(), glWidget->height(),
audio->getCollisionSoundMagnitude());
}
}
// Audio VU Meter and Mute Icon
const int MUTE_ICON_SIZE = 24;
const int AUDIO_METER_INSET = 2;
const int MUTE_ICON_PADDING = 10;
const int AUDIO_METER_WIDTH = MIRROR_VIEW_WIDTH - MUTE_ICON_SIZE - AUDIO_METER_INSET - MUTE_ICON_PADDING;
const int AUDIO_METER_SCALE_WIDTH = AUDIO_METER_WIDTH - 2 * AUDIO_METER_INSET;
const int AUDIO_METER_HEIGHT = 8;
const int AUDIO_METER_GAP = 5;
const int AUDIO_METER_X = MIRROR_VIEW_LEFT_PADDING + MUTE_ICON_SIZE + AUDIO_METER_INSET + AUDIO_METER_GAP;
int audioMeterY;
bool smallMirrorVisible = Menu::getInstance()->isOptionChecked(MenuOption::Mirror) && !OculusManager::isConnected();
bool boxed = smallMirrorVisible &&
!Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror);
if (boxed) {
audioMeterY = MIRROR_VIEW_HEIGHT + AUDIO_METER_GAP + MUTE_ICON_PADDING;
} else {
audioMeterY = AUDIO_METER_GAP + MUTE_ICON_PADDING;
}
const float AUDIO_METER_BLUE[] = { 0.0, 0.0, 1.0 };
const float AUDIO_METER_GREEN[] = { 0.0, 1.0, 0.0 };
const float AUDIO_METER_RED[] = { 1.0, 0.0, 0.0 };
const float AUDIO_GREEN_START = 0.25 * AUDIO_METER_SCALE_WIDTH;
const float AUDIO_RED_START = 0.80 * AUDIO_METER_SCALE_WIDTH;
const float CLIPPING_INDICATOR_TIME = 1.0f;
const float AUDIO_METER_AVERAGING = 0.5;
const float LOG2 = log(2.0f);
const float METER_LOUDNESS_SCALE = 2.8f / 5.0f;
const float LOG2_LOUDNESS_FLOOR = 11.0f;
float audioLevel = 0.0f;
float loudness = audio->getLastInputLoudness() + 1.0f;
_trailingAudioLoudness = AUDIO_METER_AVERAGING * _trailingAudioLoudness + (1.0f - AUDIO_METER_AVERAGING) * loudness;
float log2loudness = log(_trailingAudioLoudness) / LOG2;
if (log2loudness <= LOG2_LOUDNESS_FLOOR) {
audioLevel = (log2loudness / LOG2_LOUDNESS_FLOOR) * METER_LOUDNESS_SCALE * AUDIO_METER_SCALE_WIDTH;
} else {
audioLevel = (log2loudness - (LOG2_LOUDNESS_FLOOR - 1.0f)) * METER_LOUDNESS_SCALE * AUDIO_METER_SCALE_WIDTH;
}
if (audioLevel > AUDIO_METER_SCALE_WIDTH) {
audioLevel = AUDIO_METER_SCALE_WIDTH;
}
bool isClipping = ((audio->getTimeSinceLastClip() > 0.0f) && (audio->getTimeSinceLastClip() < CLIPPING_INDICATOR_TIME));
if ((audio->getTimeSinceLastClip() > 0.0f) && (audio->getTimeSinceLastClip() < CLIPPING_INDICATOR_TIME)) {
const float MAX_MAGNITUDE = 0.7f;
float magnitude = MAX_MAGNITUDE * (1 - audio->getTimeSinceLastClip() / CLIPPING_INDICATOR_TIME);
renderCollisionOverlay(glWidget->width(), glWidget->height(), magnitude, 1.0f);
}
audio->renderToolBox(MIRROR_VIEW_LEFT_PADDING + AUDIO_METER_GAP, audioMeterY, boxed);
audio->renderScope(glWidget->width(), glWidget->height());
audio->renderStats(WHITE_TEXT, glWidget->width(), glWidget->height());
glBegin(GL_QUADS);
if (isClipping) {
glColor3f(1, 0, 0);
} else {
glColor3f(0.475f, 0.475f, 0.475f);
}
audioMeterY += AUDIO_METER_HEIGHT;
glColor3f(0, 0, 0);
// Draw audio meter background Quad
glVertex2i(AUDIO_METER_X, audioMeterY);
glVertex2i(AUDIO_METER_X + AUDIO_METER_WIDTH, audioMeterY);
glVertex2i(AUDIO_METER_X + AUDIO_METER_WIDTH, audioMeterY + AUDIO_METER_HEIGHT);
glVertex2i(AUDIO_METER_X, audioMeterY + AUDIO_METER_HEIGHT);
if (audioLevel > AUDIO_RED_START) {
if (!isClipping) {
glColor3fv(AUDIO_METER_RED);
} else {
glColor3f(1, 1, 1);
}
// Draw Red Quad
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET + AUDIO_RED_START, audioMeterY + AUDIO_METER_INSET);
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET + audioLevel, audioMeterY + AUDIO_METER_INSET);
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET + audioLevel, audioMeterY + AUDIO_METER_HEIGHT - AUDIO_METER_INSET);
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET + AUDIO_RED_START, audioMeterY + AUDIO_METER_HEIGHT - AUDIO_METER_INSET);
audioLevel = AUDIO_RED_START;
}
if (audioLevel > AUDIO_GREEN_START) {
if (!isClipping) {
glColor3fv(AUDIO_METER_GREEN);
} else {
glColor3f(1, 1, 1);
}
// Draw Green Quad
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET + AUDIO_GREEN_START, audioMeterY + AUDIO_METER_INSET);
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET + audioLevel, audioMeterY + AUDIO_METER_INSET);
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET + audioLevel, audioMeterY + AUDIO_METER_HEIGHT - AUDIO_METER_INSET);
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET + AUDIO_GREEN_START, audioMeterY + AUDIO_METER_HEIGHT - AUDIO_METER_INSET);
audioLevel = AUDIO_GREEN_START;
}
// Draw Blue Quad
if (!isClipping) {
glColor3fv(AUDIO_METER_BLUE);
} else {
glColor3f(1, 1, 1);
}
// Draw Blue (low level) quad
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET, audioMeterY + AUDIO_METER_INSET);
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET + audioLevel, audioMeterY + AUDIO_METER_INSET);
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET + audioLevel, audioMeterY + AUDIO_METER_HEIGHT - AUDIO_METER_INSET);
glVertex2i(AUDIO_METER_X + AUDIO_METER_INSET, audioMeterY + AUDIO_METER_HEIGHT - AUDIO_METER_INSET);
glEnd();
}
//--------------------------------------------------------------------------------------------------
/// Draw the legend using immediate mode OpenGL
//--------------------------------------------------------------------------------------------------
void OverlayScalarMapperLegend::renderLegendImmediateMode(OpenGLContext* oglContext, OverlayColorLegendLayoutInfo* layout)
{
#ifdef CVF_OPENGL_ES
CVF_UNUSED(layout);
CVF_FAIL_MSG("Not supported on OpenGL ES");
#else
CVF_TIGHT_ASSERT(layout);
CVF_TIGHT_ASSERT(layout->size.x() > 0);
CVF_TIGHT_ASSERT(layout->size.y() > 0);
RenderStateDepth depth(false);
depth.applyOpenGL(oglContext);
RenderStateLighting_FF lighting(false);
lighting.applyOpenGL(oglContext);
// All vertices. Initialized here to set Z to zero once and for all.
static float vertexArray[] =
{
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f,
};
// Per vector convenience pointers
float* v0 = &vertexArray[0];
float* v1 = &vertexArray[3];
float* v2 = &vertexArray[6];
float* v3 = &vertexArray[9];
float* v4 = &vertexArray[12];
// Constant coordinates
v0[0] = v3[0] = layout->x0;
v1[0] = v4[0] = layout->x1;
// Render color bar as one colored quad per pixel
int legendHeightPixelCount = static_cast<int>(layout->tickPixelPos->get(m_tickValues.size() - 1) - layout->tickPixelPos->get(0) + 0.01);
if (m_scalarMapper.notNull())
{
int iPx;
for (iPx = 0; iPx < legendHeightPixelCount; iPx++)
{
const Color3ub& clr = m_scalarMapper->mapToColor(m_scalarMapper->domainValue((iPx+0.5)/legendHeightPixelCount));
float y0 = static_cast<float>(layout->legendRect.min().y() + iPx);
float y1 = static_cast<float>(layout->legendRect.min().y() + iPx + 1);
// Dynamic coordinates for rectangle
v0[1] = v1[1] = y0;
v3[1] = v4[1] = y1;
// Draw filled rectangle elements
glColor3ubv(clr.ptr());
glBegin(GL_TRIANGLE_FAN);
glVertex3fv(v0);
glVertex3fv(v1);
glVertex3fv(v4);
glVertex3fv(v3);
glEnd();
}
}
// Render frame
// Dynamic coordinates for tickmarks-lines
bool isRenderingFrame = true;
if (isRenderingFrame)
{
v0[0] = v2[0] = layout->legendRect.min().x()-0.5f;
v1[0] = v3[0] = layout->legendRect.max().x()-0.5f;
v0[1] = v1[1] = layout->legendRect.min().y()-0.5f;
v2[1] = v3[1] = layout->legendRect.max().y()-0.5f;
glColor3fv(m_color.ptr());
glBegin(GL_LINES);
glVertex3fv(v0);
glVertex3fv(v1);
glVertex3fv(v1);
glVertex3fv(v3);
glVertex3fv(v3);
glVertex3fv(v2);
glVertex3fv(v2);
glVertex3fv(v0);
glEnd();
}
// Render tickmarks
bool isRenderingTicks = true;
if (isRenderingTicks)
{
// Constant coordinates
v0[0] = layout->x0;
v1[0] = layout->x1 - 0.5f*(layout->tickX - layout->x1) - 0.5f;
v2[0] = layout->x1;
v3[0] = layout->tickX - 0.5f*(layout->tickX - layout->x1) - 0.5f;
v4[0] = layout->tickX;
size_t ic;
for (ic = 0; ic < m_tickValues.size(); ic++)
{
float y0 = static_cast<float>(layout->legendRect.min().y() + layout->tickPixelPos->get(ic) - 0.5f);
// Dynamic coordinates for tickmarks-lines
v0[1] = v1[1] = v2[1] = v3[1] = v4[1] = y0;
glColor3fv(m_color.ptr());
glBegin(GL_LINES);
if ( m_visibleTickLabels[ic])
{
glVertex3fv(v0);
glVertex3fv(v4);
}
else
{
glVertex3fv(v2);
glVertex3fv(v3);
}
glEnd();
}
}
// Reset render states
RenderStateLighting_FF resetLighting;
resetLighting.applyOpenGL(oglContext);
RenderStateDepth resetDepth;
resetDepth.applyOpenGL(oglContext);
CVF_CHECK_OGL(oglContext);
#endif // CVF_OPENGL_ES
}
void Bonus::draw() const
{
const vector2& p_end = pos_ + sz_;
glColor3fv(color_);
drawRectangle(pos_, p_end);
}
/* draw an ant */
static Bool draw_antinspect_ant(ModeInfo *mi, antinspectstruct * mp,
const float *Material, int mono,
Bool (*sphere)(float), Bool (*cone)(float))
{
float cos1 = cos(mp->ant_step);
float cos2 = cos(mp->ant_step + 2 * Pi / 3);
float cos3 = cos(mp->ant_step + 4 * Pi / 3);
float sin1 = sin(mp->ant_step);
float sin2 = sin(mp->ant_step + 2 * Pi / 3);
float sin3 = sin(mp->ant_step + 4 * Pi / 3);
if (mono)
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialGray5);
else
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Material);
glEnable(GL_CULL_FACE);
glPushMatrix();
glScalef(1, 1.3, 1);
if (!((*sphere)(0.18)))
return False;
glScalef(1, 1 / 1.3, 1);
glTranslatef(0.00, 0.30, 0.00);
if (!((*sphere)(0.2)))
return False;
glTranslatef(-0.05, 0.17, 0.05);
glRotatef(-90, 1, 0, 0);
glRotatef(-25, 0, 1, 0);
if (!((*cone)(0.05)))
return False;
glTranslatef(0.00, 0.10, 0.00);
if (!((*cone)(0.05)))
return False;
glRotatef(25, 0, 1, 0);
glRotatef(90, 1, 0, 0);
glScalef(1, 1.3, 1);
glTranslatef(0.15, -0.65, 0.05);
if (!((*sphere)(0.25)))
return False;
glScalef(1, 1 / 1.3, 1);
glPopMatrix();
glDisable(GL_CULL_FACE);
glDisable(GL_LIGHTING);
/* ANTENNAS */
glBegin(GL_LINES);
if (mono)
glColor3fv(MaterialGray5);
else
glColor3fv(Material);
glVertex3f(0.00, 0.30, 0.00);
glColor3fv(MaterialGray);
glVertex3f(0.40, 0.70, 0.40);
mi->polygon_count++;
if (mono)
glColor3fv(MaterialGray5);
else
glColor3fv(Material);
glVertex3f(0.00, 0.30, 0.00);
glColor3fv(MaterialGray);
glVertex3f(0.40, 0.70, -0.40);
mi->polygon_count++;
glEnd();
glBegin(GL_POINTS);
if (mono)
glColor3fv(MaterialGray6);
else
glColor3fv(Material);
glVertex3f(0.40, 0.70, 0.40);
mi->polygon_count++;
glVertex3f(0.40, 0.70, -0.40);
mi->polygon_count++;
glEnd();
/* LEFT-FRONT ARM */
glBegin(GL_LINE_STRIP);
if (mono)
glColor3fv(MaterialGray5);
else
glColor3fv(Material);
glVertex3f(0.00, 0.05, 0.18);
glVertex3f(0.35 + 0.05 * cos1, 0.15, 0.25);
mi->polygon_count++;
glColor3fv(MaterialGray);
glVertex3f(-0.20 + 0.05 * cos1, 0.25 + 0.1 * sin1, 0.45);
mi->polygon_count++;
glEnd();
/* LEFT-CENTER ARM */
glBegin(GL_LINE_STRIP);
if (mono)
glColor3fv(MaterialGray5);
else
glColor3fv(Material);
glVertex3f(0.00, 0.00, 0.18);
glVertex3f(0.35 + 0.05 * cos2, 0.00, 0.25);
mi->polygon_count++;
glColor3fv(MaterialGray);
glVertex3f(-0.20 + 0.05 * cos2, 0.00 + 0.1 * sin2, 0.45);
mi->polygon_count++;
glEnd();
mi->polygon_count++;
/* LEFT-BACK ARM */
glBegin(GL_LINE_STRIP);
if (mono)
glColor3fv(MaterialGray5);
else
glColor3fv(Material);
glVertex3f(0.00, -0.05, 0.18);
glVertex3f(0.35 + 0.05 * cos3, -0.15, 0.25);
mi->polygon_count++;
glColor3fv(MaterialGray);
glVertex3f(-0.20 + 0.05 * cos3, -0.25 + 0.1 * sin3, 0.45);
mi->polygon_count++;
glEnd();
/* RIGHT-FRONT ARM */
glBegin(GL_LINE_STRIP);
if (mono)
glColor3fv(MaterialGray5);
else
glColor3fv(Material);
glVertex3f(0.00, 0.05, -0.18);
glVertex3f(0.35 - 0.05 * sin1, 0.15, -0.25);
mi->polygon_count++;
glColor3fv(MaterialGray);
glVertex3f(-0.20 - 0.05 * sin1, 0.25 + 0.1 * cos1, -0.45);
mi->polygon_count++;
glEnd();
/* RIGHT-CENTER ARM */
glBegin(GL_LINE_STRIP);
if (mono)
glColor3fv(MaterialGray5);
else
glColor3fv(Material);
glVertex3f(0.00, 0.00, -0.18);
glVertex3f(0.35 - 0.05 * sin2, 0.00, -0.25);
mi->polygon_count++;
glColor3fv(MaterialGray);
glVertex3f(-0.20 - 0.05 * sin2, 0.00 + 0.1 * cos2, -0.45);
mi->polygon_count++;
glEnd();
/* RIGHT-BACK ARM */
glBegin(GL_LINE_STRIP);
if (mono)
glColor3fv(MaterialGray5);
else
glColor3fv(Material);
glVertex3f(0.00, -0.05, -0.18);
glVertex3f(0.35 - 0.05 * sin3, -0.15, -0.25);
mi->polygon_count++;
glColor3fv(MaterialGray);
glVertex3f(-0.20 - 0.05 * sin3, -0.25 + 0.1 * cos3, -0.45);
mi->polygon_count++;
glEnd();
glEnable(GL_LIGHTING);
return True;
}
void setNodeColor(size_t node_index){
if( node_index == arm.current_node_index )
glColor3fv(activeNodeColor);
else
glColor3fv(NodeColor);
}
// int main(int argc, char *argv[])
int APIENTRY WinMain(HINSTANCE hCurrentInst, HINSTANCE hPreviousInst,LPSTR lpszCmdLine, int nCmdShow)
{
SpringNetwork cloth = SpringNetworkCreateRectangular(17, 17, 1.0f);
for (auto &v : cloth.X) v.z -= 1.75f; // put cloth object at 0,0,-1.5 region, view/camera will be at origin.
cloth.gravity = float3(0, -10.0f, 0); // normally i perfer z-up for any environment or "world" space.
cloth.dt = 0.033f; // speed it up a bit (regardless of fps, each frame advances cloth 1/30th of a second instead of just 1/60th).
GLWin glwin("TestCloth sample");
glwin.keyboardfunc = OnKeyboard;
InitTex(); // just initializes a checkerboard default texture
int selection = 0; // index of currently selected point
while (glwin.WindowUp())
{
int point_to_unpin = -1; // if we temporarily move pin a point, we have to unpin it later after simulation.
if (!glwin.MouseState) // on mouse drag
{
float3 v = glwin.MouseVector; // assumes camera at 0,0,0 looking down -z axis
selection = std::max_element(cloth.X.begin(), cloth.X.end(), [&v](const float3&a, const float3&b)->bool{return dot(v, normalize(a)) < dot(v, normalize(b)); })- cloth.X.begin();
}
else
{
if (!cloth.PointStatusSet(selection, -1))
cloth.PointStatusSet((point_to_unpin = selection), 1);
const float3 &v = glwin.MouseVector;
cloth.X[selection] = v * (dot(v, cloth.X[selection]) / dot(v, v) *(1.0f + glwin.mousewheel*0.1f));
}
cloth.Simulate();
if(point_to_unpin >=0)
cloth.PointStatusSet(point_to_unpin, 0);
glPushAttrib(GL_ALL_ATTRIB_BITS);
glViewport(0, 0, glwin.res.x,glwin.res.y); // Set up the viewport
glClearColor(0.1f, 0.1f, 0.15f, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluPerspective(glwin.ViewAngle, (double)glwin.aspect_ratio(), 0.01, 10);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
gluLookAt(0, 0, 0, 0, 0, -1, 0, 1, 0);
glEnable(GL_DEPTH_TEST);
glDisable(GL_TEXTURE_2D);
glPointSize(3);
glBegin(GL_POINTS);
for (unsigned int i = 0; i < cloth.X.size(); i++ )
glColor3f((i==selection)?1.0f:0 , 1, 0.5f), glVertex3fv(cloth.X[i]);
glEnd();
if (g_wireframe)
{
glBegin(GL_LINES);
SpringNetworkDrawSprings(&cloth, [](const float3 &a, const float3 &b, const float3 &c){glColor3fv(c); glVertex3fv(a); glVertex3fv(b); });
glColor3f(1, 0, 0);
glEnd();
}
else
{
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(1., 1. / (float)0x10000);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glColor3f(0.5f, 0.5f, 0.5f);
glBegin(GL_QUADS);
for (auto const & q: cloth.quads)
{
for (int c = 0; c <4; c++)
glTexCoord2f(q[c]%17/16.0f,q[c]/17/16.0f),glNormal3fv(cloth.N[q[c]]), glVertex3fv(cloth.X[q[c]]);
}
glEnd();
}
// Restore state
glPopMatrix(); //should be currently in modelview mode
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glPopAttrib();
glMatrixMode(GL_MODELVIEW);
glwin.PrintString({ 0, 0 }, "Press ESC to quit. w toggles wireframe. ");
glwin.PrintString({ 0, 1 }, "Use left mouse motion and wheel to move points.");
glwin.PrintString({ 0, 2 }, "(w)ireframe %s vert selected %d", ((g_wireframe) ? "ON " : "OFF"), selection);
# ifdef _DEBUG
glwin.PrintString({ 2, -1 }, "Running DEBUG Version. Performance may be SLoooow.", 2, -1);
# endif
glwin.SwapBuffers();
}
std::cout << "\n";
return 0;
}
void draw_3d_object_detail(object3d * object_id, Uint32 material_index, Uint32 use_lightning,
Uint32 use_textures, Uint32 use_extra_textures)
{
e3d_vertex_data* vertex_layout;
Uint8 * data_ptr;
// check for having to load the arrays
load_e3d_detail_if_needed(object_id->e3d_data);
CHECK_GL_ERRORS();
//also, update the last time this object was used
object_id->last_acessed_time = cur_time;
//debug
if (object_id->self_lit && (!is_day || dungeon) && use_lightning)
{
glColor3fv(object_id->color);
}
CHECK_GL_ERRORS();
glPushMatrix();//we don't want to affect the rest of the scene
glMultMatrixf(object_id->matrix);
CHECK_GL_ERRORS();
if (!dungeon && (clouds_shadows || use_shadow_mapping) && use_extra_textures)
{
VECTOR4 plane;
ELglActiveTextureARB(detail_unit);
memcpy(plane, object_id->clouds_planes[0], sizeof(VECTOR4));
plane[3] += clouds_movement_u;
glTexGenfv(GL_S, GL_EYE_PLANE, plane);
memcpy(plane, object_id->clouds_planes[1], sizeof(VECTOR4));
plane[3] += clouds_movement_v;
glTexGenfv(GL_T, GL_EYE_PLANE, plane);
ELglActiveTextureARB(base_unit);
}
// watch for a change
if (object_id->e3d_data != cur_e3d)
{
if ((cur_e3d != NULL) && (use_compiled_vertex_array))
{
ELglUnlockArraysEXT();
}
if (use_vertex_buffers)
{
ELglBindBufferARB(GL_ARRAY_BUFFER_ARB,
object_id->e3d_data->vertex_vbo);
data_ptr = 0;
}
else
{
data_ptr = object_id->e3d_data->vertex_data;
}
vertex_layout = object_id->e3d_data->vertex_layout;
if ((vertex_layout->normal_count > 0) && use_lightning)
{
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(vertex_layout->normal_type, vertex_layout->size,
data_ptr + vertex_layout->normal_offset);
}
else
{
glDisableClientState(GL_NORMAL_ARRAY);
glNormal3f(0.0f, 0.0f, 1.0f);
}
if (use_textures)
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(vertex_layout->texture_count, vertex_layout->texture_type,
vertex_layout->size, data_ptr + vertex_layout->texture_offset);
}
else
{
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glVertexPointer(vertex_layout->position_count, vertex_layout->position_type,
vertex_layout->size, data_ptr + vertex_layout->position_offset);
if (use_vertex_buffers)
{
ELglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,
object_id->e3d_data->indices_vbo);
}
// lock this new one
if (use_compiled_vertex_array)
{
ELglLockArraysEXT(0, object_id->e3d_data->vertex_no);
}
// gather statistics
if (object_id->e3d_data != cur_e3d)
{
#ifdef DEBUG
if ((cur_e3d_count > 0) && (cur_e3d != NULL))
{
e3d_count++;
e3d_total += cur_e3d_count;
}
cur_e3d_count = 0;
#endif //DEBUG
cur_e3d = object_id->e3d_data;
}
}
#ifdef DEBUG
cur_e3d_count++;
#endif //DEBUG
if (use_textures)
{
glEnable(GL_TEXTURE_2D);
#ifdef NEW_TEXTURES
bind_texture(object_id->e3d_data->materials[material_index].texture);
#else /* NEW_TEXTURES */
get_and_set_texture_id(object_id->e3d_data->materials[material_index].texture);
#endif /* NEW_TEXTURES */
}
else
{
glDisable(GL_TEXTURE_2D);
}
if (use_draw_range_elements && ELglDrawRangeElementsEXT)
ELglDrawRangeElementsEXT(GL_TRIANGLES,
object_id->e3d_data->materials[material_index].triangles_indices_min,
object_id->e3d_data->materials[material_index].triangles_indices_max,
object_id->e3d_data->materials[material_index].triangles_indices_count,
object_id->e3d_data->index_type,
object_id->e3d_data->materials[material_index].triangles_indices_index);
else
glDrawElements(GL_TRIANGLES,
object_id->e3d_data->materials[material_index].triangles_indices_count,
object_id->e3d_data->index_type,
object_id->e3d_data->materials[material_index].triangles_indices_index);
glPopMatrix();//restore the scene
CHECK_GL_ERRORS();
//OK, let's check if our mouse is over...
#ifdef MAP_EDITOR2
if (selected_3d_object == -1 && read_mouse_now && mouse_in_sphere(object_id->x_pos, object_id->y_pos, object_id->z_pos, object_id->e3d_data->radius))
anything_under_the_mouse(object_id->id, UNDER_MOUSE_3D_OBJ);
#endif
}
void CMiniMap::DrawForReal(bool use_geo)
{
SCOPED_TIMER("MiniMap::DrawForReal");
//glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPushAttrib(GL_DEPTH_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glDepthMask(GL_FALSE);
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_MODELVIEW);
if (minimized) {
if (!slaveDrawMode) {
DrawMinimizedButton();
}
glPopAttrib();
glEnable(GL_TEXTURE_2D);
return;
}
// draw the frameborder
if (!slaveDrawMode && !globalRendering->dualScreenMode && !maximized) {
glEnable(GL_BLEND);
DrawFrame();
glDisable(GL_BLEND);
}
bool resetTextureMatrix = false;
if (use_geo) {
glPushMatrix();
// switch to normalized minimap coords
if (globalRendering->dualScreenMode) {
glViewport(xpos, ypos, width, height);
glScalef(width * globalRendering->pixelX, height * globalRendering->pixelY, 1.0f);
} else {
glTranslatef(xpos * globalRendering->pixelX, ypos * globalRendering->pixelY, 0.0f);
glScalef(width * globalRendering->pixelX, height * globalRendering->pixelY, 1.0f);
}
/* FIXME: fix mouse handling too and make it fully customizable, so Lua can rotate the minimap to any angle
CCameraController* camController = &camHandler->GetCurrentController();
COverheadController* taCam = dynamic_cast<COverheadController*>(camController);
SmoothController* smCam = dynamic_cast<SmoothController*>(camController);
if ((taCam && taCam->flipped) || (smCam && smCam->flipped)) {
glTranslatef(1.0f, 1.0f, 0.0f);
glScalef(-1.0f, -1.0f, 1.0f);
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glTranslatef(1.0f, 1.0f, 0.0f);
glScalef(-1.0f, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
resetTextureMatrix = true;
}*/
}
setSurfaceCircleFunc(DrawSurfaceCircle);
setSurfaceSquareFunc(DrawSurfaceSquare);
cursorIcons.Enable(false);
glColor4f(0.6f, 0.6f, 0.6f, 1.0f);
// don't mirror the map texture with flipped cameras
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
// draw the map
glDisable(GL_BLEND);
readmap->DrawMinimap();
glEnable(GL_BLEND);
glMatrixMode(GL_TEXTURE);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
// clip everything outside of the minimap box
{
const double plane0[4] = {0,-1,0,1};
const double plane1[4] = {0,1,0,0};
const double plane2[4] = {-1,0,0,1};
const double plane3[4] = {1,0,0,0};
glClipPlane(GL_CLIP_PLANE0, plane0); // clip bottom
glClipPlane(GL_CLIP_PLANE1, plane1); // clip top
glClipPlane(GL_CLIP_PLANE2, plane2); // clip right
glClipPlane(GL_CLIP_PLANE3, plane3); // clip left
glEnable(GL_CLIP_PLANE0);
glEnable(GL_CLIP_PLANE1);
glEnable(GL_CLIP_PLANE2);
glEnable(GL_CLIP_PLANE3);
}
// switch to top-down map/world coords (z is twisted with y compared to the real map/world coords)
glPushMatrix();
glTranslatef(0.0f, +1.0f, 0.0f);
glScalef(+1.0f / (gs->mapx * SQUARE_SIZE), -1.0f / (gs->mapy * SQUARE_SIZE), 1.0f);
glEnable(GL_TEXTURE_2D);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.0f);
{
GML_RECMUTEX_LOCK(unit); // DrawForReal
const std::set<CUnit*>& units = unitDrawer->GetUnsortedUnits();
for (std::set<CUnit*>::const_iterator it = units.begin(); it != units.end(); ++it) {
DrawUnit(*it);
}
// highlight the selected unit
CUnit* unit = GetSelectUnit(GetMapPosition(mouse->lastx, mouse->lasty));
if (unit != NULL) {
DrawUnitHighlight(unit);
}
}
glDisable(GL_ALPHA_TEST);
glDisable(GL_TEXTURE_2D);
glPushMatrix();
glRotatef(-90.0f, +1.0f, 0.0f, 0.0f); // real 'world' coordinates
glScalef(1.0f, 0.0f, 1.0f); // skip the y-coord (Lua's DrawScreen is perspective and so any z-coord in it influence the x&y, too)
// draw the projectiles
if (drawProjectiles) {
glPointSize(1.0f);
WorkaroundATIPointSizeBug();
projectileDrawer->DrawProjectilesMiniMap();
}
// draw the queued commands
//
// NOTE: this needlessly adds to the CursorIcons list, but at least
// they are not drawn (because the input receivers are drawn
// after the command queues)
LuaUnsyncedCtrl::DrawUnitCommandQueues();
if ((drawCommands > 0) && guihandler->GetQueueKeystate()) {
selectedUnits.DrawCommands();
}
lineDrawer.DrawAll();
// draw the selection shape, and some ranges
if (drawCommands > 0) {
guihandler->DrawMapStuff(!!drawCommands);
}
{
GML_RECMUTEX_LOCK(sel); // DrawForReal
// draw unit ranges
const float radarSquare = radarhandler->radarDiv;
CUnitSet& selUnits = selectedUnits.selectedUnits;
for(CUnitSet::iterator si = selUnits.begin(); si != selUnits.end(); ++si) {
CUnit* unit = *si;
if (unit->radarRadius && !unit->beingBuilt && unit->activated) {
glColor3fv(cmdColors.rangeRadar);
DrawCircle(unit->pos, (unit->radarRadius * radarSquare));
}
if (unit->sonarRadius && !unit->beingBuilt && unit->activated) {
glColor3fv(cmdColors.rangeSonar);
DrawCircle(unit->pos, (unit->sonarRadius * radarSquare));
}
if (unit->jammerRadius && !unit->beingBuilt && unit->activated) {
glColor3fv(cmdColors.rangeJammer);
DrawCircle(unit->pos, (unit->jammerRadius * radarSquare));
}
// change if someone someday create a non stockpiled interceptor
const CWeapon* w = unit->stockpileWeapon;
if((w != NULL) && w->weaponDef->interceptor) {
if (w->numStockpiled) {
glColor3fv(cmdColors.rangeInterceptorOn);
} else {
glColor3fv(cmdColors.rangeInterceptorOff);
}
DrawCircle(unit->pos, w->weaponDef->coverageRange);
}
}
}
glPopMatrix(); // revert to the 2d xform
if (!minimap->maximized) {
// draw the camera frustum lines
cam2->GetFrustumSides(0.0f, 0.0f, 1.0f, true);
cam2->ClipFrustumLines(true, -10000.0f, 400096.0f);
const std::vector<CCamera::FrustumLine>& negSides = cam2->negFrustumSides;
// const std::vector<CCamera::FrustumLine>& posSides = cam2->posFrustumSides;
std::vector<CCamera::FrustumLine>::const_iterator fli;
CVertexArray* va = GetVertexArray();
va->Initialize();
va->EnlargeArrays(negSides.size() * 2, 0, VA_SIZE_2D0);
for (fli = negSides.begin(); fli != negSides.end(); ++fli) {
if (fli->minz < fli->maxz) {
va->AddVertex2dQ0(fli->base + (fli->dir * fli->minz), fli->minz);
va->AddVertex2dQ0(fli->base + (fli->dir * fli->maxz), fli->maxz);
}
}
glLineWidth(2.5f);
glColor4f(0, 0, 0, 0.5f);
va->DrawArray2d0(GL_LINES);
glLineWidth(1.5f);
glColor4f(1, 1, 1, 0.75f);
va->DrawArray2d0(GL_LINES);
glLineWidth(1.0f);
}
// selection box
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
CMouseHandler::ButtonPressEvt& bp = mouse->buttons[SDL_BUTTON_LEFT];
if (selecting && fullProxy && (bp.movement > 4)) {
const float3 oldPos = GetMapPosition(bp.x, bp.y);
const float3 newPos = GetMapPosition(mouse->lastx, mouse->lasty);
glColor4fv(cmdColors.mouseBox);
glBlendFunc((GLenum)cmdColors.MouseBoxBlendSrc(),
(GLenum)cmdColors.MouseBoxBlendDst());
glLineWidth(cmdColors.MouseBoxLineWidth());
float verts[] = {
oldPos.x, oldPos.z,
newPos.x, oldPos.z,
newPos.x, newPos.z,
oldPos.x, newPos.z,
};
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, verts);
glDrawArrays(GL_LINE_LOOP, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
glLineWidth(1.0f);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
DrawNotes();
// reset 1
if (resetTextureMatrix) {
glMatrixMode(GL_TEXTURE_MATRIX);
glPopMatrix();
}
glMatrixMode(GL_MODELVIEW);
if (use_geo) {
glPopMatrix();
}
// reset 2
glPopMatrix();
glPopAttrib();
glEnable(GL_TEXTURE_2D);
{
//! prepare ClipPlanes for Lua's DrawInMinimap Modelview matrix
//! quote from glClipPlane spec:
//! "When glClipPlane is called, equation is transformed by the inverse of the modelview matrix and stored in the resulting eye coordinates.
//! Subsequent changes to the modelview matrix have no effect on the stored plane-equation components."
//! -> we have to use the same modelview matrix when calling glClipPlane and later draw calls
//! set the modelview matrix to the same as used in Lua's DrawInMinimap
glPushMatrix();
glLoadIdentity();
glScalef(1.0f / width, 1.0f / height, 1.0f);
const double plane0[4] = {0, -1, 0, double(height)};
const double plane1[4] = {0, 1, 0, 0};
const double plane2[4] = {-1, 0, 0, double(width)};
const double plane3[4] = {1, 0, 0, 0};
glClipPlane(GL_CLIP_PLANE0, plane0); // clip bottom
glClipPlane(GL_CLIP_PLANE1, plane1); // clip top
glClipPlane(GL_CLIP_PLANE2, plane2); // clip right
glClipPlane(GL_CLIP_PLANE3, plane3); // clip left
glPopMatrix();
}
//! allow the LUA scripts to draw into the minimap
eventHandler.DrawInMiniMap();
if (use_geo && globalRendering->dualScreenMode)
glViewport(globalRendering->viewPosX,0,globalRendering->viewSizeX,globalRendering->viewSizeY);
//FIXME: Lua modifies the matrices w/o reseting it! (quite complexe to fix because ClearMatrixStack() makes it impossible to use glPushMatrix)
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0,1,0,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// disable ClipPlanes
glDisable(GL_CLIP_PLANE0);
glDisable(GL_CLIP_PLANE1);
glDisable(GL_CLIP_PLANE2);
glDisable(GL_CLIP_PLANE3);
cursorIcons.Enable(true);
setSurfaceCircleFunc(NULL);
setSurfaceSquareFunc(NULL);
}
void Cursor::Draw3dCursorScale(const vec_t min, const vec_t mid, const vec_t max)
{
glBegin(GL_LINES);
// X Axis, red
glColor3fv(RED);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(mid, 0.0, 0.0);
// Y Axis, green
glColor3fv(GREEN);
glVertex3f(0.0, mid, 0.0);
glVertex3f(0.0, 0.0, 0.0);
// Z Axis, blue
glColor3fv(BLUE);
glVertex3f(0.0, 0.0, mid);
glVertex3f(0.0, 0.0, 0.0);
glEnd();
glBegin(GL_QUADS);
// X Axis, Red box
glColor3fv(RED);
glVertex3f(mid+min, -min, min);
glVertex3f(mid+min, min, min);
glVertex3f(mid-min, min, min);
glVertex3f(mid-min, -min, min);
glVertex3f(mid+min, -min, -min);
glVertex3f(mid+min, min, -min);
glVertex3f(mid-min, min, -min);
glVertex3f(mid-min, -min, -min);
glVertex3f(mid+min, min, -min);
glVertex3f(mid+min, min, min);
glVertex3f(mid-min, min, min);
glVertex3f(mid-min, min, -min);
glVertex3f(mid+min, -min, -min);
glVertex3f(mid+min, -min, min);
glVertex3f(mid-min, -min, min);
glVertex3f(mid-min, -min, -min);
glVertex3f(mid+min, min, -min);
glVertex3f(mid+min, min, min);
glVertex3f(mid+min, -min, min);
glVertex3f(mid+min, -min, -min);
// Y Axis, green
glColor3fv(GREEN);
glVertex3f(-min, mid+min, min);
glVertex3f(min,mid+min, min);
glVertex3f(min,mid-min, min);
glVertex3f(-min,mid-min, min);
glVertex3f(-min,mid+min, -min);
glVertex3f(min,mid+min, -min);
glVertex3f( min,mid-min, -min);
glVertex3f(-min,mid-min, -min);
glVertex3f( min,mid+min, -min);
glVertex3f( min,mid+min, min);
glVertex3f(min,mid-min, min);
glVertex3f( min,mid-min, -min);
glVertex3f( -min,mid+min, -min);
glVertex3f( -min,mid+min, min);
glVertex3f(-min,mid-min, min);
glVertex3f(-min,mid-min, -min);
glVertex3f(min,mid+min, -min);
glVertex3f(min,mid+min, min);
glVertex3f( -min,mid+min, min);
glVertex3f(-min,mid+min, -min);
// Z Axis, blue
glColor3fv(BLUE);
glVertex3f(-min, min, mid+min);
glVertex3f(min, min, mid+min);
glVertex3f(min, min, mid-min);
glVertex3f(-min, min, mid-min);
glVertex3f(-min, -min, mid+min);
glVertex3f(min, -min, mid+min);
glVertex3f( min, -min, mid-min);
glVertex3f(-min, -min, mid-min);
glVertex3f( min, -min, mid+min);
glVertex3f( min, min, mid+min);
glVertex3f(min, min, mid-min);
glVertex3f( min, -min, mid-min);
glVertex3f( -min, -min, mid+min);
glVertex3f( -min, min, mid+min);
glVertex3f(-min, min, mid-min);
glVertex3f(-min, -min, mid-min);
glVertex3f(min, -min, mid+min);
glVertex3f(min, min, mid+min);
glVertex3f( -min, min, mid+min);
glVertex3f(-min, -min, mid+min);
glEnd();
}
/* glmDraw: Renders the model to the current OpenGL context using the
* mode specified.
*
* model - initialized GLMmodel structure
* mode - a bitwise OR of values describing what is to be rendered.
* GLM_NONE - render with only vertices
* GLM_FLAT - render with facet normals
* GLM_SMOOTH - render with vertex normals
* GLM_TEXTURE - render with texture coords
* GLM_COLOR - render with colors (color material)
* GLM_MATERIAL - render with materials
* GLM_COLOR and GLM_MATERIAL should not both be specified.
* GLM_FLAT and GLM_SMOOTH should not both be specified.
*/
GLvoid
glmDraw(GLMmodel* model, GLuint mode)
{
GLuint i;
GLMgroup* group;
assert(model);
assert(model->vertices);
/* do a bit of warning */
if (mode & GLM_FLAT && !model->facetnorms) {
printf("glmDraw() warning: flat render mode requested "
"with no facet normals defined.\n");
mode &= ~GLM_FLAT;
}
if (mode & GLM_SMOOTH && !model->normals) {
printf("glmDraw() warning: smooth render mode requested "
"with no normals defined.\n");
mode &= ~GLM_SMOOTH;
}
if (mode & GLM_TEXTURE && !model->texcoords) {
printf("glmDraw() warning: texture render mode requested "
"with no texture coordinates defined.\n");
mode &= ~GLM_TEXTURE;
}
if (mode & GLM_FLAT && mode & GLM_SMOOTH) {
printf("glmDraw() warning: flat render mode requested "
"and smooth render mode requested (using smooth).\n");
mode &= ~GLM_FLAT;
}
if (mode & GLM_COLOR && !model->materials) {
printf("glmDraw() warning: color render mode requested "
"with no materials defined.\n");
mode &= ~GLM_COLOR;
}
if (mode & GLM_MATERIAL && !model->materials) {
printf("glmDraw() warning: material render mode requested "
"with no materials defined.\n");
mode &= ~GLM_MATERIAL;
}
if (mode & GLM_COLOR && mode & GLM_MATERIAL) {
printf("glmDraw() warning: color and material render mode requested "
"using only material mode\n");
mode &= ~GLM_COLOR;
}
if (mode & GLM_COLOR)
glEnable(GL_COLOR_MATERIAL);
if (mode & GLM_MATERIAL)
glDisable(GL_COLOR_MATERIAL);
glPushMatrix();
glTranslatef(model->position[0], model->position[1], model->position[2]);
glBegin(GL_TRIANGLES);
group = model->groups;
while (group) {
if (mode & GLM_MATERIAL) {
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,
model->materials[group->material].ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,
model->materials[group->material].diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR,
model->materials[group->material].specular);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS,
model->materials[group->material].shininess);
}
if (mode & GLM_COLOR) {
glColor3fv(model->materials[group->material].diffuse);
}
for (i = 0; i < group->numtriangles; i++) {
if (mode & GLM_FLAT)
glNormal3fv(&model->facetnorms[3 * T(group->triangles[i]).findex]);
if (mode & GLM_SMOOTH)
glNormal3fv(&model->normals[3 * T(group->triangles[i]).nindices[0]]);
if (mode & GLM_TEXTURE)
glTexCoord2fv(&model->texcoords[2*T(group->triangles[i]).tindices[0]]);
glVertex3fv(&model->vertices[3 * T(group->triangles[i]).vindices[0]]);
#if 0
printf("%f %f %f\n",
model->vertices[3 * T(group->triangles[i]).vindices[0] + X],
model->vertices[3 * T(group->triangles[i]).vindices[0] + Y],
model->vertices[3 * T(group->triangles[i]).vindices[0] + Z]);
#endif
if (mode & GLM_SMOOTH)
glNormal3fv(&model->normals[3 * T(group->triangles[i]).nindices[1]]);
if (mode & GLM_TEXTURE)
glTexCoord2fv(&model->texcoords[2*T(group->triangles[i]).tindices[1]]);
glVertex3fv(&model->vertices[3 * T(group->triangles[i]).vindices[1]]);
#if 0
printf("%f %f %f\n",
model->vertices[3 * T(group->triangles[i]).vindices[1] + X],
model->vertices[3 * T(group->triangles[i]).vindices[1] + Y],
model->vertices[3 * T(group->triangles[i]).vindices[1] + Z]);
#endif
if (mode & GLM_SMOOTH)
glNormal3fv(&model->normals[3 * T(group->triangles[i]).nindices[2]]);
if (mode & GLM_TEXTURE)
glTexCoord2fv(&model->texcoords[2*T(group->triangles[i]).tindices[2]]);
glVertex3fv(&model->vertices[3 * T(group->triangles[i]).vindices[2]]);
#if 0
printf("%f %f %f\n",
model->vertices[3 * T(group->triangles[i]).vindices[2] + X],
model->vertices[3 * T(group->triangles[i]).vindices[2] + Y],
model->vertices[3 * T(group->triangles[i]).vindices[2] + Z]);
#endif
}
group = group->next;
}
glEnd();
glPopMatrix();
}
void GLUTSimLightController::draw() {
int w = glutGet(GLUT_WINDOW_WIDTH);
int h = glutGet(GLUT_WINDOW_HEIGHT);
float light_position[4] = {0.0, 0.0, -1.0, 0.0};
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(35, (double) w/h, 0.1, 100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glTranslatef(0, 0, -3);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
glEnable(GL_DEPTH_TEST);
glEnable(GL_POINT_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_LIGHT0);
glEnable(GL_NORMALIZE);
struct Light {
float radius;
float color[3];
float position[2];
} lights[4] = {
{ .2, { 0, 0,.8 }, { -.5, -.5 } },
{ .2, { .8, 0, 0 }, { .5, -.5 } },
{ .2, { 0,.8, 0 }, { .5, .5 } },
{ .2, { .9,.9,.9 }, { -.5, .5 } },
};
for (unsigned i = 0; i != 4; ++i) {
Light &l = lights[i];
if (lights_enabled[i]) {
glColor3fv(l.color);
draw_circle_filled(l.position[0], l.position[1], l.radius);
}
}
// Draw the beat monitor.
const double beat_monitor_dim_time = .05;
double elapsed = get_elapsed_time_in_seconds();
if (elapsed - last_beat_time <= beat_monitor_dim_time) {
double v = 1 - (elapsed - last_beat_time) / beat_monitor_dim_time;
glColor3f(v, v, v);
glRectf(-.9, -.9, -.7, -.8);
}
// Draw the 2D overlays.
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, w, 0, h, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
const int textHeight = 15;
char buffer[256];
int y = 0;
sprintf(buffer, "Time: %.4fs\n", elapsed);
glColor3f(1, 1, 1);
glutDrawString(10, 10 + textHeight*y++, buffer);
if (true) {
num_frames++;
double fps = num_frames / elapsed;
sprintf(buffer, "FPS: %.4fs\n", fps);
glColor3f(1, 1, 1);
glutDrawString(10, 10 + textHeight*y++, buffer);
}
if (light_manager) {
double bpm = light_manager->GetRecentBPM();
sprintf(buffer, "BPM: %.4fs\n", bpm);
glColor3f(1, 1, 1);
glutDrawString(10, 10 + textHeight*y++, buffer);
}
if (light_manager) {
sprintf(buffer, "Program: %s\n", light_manager->GetProgramName().c_str());
glColor3f(1, 1, 1);
glutDrawString(10, 10 + textHeight*y++, buffer);
}
if (light_manager) {
sprintf(buffer, "Strobe Enabled: %s\n",
light_manager->GetStrobeEnabled() ? "yes" : "no");
glColor3f(1, 1, 1);
glutDrawString(10, 10 + textHeight*y++, buffer);
}
glFlush();
glutSwapBuffers();
}
bool OGL_DoFades(float Left, float Top, float Right, float Bottom)
{
if (!OGL_FaderActive()) return false;
// Set up the vertices
GLfloat Vertices[4][2];
Vertices[0][0] = Left;
Vertices[0][1] = Top;
Vertices[1][0] = Right;
Vertices[1][1] = Top;
Vertices[2][0] = Right;
Vertices[2][1] = Bottom;
Vertices[3][0] = Left;
Vertices[3][1] = Bottom;
glVertexPointer(2,GL_FLOAT,0,Vertices[0]);
// Do real blending
glDisable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
// Modified color:
GLfloat BlendColor[4];
for (int f=0; f<NUMBER_OF_FADER_QUEUE_ENTRIES; f++)
{
OGL_Fader& Fader = FaderQueue[f];
switch(Fader.Type)
{
case NONE:
break;
case _tint_fader_type:
// The simplest kind: fade to the fader color.
SglColor4fva(Fader.Color);
glDrawArrays(GL_POLYGON,0,4);
break;
case _randomize_fader_type:
UseFlatStatic = TEST_FLAG(Get_OGL_ConfigureData().Flags,OGL_Flag_FlatStatic);
if (UseFlatStatic)
{
for (int c=0; c<3; c++)
FlatStaticColor[c] = FlatStaticRandom.KISS() + FlatStaticRandom.LFIB4();
FlatStaticColor[3] = PIN(int(65535*Fader.Color[3]+0.5),0,65535);
glDisable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
SglColor4usv(FlatStaticColor);
glDrawArrays(GL_POLYGON,0,4);
}
else
{
// Do random flipping of the lower bits of color values;
// the stronger the opacity (alpha), the more bits to flip.
if (Using_sRGB) glDisable(GL_FRAMEBUFFER_SRGB_EXT);
glDisable(GL_BLEND);
MultAlpha(Fader.Color,BlendColor);
glColor3fv(BlendColor);
glEnable(GL_COLOR_LOGIC_OP);
glLogicOp(GL_XOR);
glDrawArrays(GL_POLYGON,0,4);
// Revert to defaults
glDisable(GL_COLOR_LOGIC_OP);
glEnable(GL_BLEND);
if (Using_sRGB) glEnable(GL_FRAMEBUFFER_SRGB_EXT);
}
break;
case _negate_fader_type:
// This is only a partial approximation of the negation effect
// Neither glBlendColorEXT nor glBlendEquationEXT is currently supported
// in ATI Rage 128 AppleGL, which makes my life more difficult :-P
MultAlpha(Fader.Color,BlendColor);
SglColor4fva(BlendColor);
glBlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ONE_MINUS_SRC_ALPHA);
glDrawArrays(GL_POLYGON,0,4);
// Revert to defaults
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
break;
case _dodge_fader_type:
ComplementColor(Fader.Color,BlendColor);
MultAlpha(BlendColor,BlendColor);
SglColor4fva(BlendColor);
glBlendFunc(GL_DST_COLOR,GL_ONE_MINUS_SRC_ALPHA);
glDrawArrays(GL_POLYGON,0,4);
glBlendFunc(GL_DST_COLOR,GL_ONE);
glDrawArrays(GL_POLYGON,0,4);
// Revert to defaults
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
break;
case _burn_fader_type:
// Attempted to get that reversed-color effect at maximum intensity,
// with it being only near maximum intensity
// (MultAlpha + GL_SRC_ALPHA means opacity^2).
MultAlpha(Fader.Color,BlendColor);
SglColor4fva(BlendColor);
glBlendFunc(GL_DST_COLOR,GL_ONE);
glDrawArrays(GL_POLYGON,0,4);
ComplementColor(Fader.Color,BlendColor);
MultAlpha(BlendColor,BlendColor);
SglColor4fva(BlendColor);
glBlendFunc(GL_SRC_ALPHA,GL_ONE);
glDrawArrays(GL_POLYGON,0,4);
// Revert to defaults
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
break;
case _soft_tint_fader_type:
// Fade to the color multiplied by the fader color,
// as if the scene was illuminated by light with that fader color.
if(Using_sRGB) {
float alpha = std::sqrt(Fader.Color[3]);
float corrected[4] = {
sRGB_frob(Fader.Color[0])*alpha,
sRGB_frob(Fader.Color[1])*alpha,
sRGB_frob(Fader.Color[2])*alpha,
alpha
};
MultAlpha(corrected,BlendColor);
}
else
MultAlpha(Fader.Color,BlendColor);
glColor4fv(BlendColor);
glBlendFunc(GL_DST_COLOR,GL_ONE_MINUS_SRC_ALPHA);
glDrawArrays(GL_POLYGON,0,4);
// Revert to defaults
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
break;
}
}
return true;
}
void DisplayScene()
{
// kolor tła - zawartość bufora koloru
glClearColor(1.0, 1.0, 1.0, 1.0);
// czyszczenie bufora koloru i bufora głębokości
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// wybór macierzy modelowania
glMatrixMode(GL_MODELVIEW);
// macierz modelowania = macierz jednostkowa
glLoadIdentity();
// przesunięcie układu współrzędnych obiektów do środka bryły odcinania
glTranslatef(0.0, 0.0, -(near + far) / 2);
// obroty obiektu
glRotatef(rotatex, 1.0, 0.0, 0.0);
glRotatef(rotatez, 0.0, 0.0, 1.0);
// skalowanie obiektu - klawisze "+" i "-"
glScalef(scale, scale, scale);
// włączenie testu bufora głębokości
glEnable(GL_DEPTH_TEST);
// włączenie teksturowania dwuwymiarowego
glEnable(GL_TEXTURE_2D);
// filtr powiększający
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// filtr pomniejszający
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
// dowiązanie wybranej tekstury
glBindTexture(GL_TEXTURE_2D, texture);
// ustawienie parametów środowiska tekstur
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
// utworzenie kwadryki
GLUquadricObj *quadobj = gluNewQuadric();
// styl (wygląd) generowanej kwadryki
gluQuadricDrawStyle(quadobj, GLU_FILL);
// sposób generacji wektorów normalnych
gluQuadricNormals(quadobj, GLU_SMOOTH);
// nałożenie tekstury na kwadrykę
gluQuadricTexture(quadobj, GL_TRUE);
// narysowanie kuli
gluSphere(quadobj, 1.0, 30, 30);
// usunięcie kwadryki
gluDeleteQuadric(quadobj);
// wyłączenie teksturowania dwuwymiarowego
glDisable(GL_TEXTURE_2D);
// informacje o wybranych parametrach bieżącej tekstury
char string[200];
GLfloat var;
glColor3fv(Black);
// wartość priorytetu tekstury
glGetTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_PRIORITY, &var);
sprintf_s(string, "GL_TEXTURE_PRIORITY = %f", var);
DrawString(2, 2, string);
// czy tekstura jest rezydentna
glGetTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_RESIDENT, &var);
if (var == GL_FALSE)
strcpy_s(string, "GL_TEXTURE_RESIDENT = GL_FALSE");
else
strcpy_s(string, "GL_TEXTURE_RESIDENT = GL_TRUE");
DrawString(2, 16, string);
// szerokość tekstury (poziom 0)
glGetTexLevelParameterfv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &var);
sprintf_s(string, "GL_TEXTURE_WIDTH = %f", var);
DrawString(2, 30, string);
// wysokość tekstury (poziom 0)
glGetTexLevelParameterfv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &var);
sprintf_s(string, "GL_TEXTURE_HEIGHT = %f", var);
DrawString(2, 46, string);
// skierowanie poleceñ do wykonania
glFlush();
// zamiana buforów koloru
glutSwapBuffers();
}
void draw_cube(double radius) {
GLfloat matspec[4] = {0.5, 0.5, 0.5, 0.0};
glPushMatrix();
glScaled(radius, radius, radius);
glMaterialfv(GL_FRONT, GL_SPECULAR, matspec);
glMaterialf(GL_FRONT, GL_SHININESS, 64.0);
glBegin(GL_POLYGON);
glColor3fv(lightblu_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, lightblu_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, lightblu_col);
glNormal3f(0.0, 0.0, -1.0);
glVertex3f(1.0, 1.0, -1.0);
glVertex3f(1.0, -1.0, -1.0);
glVertex3f(-1.0, -1.0, -1.0);
glVertex3f(-1.0, 1.0, -1.0);
glEnd();
glBegin(GL_POLYGON);
glColor3fv(blu_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, blu_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, blu_col);
glNormal3f(0.0, 0.0, 1.0);
glVertex3f(-1.0, 1.0, 1.0);
glVertex3f(-1.0, -1.0, 1.0);
glVertex3f(1.0, -1.0, 1.0);
glVertex3f(1.0, 1.0, 1.0);
glEnd();
glBegin(GL_POLYGON);
glColor3fv(yel_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, yel_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, yel_col);
glNormal3f(0.0, -1.0, 0.0);
glVertex3f(1.0, -1.0, 1.0);
glVertex3f(-1.0, -1.0, 1.0);
glVertex3f(-1.0, -1.0, -1.0);
glVertex3f(1.0, -1.0, -1.0);
glEnd();
glBegin(GL_POLYGON);
glColor3fv(grn_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, grn_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, grn_col);
glNormal3f(0.0, 1.0, 0.0);
glVertex3f(1.0, 1.0, 1.0);
glVertex3f(1.0, 1.0, -1.0);
glVertex3f(-1.0, 1.0, -1.0);
glVertex3f(-1.0, 1.0, 1.0);
glEnd();
glBegin(GL_POLYGON);
glColor3fv(pur_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, pur_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, pur_col);
glNormal3f(-1.0, 0.0, 0.0);
glVertex3f(-1.0, 1.0, 1.0);
glVertex3f(-1.0, 1.0, -1.0);
glVertex3f(-1.0, -1.0, -1.0);
glVertex3f(-1.0, -1.0, 1.0);
glEnd();
glBegin(GL_POLYGON);
glColor3fv(red_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, red_col);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, red_col);
glNormal3f(1.0, 0.0, 0.0);
glVertex3f(1.0, -1.0, 1.0);
glVertex3f(1.0, -1.0, -1.0);
glVertex3f(1.0, 1.0, -1.0);
glVertex3f(1.0, 1.0, 1.0);
glEnd();
glPopMatrix();
}
static void draw_screen( OBJSC * model )
{
/* Our angle of rotation. */
/*
* EXERCISE:
* Replace this awful mess with vertex
* arrays and a call to glDrawElements.
*
* EXERCISE:
* After completing the above, change
* it to use compiled vertex arrays.
*
* EXERCISE:
* Verify my windings are correct here ;).
*/
static GLubyte red[] = { 255, 0, 0, 255 };
static GLubyte green[] = { 0, 255, 0, 255 };
static GLubyte blue[] = { 0, 0, 255, 255 };
static GLubyte white[] = { 255, 255, 255, 255 };
static GLubyte yellow[] = { 0, 255, 255, 255 };
static GLubyte black[] = { 0, 0, 0, 255 };
static GLubyte orange[] = { 255, 255, 0, 255 };
static GLubyte purple[] = { 255, 0, 255, 0 };
/* Clear the color and depth buffers. */
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
/* We don't want to modify the projection matrix. */
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
/* Move down the z-axis. */
glRotatef( 20, 1.0, 0.0, 0.0 );
glTranslatef( 0.0, -100.0, -150.0 );
/* Rotate. */
glRotatef( angle*8, 0.0, 1.0, 0.0 );
/* Send our triangle data to the pipeline. */
int i;
for(i = 0; i < model->vlen; i++) {
calc_vertex(model, i, game_time, speed);
calc_vertex_normal(model, i, model->vntable[i]);
}
glBegin( GL_TRIANGLES );
for(i = 0; i < model->flen; i++) {
if(model->ftable[i].data == 2) {
glColor4ubv( white );
} else if(model->ftable[i].data == 3) {
glColor4ubv( black );
} else {
glColor4ubv( black );
}
vec3 normal;
vec3 a;
vec3 b;
vec3 c;
vec3 an;
vec3 bn;
vec3 cn;
vec3_cpy(a, model->vtable[model->ftable[i].a]);
vec3_cpy(b, model->vtable[model->ftable[i].b]);
vec3_cpy(c, model->vtable[model->ftable[i].c]);
vec3_cpy(an, model->vntable[model->ftable[i].a]);
vec3_cpy(bn, model->vntable[model->ftable[i].b]);
vec3_cpy(cn, model->vntable[model->ftable[i].c]);
glColor3fv( an);
glVertex3fv( a );
glColor3fv( bn);
glVertex3fv( b );
glColor3fv( cn);
glVertex3fv( c );
}
glEnd( );
/*
* EXERCISE:
* Draw text telling the user that 'Spc'
* pauses the rotation and 'Esc' quits.
* Do it using vetors and textured quads.
*/
/*
* Swap the buffers. This this tells the driver to
* render the next frame from the contents of the
* back-buffer, and to set all rendering operations
* to occur on what was the front-buffer.
*
* Double buffering prevents nasty visual tearing
* from the application drawing on areas of the
* screen that are being updated at the same time.
*/
SDL_GL_SwapBuffers( );
}
void SceneRenderer::render(
bool _lastFrame,
bool _sameFrame,
bool fullWindow)
{
static const GLfloat blindnessColor[4] = { 1.0f, 1.0f, 0.0f, 1.0f };
static const GLfloat dimnessColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
static const float dimDensity = 0.75f;
bool lighting = BZDB.isTrue("lighting");
lastFrame = _lastFrame;
sameFrame = _sameFrame;
// avoid OpenGL calls as long as possible -- there's a good
// chance we're waiting on the vertical retrace.
// set the view frustum
if (sceneIterator) sceneIterator->resetFrustum(&frustum);
// get the important lights in the scene
int i;
int numLights = 0;
if (!sameFrame) {
clearLights();
if (sceneIterator && !blank && lighting) {
// add lights
sceneIterator->reset();
SceneNode* node;
while ((node = sceneIterator->getNext()) != NULL)
node->addLight(*this);
numLights = lights.size();
// pick maxLights most important light sources
// should go by full lighting function but we'll just go by distance
if (numLights > maxLights) {
const GLfloat* eye = frustum.getEye();
for (i = 0; i < maxLights; i++) {
GLfloat maxImportance = lights[i]->getImportance(eye);
for (int j = i + 1; j < numLights; j++) {
GLfloat importance = lights[j]->getImportance(eye);
if (importance > maxImportance) {
OpenGLLight* temp = lights[i];
lights[j] = lights[i];
lights[i] = temp;
maxImportance = importance;
}
}
}
numLights = maxLights;
}
}
}
// get the nodes to draw
if (!blank) {
// empty the render node lists in preparation for the next frame
OpenGLGState::clearLists();
orderedList.clear();
shadowList.clear();
flareLightList.clear();
// make the lists of render nodes sorted in optimal rendering order
if (sceneIterator) {
sceneIterator->reset();
SceneNode* node;
while ((node = sceneIterator->getNext()) != NULL)
node->getRenderNodes(*this);
}
// sort ordered list in reverse depth order
if (!inOrder)
orderedList.sort(frustum.getEye());
}
// prepare transforms
// note -- lights should not be positioned before view is set
frustum.executeDeepProjection();
glPushMatrix();
frustum.executeView();
// turn sunlight on -- the ground needs it
if (lighting && sunOrMoonUp) {
theSun.execute(SunLight);
theSun.enableLight(SunLight);
}
// turn on fog for teleporter blindness if close to a teleporter
float teleporterProximity = 0.0f;
if (!blank && LocalPlayer::getMyTank() && (LocalPlayer::getMyTank()->getTeam() != ObserverTeam))
teleporterProximity = LocalPlayer::getMyTank()->getTeleporterProximity();
float worldSize = BZDB.eval(StateDatabase::BZDB_WORLDSIZE);
bool reallyUseFogHack = useFogHack && (useQualityValue >= 2);
if (reallyUseFogHack) {
if (useDimming) {
const float density = dimDensity;
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, -density * 1000.0f * worldSize);
glFogf(GL_FOG_END, (1.0f - density) * 1000.0f * worldSize);
glFogfv(GL_FOG_COLOR, dimnessColor);
glEnable(GL_FOG);
}
else if (teleporterProximity > 0.0f && useFogHack) {
const float density = (teleporterProximity > 0.75f) ?
1.0f : teleporterProximity / 0.75f;
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, -density * 1000.0f * worldSize);
glFogf(GL_FOG_END, (1.0f - density) * 1000.0f * worldSize);
glFogfv(GL_FOG_COLOR, blindnessColor);
glEnable(GL_FOG);
}
}
// set scissor
glScissor(window.getOriginX(), window.getOriginY() + window.getHeight() - window.getViewHeight(),
window.getWidth(), window.getViewHeight());
if (useDepthComplexityOn) {
// glEnable(GL_STENCIL_TEST);
// glClear(GL_STENCIL_BUFFER_BIT);
// glStencilFunc(GL_ALWAYS, 0, 0xf);
// glStencilOp(GL_KEEP, GL_INCR, GL_INCR);
}
if (useHiddenLineOn) {
//glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
// glClear(GL_COLOR_BUFFER_BIT);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
}
else if (useWireframeOn) {
//glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
// glClear(GL_COLOR_BUFFER_BIT);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
// prepare z buffer
/*
if (BZDB.isTrue("zbuffer"))
{
if (sameFrame && ++depthRange == numDepthRanges)
depthRange = 0;
if (exposed || useHiddenLineOn || --depthRange < 0)
{
depthRange = numDepthRanges - 1;
glClear(GL_DEPTH_BUFFER_BIT);
exposed = false;
}
if (!sameFrame && numDepthRanges != 1)
{
if (useHiddenLineOn) {
glDepthRange(0.0, 1.0);
}
else {
GLclampd x_near = (GLclampd)depthRange * depthRangeSize;
glDepthRange(x_near, x_near + depthRangeSize);
}
}
}
*/
// draw start of background (no depth testing)
OpenGLGState::resetState();
if (background)
{
background->setBlank(blank);
background->setInvert(invert);
background->renderSkyAndGround(*this, fullWindow);
}
// prepare the other lights but don't turn them on yet --
// we may need to turn them on when drawing the background.
if (lighting) {
for (i = 0; i < numLights; i++)
lights[i]->execute(i + reservedLights);
}
// draw rest of background
if (background)
background->render(*this);
if (!blank) {
if (lighting) {
// now turn on the remaining lights
for (i = 0; i < numLights; i++)
OpenGLLight::enableLight(i + reservedLights);
}
frustum.executeProjection();
if (BZDB.isTrue("zbuffer")) glEnable(GL_DEPTH_TEST);
if (useHiddenLineOn) {
#if defined(GL_VERSION_1_1)
glEnable(GL_POLYGON_OFFSET_FILL);
#elif defined(GL_EXT_polygon_offset)
glEnable(GL_POLYGON_OFFSET_EXT);
#endif
}
// render the normal stuff
doRender();
if (useHiddenLineOn) {
#if defined(GL_VERSION_1_1)
glDisable(GL_POLYGON_OFFSET_FILL);
#elif defined(GL_EXT_polygon_offset)
glDisable(GL_POLYGON_OFFSET_EXT);
#endif
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
doRender();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
OpenGLGState::resetState();
// shut off lights
if (lighting) {
theSun.enableLight(SunLight, false);
for (i = 0; i < numLights; i++)
OpenGLLight::enableLight(i + reservedLights, false);
}
if (BZDB.isTrue("zbuffer")) glDisable(GL_DEPTH_TEST);
// FIXME -- must do post-rendering: flare lights, etc.
// flare lights are in world coordinates. trace ray to that world
// position and calculate opacity. if opaque then don't render
// flare, otherwise modulate input color by opacity and draw a
// billboard texture (constant size in screen space).
}
// back to original state
if (!useHiddenLineOn && useWireframeOn)
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glPopMatrix();
if ((reallyUseFogHack && (teleporterProximity > 0.0f || useDimming)))
glDisable(GL_FOG);
if (!reallyUseFogHack) {
float density = 0.0f;
const GLfloat* color = NULL;
if (useDimming) {
density = dimDensity;
color = dimnessColor;
}
else if (teleporterProximity > 0.0f) {
density = (teleporterProximity > 0.75f) ?
1.0f : teleporterProximity / 0.75f;
color = blindnessColor;
}
if (density > 0.0f && color != NULL) {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glColor4f(color[0], color[1], color[2], density);
glRectf(-1.0f, -1.0f, 1.0f, 1.0f);
}
}
if (useDepthComplexityOn) {
static const GLfloat depthColors[][3] = {
{ 0.0f, 0.0f, 0.0f }, // black -- 0 times
{ 0.5f, 0.0f, 1.0f }, // purple -- 1 time
{ 0.0f, 0.0f, 1.0f }, // blue -- 2 times
{ 0.0f, 1.0f, 1.0f }, // cyan -- 3 times
{ 0.0f, 1.0f, 0.0f }, // green -- 4 times
{ 1.0f, 1.0f, 0.0f }, // yellow -- 5 times
{ 1.0f, 0.5f, 0.0f }, // orange -- 6 times
{ 1.0f, 0.0f, 0.0f } // red -- 7 or more
};
static const int numColors = countof(depthColors);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
for (i = 0; i < numColors; i++) {
glStencilFunc(i == numColors - 1 ? GL_LEQUAL : GL_EQUAL, i, 0xf);
glColor3fv(depthColors[i]);
glRectf(-1.0f, -1.0f, 1.0f, 1.0f);
}
glDisable(GL_STENCIL_TEST);
}
}
void ccGenericMesh::drawMeOnly(CC_DRAW_CONTEXT& context)
{
ccGenericPointCloud* vertices = getAssociatedCloud();
if (!vertices)
return;
handleColorRamp(context);
//3D pass
if (MACRO_Draw3D(context))
{
//any triangle?
unsigned triNum = size();
if (triNum == 0)
return;
//L.O.D.
bool lodEnabled = (triNum > GET_MAX_LOD_FACES_NUMBER() && context.decimateMeshOnMove && MACRO_LODActivated(context));
unsigned decimStep = (lodEnabled ? (unsigned)ceil((float)triNum*3 / (float)GET_MAX_LOD_FACES_NUMBER()) : 1);
unsigned displayedTriNum = triNum / decimStep;
//display parameters
glDrawParams glParams;
getDrawingParameters(glParams);
glParams.showNorms &= bool(MACRO_LightIsEnabled(context));
//vertices visibility
const ccGenericPointCloud::VisibilityTableType* verticesVisibility = vertices->getTheVisibilityArray();
bool visFiltering = (verticesVisibility && verticesVisibility->isAllocated());
//wireframe ? (not compatible with LOD)
bool showWired = isShownAsWire() && !lodEnabled;
//per-triangle normals?
bool showTriNormals = (hasTriNormals() && triNormsShown());
//fix 'showNorms'
glParams.showNorms = showTriNormals || (vertices->hasNormals() && m_normalsDisplayed);
//materials & textures
bool applyMaterials = (hasMaterials() && materialsShown());
bool showTextures = (hasTextures() && materialsShown() && !lodEnabled);
//GL name pushing
bool pushName = MACRO_DrawEntityNames(context);
//special case: triangle names pushing (for picking)
bool pushTriangleNames = MACRO_DrawTriangleNames(context);
pushName |= pushTriangleNames;
if (pushName)
{
//not fast at all!
if (MACRO_DrawFastNamesOnly(context))
return;
glPushName(getUniqueIDForDisplay());
//minimal display for picking mode!
glParams.showNorms = false;
glParams.showColors = false;
//glParams.showSF --> we keep it only if SF 'NaN' values are hidden
showTriNormals = false;
applyMaterials = false;
showTextures = false;
}
//in the case we need to display scalar field colors
ccScalarField* currentDisplayedScalarField = 0;
bool greyForNanScalarValues = true;
unsigned colorRampSteps = 0;
ccColorScale::Shared colorScale(0);
if (glParams.showSF)
{
assert(vertices->isA(CC_TYPES::POINT_CLOUD));
ccPointCloud* cloud = static_cast<ccPointCloud*>(vertices);
greyForNanScalarValues = (cloud->getCurrentDisplayedScalarField() && cloud->getCurrentDisplayedScalarField()->areNaNValuesShownInGrey());
if (greyForNanScalarValues && pushName)
{
//in picking mode, no need to take SF into account if we don't hide any points!
glParams.showSF = false;
}
else
{
currentDisplayedScalarField = cloud->getCurrentDisplayedScalarField();
colorScale = currentDisplayedScalarField->getColorScale();
colorRampSteps = currentDisplayedScalarField->getColorRampSteps();
assert(colorScale);
//get default color ramp if cloud has no scale associated?!
if (!colorScale)
colorScale = ccColorScalesManager::GetUniqueInstance()->getDefaultScale(ccColorScalesManager::BGYR);
}
}
//materials or color?
bool colorMaterial = false;
if (glParams.showSF || glParams.showColors)
{
applyMaterials = false;
colorMaterial = true;
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
}
//in the case we need to display vertex colors
ColorsTableType* rgbColorsTable = 0;
if (glParams.showColors)
{
if (isColorOverriden())
{
glColor3ubv(m_tempColor);
glParams.showColors = false;
}
else
{
assert(vertices->isA(CC_TYPES::POINT_CLOUD));
rgbColorsTable = static_cast<ccPointCloud*>(vertices)->rgbColors();
}
}
else
{
glColor3fv(context.defaultMat.diffuseFront);
}
if (glParams.showNorms)
{
//DGM: Strangely, when Qt::renderPixmap is called, the OpenGL version can fall to 1.0!
glEnable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE));
glEnable(GL_LIGHTING);
context.defaultMat.applyGL(true,colorMaterial);
}
//in the case we need normals (i.e. lighting)
NormsIndexesTableType* normalsIndexesTable = 0;
ccNormalVectors* compressedNormals = 0;
if (glParams.showNorms)
{
assert(vertices->isA(CC_TYPES::POINT_CLOUD));
normalsIndexesTable = static_cast<ccPointCloud*>(vertices)->normals();
compressedNormals = ccNormalVectors::GetUniqueInstance();
}
//stipple mask
if (stipplingEnabled())
EnableGLStippleMask(true);
if (!pushTriangleNames && !visFiltering && !(applyMaterials || showTextures) && (!glParams.showSF || greyForNanScalarValues))
{
//the GL type depends on the PointCoordinateType 'size' (float or double)
GLenum GL_COORD_TYPE = sizeof(PointCoordinateType) == 4 ? GL_FLOAT : GL_DOUBLE;
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3,GL_COORD_TYPE,0,GetVertexBuffer());
if (glParams.showNorms)
{
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_COORD_TYPE,0,GetNormalsBuffer());
}
if (glParams.showSF || glParams.showColors)
{
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(3,GL_UNSIGNED_BYTE,0,GetColorsBuffer());
}
//we can scan and process each chunk separately in an optimized way
//we mimic the way ccMesh beahves by using virtual chunks!
unsigned chunks = static_cast<unsigned>(ceil((double)displayedTriNum/(double)MAX_NUMBER_OF_ELEMENTS_PER_CHUNK));
unsigned chunkStart = 0;
const colorType* col = 0;
for (unsigned k=0; k<chunks; ++k, chunkStart += MAX_NUMBER_OF_ELEMENTS_PER_CHUNK)
{
//virtual chunk size
const unsigned chunkSize = k+1 < chunks ? MAX_NUMBER_OF_ELEMENTS_PER_CHUNK : (displayedTriNum % MAX_NUMBER_OF_ELEMENTS_PER_CHUNK);
//vertices
PointCoordinateType* _vertices = GetVertexBuffer();
for (unsigned n=0; n<chunkSize; n+=decimStep)
{
const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
memcpy(_vertices,vertices->getPoint(ti->i1)->u,sizeof(PointCoordinateType)*3);
_vertices+=3;
memcpy(_vertices,vertices->getPoint(ti->i2)->u,sizeof(PointCoordinateType)*3);
_vertices+=3;
memcpy(_vertices,vertices->getPoint(ti->i3)->u,sizeof(PointCoordinateType)*3);
_vertices+=3;
}
//scalar field
if (glParams.showSF)
{
colorType* _rgbColors = GetColorsBuffer();
assert(colorScale);
for (unsigned n=0; n<chunkSize; n+=decimStep)
{
const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
col = currentDisplayedScalarField->getValueColor(ti->i1);
memcpy(_rgbColors,col,sizeof(colorType)*3);
_rgbColors += 3;
col = currentDisplayedScalarField->getValueColor(ti->i2);
memcpy(_rgbColors,col,sizeof(colorType)*3);
_rgbColors += 3;
col = currentDisplayedScalarField->getValueColor(ti->i3);
memcpy(_rgbColors,col,sizeof(colorType)*3);
_rgbColors += 3;
}
}
//colors
else if (glParams.showColors)
{
colorType* _rgbColors = GetColorsBuffer();
for (unsigned n=0; n<chunkSize; n+=decimStep)
{
const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
memcpy(_rgbColors,rgbColorsTable->getValue(ti->i1),sizeof(colorType)*3);
_rgbColors += 3;
memcpy(_rgbColors,rgbColorsTable->getValue(ti->i2),sizeof(colorType)*3);
_rgbColors += 3;
memcpy(_rgbColors,rgbColorsTable->getValue(ti->i3),sizeof(colorType)*3);
_rgbColors += 3;
}
}
//normals
if (glParams.showNorms)
{
PointCoordinateType* _normals = GetNormalsBuffer();
if (showTriNormals)
{
for (unsigned n=0; n<chunkSize; n+=decimStep)
{
CCVector3 Na, Nb, Nc;
getTriangleNormals(chunkStart + n, Na, Nb, Nc);
memcpy(_normals,Na.u,sizeof(PointCoordinateType)*3);
_normals+=3;
memcpy(_normals,Nb.u,sizeof(PointCoordinateType)*3);
_normals+=3;
memcpy(_normals,Nc.u,sizeof(PointCoordinateType)*3);
_normals+=3;
}
}
else
{
for (unsigned n=0; n<chunkSize; n+=decimStep)
{
const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
memcpy(_normals,vertices->getPointNormal(ti->i1).u,sizeof(PointCoordinateType)*3);
_normals+=3;
memcpy(_normals,vertices->getPointNormal(ti->i2).u,sizeof(PointCoordinateType)*3);
_normals+=3;
memcpy(_normals,vertices->getPointNormal(ti->i3).u,sizeof(PointCoordinateType)*3);
_normals+=3;
}
}
}
if (!showWired)
{
glDrawArrays(lodEnabled ? GL_POINTS : GL_TRIANGLES,0,(chunkSize/decimStep)*3);
}
else
{
glDrawElements(GL_LINES,(chunkSize/decimStep)*6,GL_UNSIGNED_INT,GetWireVertexIndexes());
}
}
//disable arrays
glDisableClientState(GL_VERTEX_ARRAY);
if (glParams.showNorms)
glDisableClientState(GL_NORMAL_ARRAY);
if (glParams.showSF || glParams.showColors)
glDisableClientState(GL_COLOR_ARRAY);
}
else
{
//current vertex color
const colorType *col1=0,*col2=0,*col3=0;
//current vertex normal
const PointCoordinateType *N1=0,*N2=0,*N3=0;
//current vertex texture coordinates
float *Tx1=0,*Tx2=0,*Tx3=0;
//loop on all triangles
int lasMtlIndex = -1;
if (showTextures)
{
//#define TEST_TEXTURED_BUNDLER_IMPORT
#ifdef TEST_TEXTURED_BUNDLER_IMPORT
glPushAttrib(GL_COLOR_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(context.sourceBlend, context.destBlend);
#endif
glEnable(GL_TEXTURE_2D);
}
if (pushTriangleNames)
glPushName(0);
GLenum triangleDisplayType = lodEnabled ? GL_POINTS : showWired ? GL_LINE_LOOP : GL_TRIANGLES;
glBegin(triangleDisplayType);
//per-triangle normals
const NormsIndexesTableType* triNormals = getTriNormsTable();
//materials
const ccMaterialSet* materials = getMaterialSet();
for (unsigned n=0; n<triNum; ++n)
{
//current triangle vertices
const CCLib::TriangleSummitsIndexes* tsi = getTriangleIndexes(n);
//LOD: shall we display this triangle?
if (n % decimStep)
continue;
if (visFiltering)
{
//we skip the triangle if at least one vertex is hidden
if ((verticesVisibility->getValue(tsi->i1) != POINT_VISIBLE) ||
(verticesVisibility->getValue(tsi->i2) != POINT_VISIBLE) ||
(verticesVisibility->getValue(tsi->i3) != POINT_VISIBLE))
continue;
}
if (glParams.showSF)
{
assert(colorScale);
col1 = currentDisplayedScalarField->getValueColor(tsi->i1);
if (!col1)
continue;
col2 = currentDisplayedScalarField->getValueColor(tsi->i2);
if (!col2)
continue;
col3 = currentDisplayedScalarField->getValueColor(tsi->i3);
if (!col3)
continue;
}
else if (glParams.showColors)
{
col1 = rgbColorsTable->getValue(tsi->i1);
col2 = rgbColorsTable->getValue(tsi->i2);
col3 = rgbColorsTable->getValue(tsi->i3);
}
if (glParams.showNorms)
{
if (showTriNormals)
{
assert(triNormals);
int n1,n2,n3;
getTriangleNormalIndexes(n,n1,n2,n3);
N1 = (n1>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n1)).u : 0);
N2 = (n1==n2 ? N1 : n1>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n2)).u : 0);
N3 = (n1==n3 ? N1 : n3>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n3)).u : 0);
}
else
{
N1 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i1)).u;
N2 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i2)).u;
N3 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i3)).u;
}
}
if (applyMaterials || showTextures)
{
assert(materials);
int newMatlIndex = this->getTriangleMtlIndex(n);
//do we need to change material?
if (lasMtlIndex != newMatlIndex)
{
assert(newMatlIndex<(int)materials->size());
glEnd();
if (showTextures)
{
GLuint texID = (newMatlIndex>=0 ? (*materials)[newMatlIndex].texID : 0);
if (texID>0)
assert(glIsTexture(texID));
glBindTexture(GL_TEXTURE_2D, texID);
}
//if we don't have any current material, we apply default one
(newMatlIndex>=0 ? (*materials)[newMatlIndex] : context.defaultMat).applyGL(glParams.showNorms,false);
glBegin(triangleDisplayType);
lasMtlIndex=newMatlIndex;
}
if (showTextures)
{
getTriangleTexCoordinates(n,Tx1,Tx2,Tx3);
}
}
if (pushTriangleNames)
{
glEnd();
glLoadName(n);
glBegin(triangleDisplayType);
}
else if (showWired)
{
glEnd();
glBegin(triangleDisplayType);
}
//vertex 1
if (N1)
ccGL::Normal3v(N1);
if (col1)
glColor3ubv(col1);
if (Tx1)
glTexCoord2fv(Tx1);
ccGL::Vertex3v(vertices->getPoint(tsi->i1)->u);
//vertex 2
if (N2)
ccGL::Normal3v(N2);
if (col2)
glColor3ubv(col2);
if (Tx2)
glTexCoord2fv(Tx2);
ccGL::Vertex3v(vertices->getPoint(tsi->i2)->u);
//vertex 3
if (N3)
ccGL::Normal3v(N3);
if (col3)
glColor3ubv(col3);
if (Tx3)
glTexCoord2fv(Tx3);
ccGL::Vertex3v(vertices->getPoint(tsi->i3)->u);
}
glEnd();
if (pushTriangleNames)
glPopName();
if (showTextures)
{
#ifdef TEST_TEXTURED_BUNDLER_IMPORT
glPopAttrib(); //GL_COLOR_BUFFER_BIT
#endif
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
}
}
if (stipplingEnabled())
EnableGLStippleMask(false);
if (colorMaterial)
glDisable(GL_COLOR_MATERIAL);
if (glParams.showNorms)
{
glDisable(GL_LIGHTING);
glDisable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE));
}
if (pushName)
glPopName();
}
}
void GeometryEngine::drawBaseMesh(BaseMesh* mesh, QGLWidget* glWidget, unsigned int flags)
{
if (mesh == NULL) return;
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
QVector<Edge *> edges = mesh->GetEdges();
for(int i=0;i<edges.size();i++)
{
float UT_color[3];
if(edges[i]->GetFlag()==1)
glColor3f(1.0,0.0,0.0);
else
if(edges[i]->GetFlag()==-1)
glColor3f(0.0,1.0,0.0);
else
glColor3f(0.0,0.0,1.0);
Vertex* start_v = edges[i]->GetStart();
Vertex* end_v = edges[i]->GetEnd();
glBegin(GL_LINES);
glVertex3f(start_v->x(),start_v->y(),start_v->z());
glVertex3f(end_v->x(),end_v->y(),end_v->z());
glEnd();
// if(glWidget)
// {
// glDisable(GL_DEPTH_TEST);
// glColor3f(0.0, 0.0, 0.0);
// QFont m_font;
// m_font.setPointSize(15);
// QString cur = QString("%1").arg(edges[i]->Weight(),0,'f',3);
// glWidget->renderText((start_v->x()+end_v->x())/2, (start_v->y()+end_v->y())/2, (start_v->z()+end_v->z())/2,cur,m_font);
// }
}
float UT_color[3];
QVector <Vertex*> verts = mesh->GetVertices();
glBegin(GL_POINTS);
for (int i=0; i<verts.size(); ++i){
UTILS_color_hue_to_rgb(verts[i]->Value()/720.0,UT_color);
glColor3fv(UT_color);
glVertex3f(verts[i]->x(), verts[i]->y(), verts[i]->z());
}
glEnd();
if (flags&SHADED)
{
QVector <Face*> faces = mesh->GetFaces();
for (int i=0; i<faces.size(); ++i) {
QVector <Vertex* > vertices = faces[i]->GetVertices();
float UT_color[3];
glBegin(GL_POLYGON);
for (int j=0; j<vertices.size(); ++j)
{
glColor4f(vertices[j]->Value(), vertices[j]->Value(), vertices[j]->Value(), 1);
UTILS_color_hue_to_rgb(vertices[j]->Value()/720.0,UT_color);
glColor3fv(UT_color);
glVertex3f(vertices[j]->x(), vertices[j]->y(), vertices[j]->z());
}
glEnd();
}
}
if (flags&VERTEX_DATA)
{
glDisable(GL_DEPTH_TEST);
glColor3f(0.0, 0.0, 0.0);
QFont m_font;
m_font.setPointSize(15);
for (int i=0; i<verts.size(); ++i) {
QString cur = QString("%1").arg(verts[i]->Value(),0,'f',3);
glWidget->renderText(verts[i]->x(), verts[i]->y(), verts[i]->z(),cur,m_font);
}
}
/*
QVector <Face*> faces = mesh->GetFaces();
for (int i=0; i<faces.size(); ++i) {
QVector <Vertex* > vertices = faces[i]->GetVertices();
float UT_color[3];
// glBegin(GL_LINE_LOOP);
// for (int j=0; j<vertices.size(); ++j)
// {
//// glColor4f(vertices[j]->Value(), vertices[j]->Value(), vertices[j]->Value(), 1);
// UTILS_color_hue_to_rgb(vertices[j]->Value()/720.0,UT_color);
// glColor3fv(UT_color);
// glVertex3f(vertices[j]->x(), vertices[j]->y(), vertices[j]->z());
// }
// glEnd();
glBegin(GL_POINTS);
for (int j=0; j<vertices.size(); ++j)
{
// glColor4f(vertices[j]->Value(), vertices[j]->Value(), vertices[j]->Value(), 1);
UTILS_color_hue_to_rgb(vertices[j]->Value()/720.0,UT_color);
glColor3fv(UT_color);
glVertex3f(vertices[j]->x(), vertices[j]->y(), vertices[j]->z());
}
glEnd();
// glColor4f(1.0, 1.0, 1.0, 0.5);
// for (int j=0; j<faces.size(); ++j)
// {
// glBegin(GL_POLYGON);
// QVector<Vertex*> f_vertices = faces[i]->GetVertices();
// for(int k=0;k<f_vertices.size();k++)
// {
// UTILS_color_hue_to_rgb(f_vertices[k]->Value()/720.0,UT_color);
// glColor3fv(UT_color);
// glVertex3f(f_vertices[k]->x(), f_vertices[k]->y(), f_vertices[k]->z());
// }
// glEnd();
// }
if(glWidget && (flags&VERTEX_DATA))
{
glDisable(GL_DEPTH_TEST);
glColor3f(0.0, 0.0, 0.0);
QFont m_font;
m_font.setPointSize(15);
for (int j=0; j<vertices.size(); ++j)
{
QString cur = QString("%1").arg(vertices[j]->Value(),0,'f',3);
glWidget->renderText(vertices[j]->x(), vertices[j]->y(), vertices[j]->z(),cur,m_font);
}
}
}*/
}
