static void Init(void)
{
fprintf(stderr, "GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
fprintf(stderr, "GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
fprintf(stderr, "GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
fflush(stderr);
glClearColor(0.0, 0.0, 1.0, 0.0);
glPolygonMode(GL_FRONT, GL_LINE);
glPolygonMode(GL_BACK, GL_POINT);
list = glGenLists(1);
glNewList(list, GL_COMPILE);
glBegin(GL_TRIANGLES);
glEdgeFlag(1);
/* glColor3f(0,0,.7); */
glVertex3f( 0.9, -0.9, -30.0);
glEdgeFlag(0);
/* glColor3f(.8,0,0); */
glVertex3f( 0.9, 0.9, -30.0);
glEdgeFlag(1);
/* glColor3f(0,.9,0); */
glVertex3f(-0.9, 0.0, -30.0);
glEnd();
glEndList();
}
//Set RenderScene
void RenderScene(void)
{
//set Polygon Mode (Line or Fill)
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
//clear bg with present color by setting SetupRC() -> glClearColor()
glClear(GL_COLOR_BUFFER_BIT);
//save Matrix state and rotate
glPushMatrix();
glRotatef(xRot, 1.0f, 0.0f, 0.0f);
glRotatef(yRot, 0.0f, 1.0f, 0.0f);
//start to drawing x-axis and y-axis
glBegin(GL_TRIANGLES);
glEdgeFlag(bEdgeFlag);
glVertex2f(-20.0f, 0.0f);
glEdgeFlag(TRUE);
glVertex2f(20.0f, 0.0f);
glVertex2f(0.0f, 40.0f);
glVertex2f(-20.0f, 0.0f);
glVertex2f(-60.0f, -20.0f);
glEdgeFlag(bEdgeFlag);
glVertex2f(-20.0f, -40.0f);
glEdgeFlag(TRUE);
glVertex2f(-20.0f, -40.0f);
glVertex2f(00.0f, -80.0f);
glEdgeFlag(bEdgeFlag);
glVertex2f(20.0f, -40.0f);
glEdgeFlag(TRUE);
glVertex2f(20.0f, -40.0f);
glVertex2f(60.0f, -20.0f);
glEdgeFlag(bEdgeFlag);
glVertex2f(20.0f, 0.0f);
glEdgeFlag(TRUE);
glEdgeFlag(bEdgeFlag);
glVertex2f(-20.0f, 0.0f);
glVertex2f(-20.0f, -40.0f);
glVertex2f(20.0f, 0.0f);
glVertex2f(-20.0f, -40.0f);
glVertex2f(20.0f, -40.0f);
glVertex2f(20.0f, 0.0f);
glEdgeFlag(TRUE);
glEnd();
//reload Matrix for using translation
glPopMatrix();
//draw
glutSwapBuffers();
}
void RenderScene (void)
{
glPolygonMode(GL_FRONT, GL_LINE);
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLES);
{
// first
glEdgeFlag(bEdgeFlag);
glVertex2f(-20.0f, 0.0f);
glEdgeFlag(TRUE);
glVertex2f(20.0f, 0.0f);
glVertex2f(0.0f, 40.0f);
//second
glVertex2f(-20.0f, 0.0f);
glVertex2f(-60.0f, -20.0f);
glEdgeFlag(bEdgeFlag);
glVertex2f(-20.0f, -40.0f);
// third
glEdgeFlag(TRUE);
glVertex2f(-20.0f, -40.0f);
glVertex2f(0.0f, -80.0f);
glEdgeFlag(bEdgeFlag);
glVertex2f(20.0f, -40.0f);
// fourth
glEdgeFlag(TRUE);
glVertex2f(20.0f, -40.0f);
glVertex2f(60.0f, -20.0f);
glEdgeFlag(bEdgeFlag);
glVertex2f(20.0f, 0.0f);
glEdgeFlag(TRUE);
// draw two triangles for central square
// first
glEdgeFlag(bEdgeFlag);
glVertex2f(-20.0f, 0.0f);
glVertex2f(-20.0f, -40.0f);
glVertex2f(20.0f, 0.0f);
// second
glVertex2f(-20.0f, -40.0f);
glVertex2f(20.0f, -40.0f);
glVertex2f(20.0f, 0.0f);
glEdgeFlag(TRUE);
}
glEnd();
glutSwapBuffers();
}
static void Display( void )
{
glClearColor(0.2, 0.2, 0.8, 0);
glClear( GL_COLOR_BUFFER_BIT );
glPushMatrix();
/* This is the "reference" square.
*/
glTranslatef(-4.5, 0, 0);
glBlendEquation( GL_FUNC_ADD );
glBlendFunc( GL_ONE, GL_ZERO );
glBegin(GL_QUADS);
glColor3f( 0.5, 0.5, 0.5 );
glVertex2f(-1, -1);
glVertex2f( 1, -1);
glEdgeFlag(GL_TRUE);
glVertex2f( 1, 1);
glVertex2f(-1, 1);
glEnd();
glPopMatrix();
glutSwapBuffers();
}
//######### Update With Sketch Lines ###############//
void ofxSketch::update(float xL, float yL, float zL, int redL, int greenL, int blueL, int alphaL) {
ofFill();
ofSetColor(redL, greenL, blueL, alphaL);
glEdgeFlag(GL_TRUE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_LINE_SMOOTH);
glBegin(GL_POINTS); //GL_POINTS,GL_LINE_LOOP, GL_LINE_STRIP (http://pyopengl.sourceforge.net/documentation/manual/glBegin.3G.xml)
for (int i=0; i<stoixeia; i++) {
if (i==0) {
deltaX[i] = (xL - xi[i]);
deltaY[i] = (yL - yi[i]);
}
else {
deltaX[i] = (xi[i-1]-xi[i]);
deltaY[i] = (yi[i-1]-yi[i]);
}
deltaX[i] *= elastikotita[i]; // create elastikotita effect
deltaY[i] *= elastikotita[i];
epitaxinsiX[i] += deltaX[i];
epitaxinsiY[i] += deltaY[i];
xi[i] += epitaxinsiX[i];// move it
yi[i] += epitaxinsiY[i];
my3d.x = xi[i];
my3d.y = yi[i];
my3d.z = zL;
glVertex3f(my3d.x, my3d.y, my3d.z);
epitaxinsiX[i] *= aposbesi[i]; // slow down elastikotita
epitaxinsiY[i] *= aposbesi[i];
}
glEnd();
}
static void hugsprim_glEdgeFlag_3(HugsStackPtr hugs_root)
{
HsWord8 arg1;
arg1 = hugs->getWord8();
glEdgeFlag(arg1);
hugs->returnIO(hugs_root,0);
}
void CRenderer::EdgeFlag(bool bEdgeFlag)
{
if (m_pCurrState->GetEdgetFlag() != bEdgeFlag)
{
glEdgeFlag(bEdgeFlag);
FC_CHECK_GL_ERROR_DEBUG();
m_pCurrState->SetEdgeFlag(bEdgeFlag);
}
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
bool pass = true;
float green[] = {0, 1, 0, 0};
float clear[] = {0, 0, 0, 0};
piglit_ortho_projection(piglit_width, piglit_height, false);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor4f(0, 1, 0, 0);
/* Draw a rectangle, but set the flag to false for the verticals. */
glBegin(GL_QUADS);
glEdgeFlag(GL_TRUE);
glVertex2f(1.5, 1.5);
glEdgeFlag(GL_FALSE);
glVertex2f(5.5, 1.5);
glEdgeFlag(GL_TRUE);
glVertex2f(5.5, 5.5);
glEdgeFlag(GL_FALSE);
glVertex2f(1.5, 5.5);
glEdgeFlag(GL_TRUE);
glVertex2f(11.5, 1.5);
glEdgeFlag(GL_FALSE);
glVertex2f(15.5, 1.5);
glEdgeFlag(GL_TRUE);
glVertex2f(15.5, 5.5);
glEdgeFlag(GL_FALSE);
glVertex2f(11.5, 5.5);
glEnd();
pass = piglit_probe_pixel_rgba(3, 1, green) && pass;
pass = piglit_probe_pixel_rgba(3, 5, green) && pass;
pass = piglit_probe_pixel_rgba(1, 3, clear) && pass;
pass = piglit_probe_pixel_rgba(5, 3, clear) && pass;
pass = piglit_probe_pixel_rgba(13, 1, green) && pass;
pass = piglit_probe_pixel_rgba(13, 5, green) && pass;
pass = piglit_probe_pixel_rgba(11, 3, clear) && pass;
pass = piglit_probe_pixel_rgba(15, 3, clear) && pass;
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
static void Draw(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glPolygonMode(GL_FRONT, GL_LINE);
glPolygonMode(GL_BACK, GL_LINE);
glBegin(GL_TRIANGLES);
glEdgeFlag(1);
glColor3f(0,0,.7);
glVertex3f( 0.9, -0.9, -0.0);
glEdgeFlag(0);
glColor3f(.8,0,0);
glVertex3f( 0.9, 0.9, -0.0);
glEdgeFlag(1);
glColor3f(0,.9,0);
glVertex3f(-0.9, 0.0, -0.0);
glEnd();
glFlush();
if (doubleBuffer) {
glutSwapBuffers();
}
}
void RfxState::SetGLEnvironment()
{
switch (state) {
case GL_CurrentColor: {
GLfloat *res = DecodeColor(value);
glColor3f(res[0], res[1], res[2]);
delete res;
}
case GL_SecondaryColor: {
GLfloat *res = DecodeColor(value);
glSecondaryColor3f(res[0], res[1], res[2]);
delete res;
break;
}
case GL_ClearColor: {
GLfloat *res = DecodeColor(value);
glClearColor(res[0], res[1], res[2], res[3]);
delete res;
break;
}
case GL_ClearDepth:
glClearDepth(value);
break;
case GL_ShadeModel:
glShadeModel((value == 1)? GL_FLAT : GL_SMOOTH);
break;
case GL_FrontFace:
glFrontFace((value == 1)? GL_CCW : GL_CW);
break;
case GL_CullMode:
if (value == 1) {
glDisable(GL_CULL_FACE);
} else {
glEnable(GL_CULL_FACE);
glCullFace((value == 2)? GL_FRONT :
((value == 3)? GL_BACK : GL_FRONT_AND_BACK));
}
break;
case GL_EdgeFlag:
glEdgeFlag(value);
break;
case GL_DepthNear:
case GL_DepthFar: {
GLfloat range[2];
glGetFloatv(GL_DEPTH_RANGE, range);
if (state == GL_DepthNear)
glDepthRange(value, range[1]);
else
glDepthRange(range[0], value);
break;
}
case GL_FogColor: {
glFogfv(GL_FOG_COLOR, DecodeColor(value));
break;
}
case GL_FogDensity:
glFogi(GL_FOG_DENSITY, value);
break;
case GL_FogStart:
glFogi(GL_FOG_START, value);
break;
case GL_FogEnd:
glFogi(GL_FOG_END, value);
break;
case GL_FogMode:
glEnable(GL_FOG);
switch ((GLint)value) {
case 1: // NONE
glDisable(GL_FOG);
break;
case 2: // LINEAR
glFogi(GL_FOG_MODE, GL_LINEAR);
break;
case 3: // EXP
glFogi(GL_FOG_MODE, GL_EXP);
break;
case 4: // EXP2
glFogi(GL_FOG_MODE, GL_EXP2);
break;
default: // UNKNOWN
break;
}
break;
case GL_PointSize:
glPointSize(value);
break;
case GL_PointMin:
glPointParameterf(GL_POINT_SIZE_MIN, value);
break;
case GL_PointMax:
glPointParameterf(GL_POINT_SIZE_MAX_ARB, value);
break;
case GL_PointSmooth:
GLEnableDisable(GL_POINT_SMOOTH);
break;
case GL_LineWidth:
glLineWidth(value);
break;
case GL_LineSmooth:
GLEnableDisable(GL_LINE_SMOOTH);
break;
case GL_PolyFrontMode:
glPolygonMode(GL_FRONT, (value == 1)? GL_POINT :
((value == 2)? GL_LINE : GL_FILL));
break;
case GL_PolyBackMode:
glPolygonMode(GL_BACK, (value == 1)? GL_POINT :
((value == 2)? GL_LINE : GL_FILL));
break;
case GL_PolySmooth:
GLEnableDisable(GL_POLYGON_SMOOTH);
break;
case GL_PolyOffsetFactor: {
GLfloat units;
glGetFloatv(GL_POLYGON_OFFSET_UNITS, &units);
glPolygonOffset(value, units);
break;
}
case GL_PolyOffsetUnits: {
GLfloat factor;
glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &factor);
glPolygonOffset(factor, value);
break;
}
case GL_PolyOffsetPoint:
GLEnableDisable(GL_POLYGON_OFFSET_POINT);
break;
case GL_PolyOffsetLine:
GLEnableDisable(GL_POLYGON_OFFSET_LINE);
break;
case GL_PolyOffsetFill:
GLEnableDisable(GL_POLYGON_OFFSET_FILL);
break;
case GL_AlphaEnable:
GLEnableDisable(GL_ALPHA_TEST);
break;
case GL_AlphaFunction: {
GLfloat ref;
glGetFloatv(GL_ALPHA_TEST_REF, &ref);
glAlphaFunc(GLFunctionMode(), ref);
break;
}
case GL_AlphaReference: {
GLint func;
glGetIntegerv(GL_ALPHA_TEST_FUNC, &func);
glAlphaFunc(func, value);
break;
}
case GL_DepthEnable:
GLEnableDisable(GL_DEPTH_TEST);
break;
case GL_DepthFunction:
glDepthFunc(GLFunctionMode());
break;
case GL_BlendEnable:
GLEnableDisable(GL_BLEND);
break;
case GL_BlendColor: {
GLfloat *res = DecodeColor(value);
glBlendColor(res[0], res[1], res[2], res[3]);
delete res;
break;
}
case GL_BlendSourceRGB:
case GL_BlendDestRGB:
case GL_BlendSourceAlpha:
case GL_BlendDestAlpha: {
GLint srcdst[4];
glGetIntegerv(GL_BLEND_SRC_RGB, &srcdst[0]);
glGetIntegerv(GL_BLEND_DST_RGB, &srcdst[1]);
glGetIntegerv(GL_BLEND_SRC_ALPHA, &srcdst[2]);
glGetIntegerv(GL_BLEND_DST_ALPHA, &srcdst[3]);
glBlendFuncSeparate(
((state == GL_BlendSourceRGB)? GLColorMode() : srcdst[0]),
((state == GL_BlendDestRGB)? GLColorMode() : srcdst[1]),
((state == GL_BlendSourceAlpha)? GLColorMode() : srcdst[2]),
((state == GL_BlendDestAlpha)? GLColorMode() : srcdst[3]));
break;
}
case GL_BlendEquation:
switch ((GLint)value) {
case 1: // ADD
glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
break;
case 2: // SUBTRACT
glBlendEquationSeparate(GL_FUNC_SUBTRACT, GL_FUNC_SUBTRACT);
break;
case 3: // REV_SUBTRACT
glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT);
break;
case 4: // MIN
glBlendEquationSeparate(GL_MIN, GL_MIN);
break;
case 5: // MAX
glBlendEquationSeparate(GL_MAX, GL_MAX);
break;
}
break;
case GL_WriteMaskColor: {
GLint val = (GLint)value;
GLboolean par[4];
par[3] = (val > 8)? GL_TRUE : GL_FALSE;
par[2] = (val -= (8 * par[3]) > 4)? GL_TRUE : GL_FALSE;
par[1] = (val -= (4 * par[2]) > 2)? GL_TRUE : GL_FALSE;
par[0] = (val -= (2 * par[1]) > 1)? GL_TRUE : GL_FALSE;
glColorMask(par[0], par[1], par[2], par[3]);
break;
}
case GL_WriteMaskDepth:
glDepthMask(value);
break;
case GL_VertexProgramTwoSideARB:
GLEnableDisable(GL_VERTEX_PROGRAM_TWO_SIDE_ARB);
break;
case GL_StencilEnable:
GLEnableDisable(GL_STENCIL_TEST);
break;
case GL_StencilFunction:
case GL_StencilValueMask:
case GL_StencilReference: {
GLint StFun[3];
glGetIntegerv(GL_STENCIL_FUNC, &StFun[0]);
glGetIntegerv(GL_STENCIL_VALUE_MASK, &StFun[1]);
glGetIntegerv(GL_STENCIL_REF, &StFun[2]);
glStencilFunc(
(state == GL_StencilFunction)? GLFunctionMode() : StFun[0],
(state == GL_StencilValueMask)? value : StFun[1],
(state == GL_StencilReference)? value : StFun[2]);
break;
}
case GL_StencilFail:
case GL_StencilPassDepthFail:
case GL_StencilPassDepthPass: {
GLint StOp[3];
glGetIntegerv(GL_STENCIL_FAIL, &StOp[0]);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &StOp[1]);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &StOp[2]);
// thanks god at least these values are equivalent to OpenGL ones,
// no mapping needed.
glStencilOp(
(state == GL_StencilFail)? value : StOp[0],
(state == GL_StencilPassDepthFail)? value : StOp[1],
(state == GL_StencilPassDepthPass)? value : StOp[2]);
break;
}
case GL_WriteMaskStencil:
glStencilMask(value);
break;
case GL_ClearStencil:
glClearStencil(value);
break;
default:
// do nothing, unsupported state
break;
}
}
// Draws triangles with vertex error, using downsampling to reduce the total
// number of triangles. If downsampling is one, each error sample will get
// drawn.
void Error3DViewerWidget::drawVertexErrorT() const
{
int k,i,j,jmax,n;
vertex_t u,v;
vertex_t a,b,c;
face_t *cur_face;
int i0,i1,i2,i3;
int j0,j1,j2,j3;
int l0,l1,l2,l3;
vertex_t v0,v1,v2,v3;
glBegin(GL_TRIANGLES);
for (k=0; k<model->mesh->num_faces; k++) {
n = model->fe[k].sample_freq;
cur_face = &(model->mesh->faces[k]);
if (n == 1 && downsampling == 1) {
/* displaying only at triangle vertices + center */
a = model->mesh->vertices[cur_face->f0];
b = model->mesh->vertices[cur_face->f1];
c = model->mesh->vertices[cur_face->f2];
v3.x = 1/3.0*(a.x+b.x+c.x);
v3.y = 1/3.0*(a.y+b.y+c.y);
v3.z = 1/3.0*(a.z+b.z+c.z);
setGLColorForError(model->verror[cur_face->f0]);
glEdgeFlag(GL_TRUE);
glVertex3f(a.x,a.y,a.z);
setGLColorForError(model->verror[cur_face->f1]);
glEdgeFlag(GL_FALSE);
glVertex3f(b.x,b.y,b.z);
setGLColorForError(model->fe[k].serror[0]);
glVertex3f(v3.x,v3.y,v3.z);
setGLColorForError(model->verror[cur_face->f0]);
glVertex3f(a.x,a.y,a.z);
setGLColorForError(model->fe[k].serror[0]);
glVertex3f(v3.x,v3.y,v3.z);
setGLColorForError(model->verror[cur_face->f2]);
glEdgeFlag(GL_TRUE);
glVertex3f(c.x,c.y,c.z);
setGLColorForError(model->verror[cur_face->f1]);
glVertex3f(b.x,b.y,b.z);
setGLColorForError(model->verror[cur_face->f2]);
glEdgeFlag(GL_FALSE);
glVertex3f(c.x,c.y,c.z);
setGLColorForError(model->fe[k].serror[0]);
glVertex3f(v3.x,v3.y,v3.z);
} else if (downsampling >= n) {
/* displaying only at triangle vertices */
glEdgeFlag(GL_TRUE);
setGLColorForError(model->verror[cur_face->f0]);
glVertex3f(model->mesh->vertices[cur_face->f0].x,
model->mesh->vertices[cur_face->f0].y,
model->mesh->vertices[cur_face->f0].z);
setGLColorForError(model->verror[cur_face->f1]);
glVertex3f(model->mesh->vertices[cur_face->f1].x,
model->mesh->vertices[cur_face->f1].y,
model->mesh->vertices[cur_face->f1].z);
setGLColorForError(model->verror[cur_face->f2]);
glVertex3f(model->mesh->vertices[cur_face->f2].x,
model->mesh->vertices[cur_face->f2].y,
model->mesh->vertices[cur_face->f2].z);
} else { /* displaying at error samples and triangle vertices */
assert(n > 1);
a = model->mesh->vertices[cur_face->f0];
b = model->mesh->vertices[cur_face->f1];
c = model->mesh->vertices[cur_face->f2];
substract_v(&b,&a,&u);
substract_v(&c,&a,&v);
prod_v(1/(float)(n-1),&u,&u);
prod_v(1/(float)(n-1),&v,&v);
for (i=0; i<n-1; i+=downsampling) {
i2 = (i+downsampling < n) ? i+downsampling : n-1;
for (j=0, jmax=n-i-1; j<jmax; j+=downsampling) {
if (i+j+downsampling < n) {
i0 = i;
j0 = j;
i1 = i+downsampling;
j1 = j;
i2 = i;
j2 = j+downsampling;
i3 = i1;
j3 = j2;
} else {
i2 = i;
j2 = j;
i0 = (i+downsampling < n) ? i+downsampling : n-1;
j0 = (j>0) ? j-downsampling : j;
assert(j0 >= 0);
i1 = i0;
j1 = n-1-i1;
i3 = i;
j3 = n-1-i3;
assert(j3 >= 0);
}
l0 = j0+i0*(2*n-i0+1)/2;
l1 = j1+i1*(2*n-i1+1)/2;
l2 = j2+i2*(2*n-i2+1)/2;
v0.x = a.x+i0*u.x+j0*v.x;
v0.y = a.y+i0*u.y+j0*v.y;
v0.z = a.z+i0*u.z+j0*v.z;
v1.x = a.x+i1*u.x+j1*v.x;
v1.y = a.y+i1*u.y+j1*v.y;
v1.z = a.z+i1*u.z+j1*v.z;
v2.x = a.x+i2*u.x+j2*v.x;
v2.y = a.y+i2*u.y+j2*v.y;
v2.z = a.z+i2*u.z+j2*v.z;
if (i0 != i1 || j0 != j1) { /* avoid possible degenerate */
setGLColorForError(model->fe[k].serror[l0]);
glEdgeFlag(j0 == 0 && j1 == 0);
glVertex3f(v0.x,v0.y,v0.z);
setGLColorForError(model->fe[k].serror[l1]);
glEdgeFlag(i1+j1 == n-1 && i2+j2 == n-1);
glVertex3f(v1.x,v1.y,v1.z);
setGLColorForError(model->fe[k].serror[l2]);
glEdgeFlag(i2 == 0 && i0 == 0);
glVertex3f(v2.x,v2.y,v2.z);
}
if (i3+j3 < n) {
l3 = j3+i3*(2*n-i3+1)/2;
v3.x = a.x+i3*u.x+j3*v.x;
v3.y = a.y+i3*u.y+j3*v.y;
v3.z = a.z+i3*u.z+j3*v.z;
setGLColorForError(model->fe[k].serror[l3]);
glEdgeFlag(i3 == 0 && i2 == 0);
glVertex3f(v3.x,v3.y,v3.z);
setGLColorForError(model->fe[k].serror[l2]);
glEdgeFlag(j2 == 0 && j1 == 0);
glVertex3f(v2.x,v2.y,v2.z);
setGLColorForError(model->fe[k].serror[l1]);
glEdgeFlag(i1+j1 == n-1 && i3+j3 == n-1);
glVertex3f(v1.x,v1.y,v1.z);
}
}
}
}
}
glEdgeFlag(GL_TRUE); /* restore default */
glEnd();
}
// Called to draw scene
void RenderScene(void)
{
// Clear the window
glClear(GL_COLOR_BUFFER_BIT);
// Draw back side as a polygon only, if flag is set
if(iMode == MODE_LINE)
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
if(iMode == MODE_POINT)
glPolygonMode(GL_FRONT_AND_BACK,GL_POINT);
if(iMode == MODE_SOLID)
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
// Save matrix state and do the rotation
glPushMatrix();
glRotatef(xRot, 1.0f, 0.0f, 0.0f);
glRotatef(yRot, 0.0f, 1.0f, 0.0f);
// Begin the triangles
glBegin(GL_TRIANGLES);
glEdgeFlag(bEdgeFlag);
glVertex2f(-20.0f, 0.0f);
glEdgeFlag(GL_TRUE);
glVertex2f(20.0f, 0.0f);
glVertex2f(0.0f, 40.0f);
glVertex2f(-20.0f,0.0f);
glVertex2f(-60.0f,-20.0f);
glEdgeFlag(bEdgeFlag);
glVertex2f(-20.0f,-40.0f);
glEdgeFlag(GL_TRUE);
glVertex2f(-20.0f,-40.0f);
glVertex2f(0.0f, -80.0f);
glEdgeFlag(bEdgeFlag);
glVertex2f(20.0f, -40.0f);
glEdgeFlag(GL_TRUE);
glVertex2f(20.0f, -40.0f);
glVertex2f(60.0f, -20.0f);
glEdgeFlag(bEdgeFlag);
glVertex2f(20.0f, 0.0f);
glEdgeFlag(GL_TRUE);
// Center square as two triangles
glEdgeFlag(bEdgeFlag);
glVertex2f(-20.0f, 0.0f);
glVertex2f(-20.0f,-40.0f);
glVertex2f(20.0f, 0.0f);
glVertex2f(-20.0f,-40.0f);
glVertex2f(20.0f, -40.0f);
glVertex2f(20.0f, 0.0f);
glEdgeFlag(GL_TRUE);
// Done drawing Triangles
glEnd();
// Restore transformations
glPopMatrix();
// Flush drawing commands
glutSwapBuffers();
}
M(void, glEdgeFlag, jboolean flag) {
glEdgeFlag(flag);
}
//
// Draws pentagon from triangles: full pentagon if 5 triangle could be build from _vertexes array.
// If generates less than 5 vertexes, than we have not a full pentagon.
//
void AsteroidEnemy::Draw()
{
if (!_isVisible)
{
return;
}
int size = _vertexes.size();
// Dust.
if (size == 1)
{
glBegin(GL_POINTS);
glColor3f(0.0, 1.0, 1.0);
glVertex2f(_vertexes[0].x, _vertexes[0].y);
glEnd();
glBegin(GL_POINTS);
glColor3f(0.0, 1.0, 1.0);
glVertex2f(_x, _y);
glEnd();
return;
}
// Shape
for (int i = 0; i < size; i++)
{
Vertex v1 = _vertexes[i];
int next = i + 1;
if (next >= size)
{
// Draw last triangle ONLY if this is a full pentagon.
if (size == PENTAGON_RIBERS_NUMBER)
{
next = 0;
}
else
{
continue;
}
}
Vertex v2 = _vertexes[next];
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glColor3f(1.0, 0.0, 1.0);
glBegin(GL_POLYGON);
// Calculate visibility of first riber.
if (_isPiece || (size != PENTAGON_RIBERS_NUMBER && i == 0))
{
// First riber becomes visible if shape is not full.
glEdgeFlag(GL_TRUE);
}
else
{
// No one internal riber should be visible in the Full Pentagon.
glEdgeFlag(GL_FALSE);
}
glVertex2f(_x, _y);
// Middle riber always visible.
glEdgeFlag(GL_TRUE);
glVertex2f(v1.x, v1.y);
// Calculate visibility of last riber.
if (_isPiece || (size != PENTAGON_RIBERS_NUMBER && i == size - 2))
{
// First riber becomes visible if shape is not full.
glEdgeFlag(GL_TRUE);
}
else
{
// No one internal riber should be visible in the Full Pentagon.
glEdgeFlag(GL_FALSE);
}
glVertex2f(v2.x, v2.y);
glEnd();
}
//glBegin(GL_POINTS);
//glColor3f(0.0, 1.0, 1.0);
//glVertex2f(_x, _y);
//glEnd();
}
bool glWindow::ResetGL () {
if (m_resetGLMode == RGM_RECREATEWINDOW) {
RecreateWindow (m_fullScreen, m_border, m_width, m_height, m_bpp, m_stencil, m_title, m_allowResizing, m_fitToWorkArea);
return true;
}
else if (m_resetGLMode == RGM_RECREATECONTEXT) {
RecreateGLContext ();
return true;
}
// Setup OpenGL defaults.
// This should reset as much as possible back to the initial state of OpenGL.
// Exceptions:
// * Projection matrix is initialised to a perspective transform
// End current gl block
try { glEnd (); } catch (...) { ; }
m_dontPaint = false;
// Intialise matrices
try { glMatrixMode (GL_PROJECTION); ClearGLMatrix (); } catch (...) { ; }
try { glMatrixMode (GL_TEXTURE); ClearGLMatrix (); } catch (...) { ; }
try { glMatrixMode (GL_MODELVIEW); ClearGLMatrix (); } catch (...) { ; }
// Initialise state
int i;
try { glColor4f (1, 1, 1, 1); } catch (...) { ; }
try { glIndexi (1); } catch (...) { ; }
try { glTexCoord4f (0, 0, 0, 1); } catch (...) { ; }
try { glNormal3f (0, 0, 1); } catch (...) { ; }
// try { glRasterPos4f (0, 0, 0, 1); } catch (...) { ; }
try { glEdgeFlag (GL_TRUE); } catch (...) { ; }
try { glDisable (GL_VERTEX_ARRAY); } catch (...) { ; }
try { glDisable (GL_NORMAL_ARRAY); } catch (...) { ; }
try { glDisable (GL_COLOR_ARRAY); } catch (...) { ; }
try { glDisable (GL_INDEX_ARRAY); } catch (...) { ; }
try { glDisable (GL_TEXTURE_COORD_ARRAY); } catch (...) { ; }
try { glDisable (GL_EDGE_FLAG_ARRAY); } catch (...) { ; }
try { glDepthRange (0, 1); } catch (...) { ; }
try { glDisable (GL_NORMALIZE); } catch (...) { ; }
for (i = 0; i < GL_MAX_CLIP_PLANES; i++)
try { glDisable (GL_CLIP_PLANE0 + i); } catch (...) { ; }
GLfloat fog[] = {0, 0, 0, 0};
try { glFogfv (GL_FOG_COLOR, fog); } catch (...) { ; }
try { glFogi (GL_FOG_INDEX, 0); } catch (...) { ; }
try { glFogf (GL_FOG_DENSITY, 1.0); } catch (...) { ; }
try { glFogf (GL_FOG_START, 0.0); } catch (...) { ; }
try { glFogf (GL_FOG_END, 1.0); } catch (...) { ; }
try { glFogi (GL_FOG_MODE, GL_EXP); } catch (...) { ; }
try { glDisable (GL_FOG); } catch (...) { ; }
try { glShadeModel (GL_SMOOTH); } catch (...) { ; }
try { glDisable (GL_LIGHTING); } catch (...) { ; }
try { glDisable (GL_COLOR_MATERIAL); } catch (...) { ; }
try { glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); } catch (...) { ; }
GLfloat ambient[] = { 0.2, 0.2, 0.2, 1.0 },
diffuse[] = { 0.8, 0.8, 0.8, 1.0 },
specular[] = { 0.0, 0.0, 0.0, 1.0 },
emission[] = { 0.0, 0.0, 0.0, 1.0 },
shininess[] = { 0.0 };
try { glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, ambient); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, specular); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_EMISSION, emission); } catch (...) { ; }
try { glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, shininess); } catch (...) { ; }
try { glLightModelfv (GL_LIGHT_MODEL_AMBIENT, ambient); } catch (...) { ; }
try { glLightModeli (GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE); } catch (...) { ; }
try { glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); } catch (...) { ; }
GLfloat lambient[] = { 0.0, 0.0, 0.0, 1.0 },
ldiffuse0[] = { 1.0, 1.0, 1.0, 1.0 },
ldiffuse1[] = { 0.0, 0.0, 0.0, 1.0 },
lspecular0[] = { 1.0, 1.0, 1.0, 1.0 },
lspecular1[] = { 0.0, 0.0, 0.0, 1.0 },
lposition[] = { 0.0, 0.0, 1.0, 0.0 };
for (i = 0; i < 8; i++) {
try { glLightfv (GL_LIGHT0 + i, GL_AMBIENT, lambient); } catch (...) { ; }
try { glLightfv (GL_LIGHT0 + i, GL_DIFFUSE, i == 0 ? ldiffuse0 : ldiffuse1); } catch (...) { ; }
try { glLightfv (GL_LIGHT0 + i, GL_SPECULAR, i == 0 ? lspecular0 : lspecular1); } catch (...) { ; }
try { glLightfv (GL_LIGHT0 + i, GL_POSITION, lposition); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_SPOT_EXPONENT, 0.0); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, 1.0); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, 0.0); } catch (...) { ; }
try { glLightf (GL_LIGHT0 + i, GL_QUADRATIC_ATTENUATION, 0.0); } catch (...) { ; }
try { glDisable (GL_LIGHT0 + i); } catch (...) { ; }
}
try { glPointSize (1.0); } catch (...) { ; }
try { glDisable (GL_POINT_SMOOTH); } catch (...) { ; }
try { glLineWidth (1.0); } catch (...) { ; }
try { glDisable (GL_LINE_SMOOTH); } catch (...) { ; }
try { glLineStipple (1, 0xffff); } catch (...) { ; }
try { glDisable (GL_LINE_STIPPLE); } catch (...) { ; }
try { glDisable (GL_CULL_FACE); } catch (...) { ; }
try { glCullFace (GL_BACK); } catch (...) { ; }
try { glFrontFace (GL_CCW); } catch (...) { ; }
try { glDisable (GL_POLYGON_SMOOTH); } catch (...) { ; }
try { glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); } catch (...) { ; }
try { glDisable (GL_TEXTURE_1D); } catch (...) { ; }
try { glDisable (GL_TEXTURE_2D); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); } catch (...) { ; }
try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); } catch (...) { ; }
GLfloat texBorder[] = {0, 0, 0, 0};
try { glTexParameterfv (GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, texBorder); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_T); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_S); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_R); } catch (...) { ; }
try { glDisable (GL_TEXTURE_GEN_Q); } catch (...) { ; }
for (i = 0; i < 4; i++) {
GLenum coord;
switch (i) {
case 0: coord = GL_T; break;
case 1: coord = GL_S; break;
case 2: coord = GL_R; break;
case 3: coord = GL_Q; break;
}
try { glTexGeni (coord, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); } catch (...) { ; }
}
try { glDisable (GL_SCISSOR_TEST); } catch (...) { ; }
try { glDisable (GL_ALPHA_TEST); } catch (...) { ; }
try { glAlphaFunc (GL_ALWAYS, 0); } catch (...) { ; }
try { glDisable (GL_STENCIL_TEST); } catch (...) { ; }
try { glStencilFunc (GL_ALWAYS, 0, 0xffffffff); } catch (...) { ; }
try { glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP); } catch (...) { ; }
try { glDisable (GL_DEPTH_TEST); } catch (...) { ; }
try { glDepthFunc (GL_LESS); } catch (...) { ; }
try { glDisable (GL_BLEND); } catch (...) { ; }
try { glBlendFunc (GL_ONE, GL_ZERO); } catch (...) { ; }
try { glDrawBuffer (GL_BACK); } catch (...) { ; }
try { glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); } catch (...) { ; }
try { glDepthMask (GL_TRUE); } catch (...) { ; }
try { glClearAccum (0, 0, 0, 0); } catch (...) { ; }
try { glClearColor (0, 0, 0, 0); } catch (...) { ; }
try { glClearDepth (1); } catch (...) { ; }
try { glClearIndex (0); } catch (...) { ; }
try { glClearStencil (0); } catch (...) { ; }
try { glPixelStorei (GL_PACK_SWAP_BYTES, GL_FALSE); } catch (...) { ; }
try { glPixelStorei (GL_PACK_LSB_FIRST, GL_FALSE); } catch (...) { ; }
try { glPixelStoref (GL_PACK_ROW_LENGTH, 0); } catch (...) { ; }
try { glPixelStoref (GL_PACK_SKIP_PIXELS, 0); } catch (...) { ; }
try { glPixelStorei (GL_PACK_ALIGNMENT, 4); } catch (...) { ; }
try { glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE); } catch (...) { ; }
try { glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE); } catch (...) { ; }
try { glPixelStoref (GL_UNPACK_ROW_LENGTH, 0); } catch (...) { ; }
try { glPixelStoref (GL_UNPACK_SKIP_PIXELS, 0); } catch (...) { ; }
try { glPixelStorei (GL_UNPACK_ALIGNMENT, 4); } catch (...) { ; }
try { glPixelTransferi (GL_MAP_COLOR, GL_FALSE); } catch (...) { ; }
try { glPixelTransferi (GL_MAP_STENCIL, GL_FALSE); } catch (...) { ; }
try { glPixelTransferi (GL_INDEX_SHIFT, 0); } catch (...) { ; }
try { glPixelTransferi (GL_INDEX_OFFSET, 0); } catch (...) { ; }
try { glPixelTransferf (GL_RED_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_GREEN_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_BLUE_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_ALPHA_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_DEPTH_SCALE, 1.0); } catch (...) { ; }
try { glPixelTransferf (GL_RED_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_GREEN_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_BLUE_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_ALPHA_BIAS, 0.0); } catch (...) { ; }
try { glPixelTransferf (GL_DEPTH_BIAS, 0.0); } catch (...) { ; }
try { glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_POINT_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_POLYGON_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; }
try { glHint (GL_FOG_HINT, GL_DONT_CARE); } catch (...) { ; }
// Multitexturing
if (ExtensionSupported ("GL_ARB_multitexture")) {
// Disable texturing for all texture units
int units;
try { glGetIntegerv (GL_MAX_TEXTURE_UNITS_ARB, &units); } catch (...) { ; }
for (int i = 0; i < units; i++) {
if (glActiveTexture != NULL)
glActiveTexture (GL_TEXTURE0_ARB + i);
try { glDisable (GL_TEXTURE_2D); } catch (...) { ; }
try { glDisable (GL_TEXTURE_1D); } catch (...) { ; }
if (i == 0) try { glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } catch (...) { ; }
else try { glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND); } catch (...) { ; }
}
if (glActiveTexture != NULL)
try { glActiveTexture (GL_TEXTURE0_ARB); } catch (...) { ; }
}
// Setup OpenGL defaults
OpenGLDefaults ();
return TRUE; // Initialization Went OK
}
