void display(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); glScalef(1.3, 1.3, 1.3); glRotatef(angle, 1.0, 0.0, 0.0); glPushMatrix(); glTranslatef(-0.75, -0.5, 0.0); glRotatef(270.0, 1.0, 0.0, 0.0); glPolygonStipple(stippleMask[tetraStipple]); glCallList(TETRAHEDRON); glPopMatrix(); glPushMatrix(); glTranslatef(-0.75, 0.5, 0.0); glRotatef(90.0, 1.0, 0.0, 0.0); glPolygonStipple(stippleMask[torusStipple]); glCallList(TORUS); glPopMatrix(); glPushMatrix(); glTranslatef(0.75, 0.0, -1.0); glPolygonStipple(stippleMask[icoStipple]); glCallList(ICOSAHEDRON); glPopMatrix(); glPopMatrix(); glutSwapBuffers(); }
void display(void) { GLubyte fly[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x01, 0xC0, 0x06, 0xC0, 0x03, 0x60, 0x04, 0x60, 0x06, 0x20, 0x04, 0x30, 0x0C, 0x20, 0x04, 0x18, 0x18, 0x20, 0x04, 0x0C, 0x30, 0x20, 0x04, 0x06, 0x60, 0x20, 0x44, 0x03, 0xC0, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x66, 0x01, 0x80, 0x66, 0x33, 0x01, 0x80, 0xCC, 0x19, 0x81, 0x81, 0x98, 0x0C, 0xC1, 0x83, 0x30, 0x07, 0xe1, 0x87, 0xe0, 0x03, 0x3f, 0xfc, 0xc0, 0x03, 0x31, 0x8c, 0xc0, 0x03, 0x33, 0xcc, 0xc0, 0x06, 0x64, 0x26, 0x60, 0x0c, 0xcc, 0x33, 0x30, 0x18, 0xcc, 0x33, 0x18, 0x10, 0xc4, 0x23, 0x08, 0x10, 0x63, 0xC6, 0x08, 0x10, 0x30, 0x0c, 0x08, 0x10, 0x18, 0x18, 0x08, 0x10, 0x00, 0x00, 0x08}; GLubyte halftone[] = { 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55}; glClear (GL_COLOR_BUFFER_BIT); glColor3f (1.0, 1.0, 1.0); /* draw one solid, unstippled rectangle, */ /* then two stippled rectangles */ glRectf (25.0, 25.0, 125.0, 125.0); glEnable (GL_POLYGON_STIPPLE); glPolygonStipple (fly); glRectf (125.0, 25.0, 225.0, 125.0); glPolygonStipple (halftone); glRectf (225.0, 25.0, 325.0, 125.0); glDisable (GL_POLYGON_STIPPLE); glFlush (); }
void display() { GLubyte fly[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x01, 0xc0, 0x06, 0xc0, 0x03, 0x60, 0x04, 0x60, 0x06, 0x20, 0x04, 0x30, 0x0c, 0x20, 0x04, 0x18, 0x18, 0x20, 0x04, 0x0c, 0x30, 0x20, 0x04, 0x06, 0x60, 0x20, 0x44, 0x03, 0xc0, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x66, 0x01, 0x80, 0x66, 0x33, 0x01, 0x80, 0xcc, 0x19, 0x81, 0x81, 0x98, 0x0c, 0xc1, 0x83, 0x30, 0x07, 0xe1, 0x87, 0xe0, 0x03, 0x3f, 0xfc, 0xc0, 0x03, 0x31, 0x8c, 0xc0, 0x03, 0x33, 0xcc, 0xc0, 0x06, 0x64, 0x26, 0x60, 0x0c, 0xcc, 0x33, 0x30, 0x18, 0xcc, 0x33, 0x18, 0x10, 0xc4, 0x23, 0x08, 0x10, 0x63, 0xc6, 0x08, 0x10, 0x30, 0x0c, 0x08, 0x10, 0x18, 0x18, 0x08, 0x10, 0x00, 0x00, 0x08}; GLubyte halftone[] = { 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55}; glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glRectf(25.0, 25.0, 125.0, 125.0); glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(fly); glRectf(125.0, 25.0, 225.0, 125.0); glPolygonStipple(halftone); glRectf(225.0, 25.0, 325.0, 125.0); glDisable(GL_POLYGON_STIPPLE); glFlush(); }
void CRenderSystemGL::SetStereoMode(RENDER_STEREO_MODE mode, RENDER_STEREO_VIEW view) { CRenderSystemBase::SetStereoMode(mode, view); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDisable(GL_POLYGON_STIPPLE); glDrawBuffer(GL_BACK); if(m_stereoMode == RENDER_STEREO_MODE_ANAGLYPH_RED_CYAN) { if(m_stereoView == RENDER_STEREO_VIEW_LEFT) glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE); else if(m_stereoView == RENDER_STEREO_VIEW_RIGHT) glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE); } if(m_stereoMode == RENDER_STEREO_MODE_ANAGLYPH_GREEN_MAGENTA) { if(m_stereoView == RENDER_STEREO_VIEW_LEFT) glColorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE); else if(m_stereoView == RENDER_STEREO_VIEW_RIGHT) glColorMask(GL_TRUE, GL_FALSE, GL_TRUE, GL_TRUE); } if(m_stereoMode == RENDER_STEREO_MODE_ANAGLYPH_YELLOW_BLUE) { if(m_stereoView == RENDER_STEREO_VIEW_LEFT) glColorMask(GL_TRUE, GL_TRUE, GL_FALSE, GL_TRUE); else if(m_stereoView == RENDER_STEREO_VIEW_RIGHT) glColorMask(GL_FALSE, GL_FALSE, GL_TRUE, GL_TRUE); } if(m_stereoMode == RENDER_STEREO_MODE_INTERLACED) { glEnable(GL_POLYGON_STIPPLE); if(m_stereoView == RENDER_STEREO_VIEW_LEFT) glPolygonStipple(stipple_3d); else if(m_stereoView == RENDER_STEREO_VIEW_RIGHT) glPolygonStipple(stipple_3d+4); } if(m_stereoMode == RENDER_STEREO_MODE_HARDWAREBASED) { if(m_stereoView == RENDER_STEREO_VIEW_LEFT) glDrawBuffer(GL_BACK_LEFT); else if(m_stereoView == RENDER_STEREO_VIEW_RIGHT) glDrawBuffer(GL_BACK_RIGHT); } }
void ModelDrawer::RenderSelection (IView *view) { glEnable (GL_POLYGON_OFFSET_FILL); glPolygonOffset (0.0f, -10.0f); glDepthMask (GL_FALSE); ulong pattern[32], *i = pattern; ulong val = 0xCCCCCCCC; for (;i < pattern+32;) { *(i++)=val; *(i++)=val; val = ~val; } glPolygonStipple ((GLubyte *)&pattern[0]); glEnable (GL_POLYGON_STIPPLE); glDisable (GL_LIGHTING); glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); glDisable (GL_CULL_FACE); if (model->root) RenderSelection_ (model->root, view); glDisable (GL_POLYGON_STIPPLE); glDisable (GL_POLYGON_OFFSET_FILL); glDepthMask (GL_TRUE); glPolygonOffset (0.0f, 0.0f); }
void Layer::setLayerFillProperties() const{ //stipple fill glEnable( GL_POLYGON_STIPPLE ); glPolygonStipple( STIPPLE_MASKS[ clsStippleMask ] ); glColor4ub( clsFillColor.r, clsFillColor.g, clsFillColor.b, 100); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); }
static void draw_translucent_rect(double x0, double y0, double x1, double y1) { /* This stipple is a simple checkerboard of bits, which should * make the floor translucent */ static GLubyte halftone[] = { 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55}; glEnable (GL_POLYGON_STIPPLE); //?? glDisable (GL_CULL_FACE); glPolygonStipple (halftone); glBegin(GL_POLYGON); glVertex3d(x0, 0, y0); glVertex3d(x1, 0, y0); glVertex3d(x1, 0, y1); glVertex3d(x0, 0, y1); glEnd(); glDisable (GL_POLYGON_STIPPLE); //?? glEnable (GL_CULL_FACE); }
//Set any necessary GL settings void setup_render_state() { glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(fire); win_resized(win_w, win_h); }
void myDisplay(void) { static GLubyte Mask[128]; FILE *fb; fopen_s(&fb,"mask.bmp","rb"); if (!fb) { exit(0); } if (fseek(fb,-(int)sizeof(Mask),SEEK_END)) { exit(0); } if (!fread(Mask,sizeof(Mask),1,fb)) { exit(0); } fclose(fb); glClear(GL_COLOR_BUFFER_BIT); glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(Mask); glPolygonMode(GL_FRONT,GL_FILL); glPolygonMode(GL_BACK,GL_LINE); glRectf(0.0f, 0.0f, 1.0f, 1.0f); glDisable(GL_POLYGON_STIPPLE); glRectf(-1.0f, -1.0f, 0.0f, 0.0f); glFlush(); }
/* Draw an image using a mask bitmap. */ void drawImageAsFile(void) { static GLubyte uMask[128]; FILE* fp = 0; fp = fopen("E:\\Projects\\lab\\lab\\file\\mask.bmp", "rb"); if(!fp) { exit(0); } if(fseek(fp, -(int)sizeof(uMask), SEEK_END)) { exit(0); } if(!fread(uMask, sizeof(uMask), 1, fp)) { exit(0); } fclose(fp); Clear(); glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(uMask); glRectf(-1.0f, -1.0f, 0.0f, 0.0f); glDisable(GL_POLYGON_STIPPLE); glRectf(0.0f, 0.0f, 1.0f, 1.0f); glFlush(); }
void piglit_init(int argc, char **argv) { if (argc < 2) print_usage_and_exit(argv[0]); { char *endptr = NULL; num_samples = strtol(argv[1], &endptr, 0); if (endptr != argv[1] + strlen(argv[1])) print_usage_and_exit(argv[0]); } piglit_require_gl_version(30); piglit_ortho_projection(pattern_width, pattern_height, GL_TRUE); /* Skip the test if num_samples > GL_MAX_SAMPLES */ GLint max_samples; glGetIntegerv(GL_MAX_SAMPLES, &max_samples); if (num_samples > max_samples) piglit_report_result(PIGLIT_SKIP); ms_fbo.setup(FboConfig(num_samples, pattern_width, pattern_height)); resolve_fbo.setup(FboConfig(0, pattern_width, pattern_height)); buffer_to_test = GL_COLOR_BUFFER_BIT; shader_compile(); glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(stipple_pattern); }
void make_stipple(void) { GLuint stipple[32]; int i; for(i = 0; i < 32; i++) { stipple[i] = 0xff00ff00; } glPolygonStipple((GLubyte *)stipple); }
/* draws a shaded strip, made from gradient + flat color + gradient */ static void draw_shadedstrip(Sequence *seq, unsigned char col[3], float x1, float y1, float x2, float y2) { float ymid1, ymid2; if (seq->flag & SEQ_MUTE) { glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(stipple_halftone); } ymid1 = (y2 - y1) * 0.25f + y1; ymid2 = (y2 - y1) * 0.65f + y1; glShadeModel(GL_SMOOTH); glBegin(GL_QUADS); if (seq->flag & SEQ_INVALID_EFFECT) { col[0] = 255; col[1] = 0; col[2] = 255; } else if (seq->flag & SELECT) UI_GetColorPtrShade3ubv(col, col, -50); /* else UI_GetColorPtrShade3ubv(col, col, 0); */ /* DO NOTHING */ glColor3ubv(col); glVertex2f(x1, y1); glVertex2f(x2, y1); if (seq->flag & SEQ_INVALID_EFFECT) { col[0] = 255; col[1] = 0; col[2] = 255; } else if (seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 5); else UI_GetColorPtrShade3ubv(col, col, -5); glColor3ubv((GLubyte *)col); glVertex2f(x2, ymid1); glVertex2f(x1, ymid1); glEnd(); glRectf(x1, ymid1, x2, ymid2); glBegin(GL_QUADS); glVertex2f(x1, ymid2); glVertex2f(x2, ymid2); if (seq->flag & SELECT) UI_GetColorPtrShade3ubv(col, col, -15); else UI_GetColorPtrShade3ubv(col, col, 25); glColor3ubv((GLubyte *)col); glVertex2f(x2, y2); glVertex2f(x1, y2); glEnd(); if (seq->flag & SEQ_MUTE) { glDisable(GL_POLYGON_STIPPLE); } }
/* Draw an image using a mask array. */ void drawImageAsMask(void) { Clear(); glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(Mask); glRectf(-1.0f, -1.0f, 0.0f, 0.0f); glDisable(GL_POLYGON_STIPPLE); glRectf(0.0f, 0.0f, 1.0f, 1.0f); glFlush(); }
void ccGenericMesh::EnableGLStippleMask(bool state) { if (state) { glPolygonStipple(s_stippleMask); glEnable(GL_POLYGON_STIPPLE); } else { glDisable(GL_POLYGON_STIPPLE); } }
void RAS_OpenGLRasterizer::SetEye(const StereoEye eye) { m_curreye = eye; switch (m_stereomode) { case RAS_STEREO_QUADBUFFERED: glDrawBuffer(m_curreye == RAS_STEREO_LEFTEYE ? GL_BACK_LEFT : GL_BACK_RIGHT); break; case RAS_STEREO_ANAGLYPH: if (m_curreye == RAS_STEREO_LEFTEYE) { glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE); } else { //glAccum(GL_LOAD, 1.0f); glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE); ClearDepthBuffer(); } break; case RAS_STEREO_VINTERLACE: { // OpenGL stippling is deprecated, it is no longer possible to affect all shaders // this way, offscreen rendering and then compositing may be the better solution glEnable(GL_POLYGON_STIPPLE); glPolygonStipple((const GLubyte*) ((m_curreye == RAS_STEREO_LEFTEYE) ? left_eye_vinterlace_mask : right_eye_vinterlace_mask)); if (m_curreye == RAS_STEREO_RIGHTEYE) ClearDepthBuffer(); break; } case RAS_STEREO_INTERLACED: { glEnable(GL_POLYGON_STIPPLE); glPolygonStipple((const GLubyte*) &hinterlace_mask[m_curreye == RAS_STEREO_LEFTEYE?0:1]); if (m_curreye == RAS_STEREO_RIGHTEYE) ClearDepthBuffer(); break; } default: break; } }
void fdrawcheckerboard(float x1, float y1, float x2, float y2) { unsigned char col1[4] = {40, 40, 40}, col2[4] = {50, 50, 50}; glColor3ubv(col1); glRectf(x1, y1, x2, y2); glColor3ubv(col2); glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(stipple_checker_8px); glRectf(x1, y1, x2, y2); glDisable(GL_POLYGON_STIPPLE); }
void RAS_OpenGLRasterizer::SetEye(const StereoEye eye) { m_curreye = eye; switch (m_stereomode) { case RAS_STEREO_QUADBUFFERED: glDrawBuffer(m_curreye == RAS_STEREO_LEFTEYE ? GL_BACK_LEFT : GL_BACK_RIGHT); break; case RAS_STEREO_ANAGLYPH: if (m_curreye == RAS_STEREO_LEFTEYE) { glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE); } else { //glAccum(GL_LOAD, 1.0); glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE); ClearDepthBuffer(); } break; case RAS_STEREO_VINTERLACE: { glEnable(GL_POLYGON_STIPPLE); glPolygonStipple((const GLubyte*) ((m_curreye == RAS_STEREO_LEFTEYE) ? left_eye_vinterlace_mask : right_eye_vinterlace_mask)); if (m_curreye == RAS_STEREO_RIGHTEYE) ClearDepthBuffer(); break; } case RAS_STEREO_INTERLACED: { glEnable(GL_POLYGON_STIPPLE); glPolygonStipple((const GLubyte*) &hinterlace_mask[m_curreye == RAS_STEREO_LEFTEYE?0:1]); if (m_curreye == RAS_STEREO_RIGHTEYE) ClearDepthBuffer(); break; } default: break; } }
static void drawmeta_stipple(int value) { if (value) { glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(stipple_halftone); glEnable(GL_LINE_STIPPLE); glLineStipple(1, 0x8888); } else { glDisable(GL_POLYGON_STIPPLE); glDisable(GL_LINE_STIPPLE); } }
// This function does any needed initialization on the rendering // context. void SetupRC() { // Black background glClearColor(0.0f, 0.0f, 0.0f, 1.0f ); // Set drawing color to red glColor3f(1.0f, 0.0f, 0.0f); // Enable polygon stippling glEnable(GL_POLYGON_STIPPLE); // Specify a specific stipple pattern glPolygonStipple(fire); }
void PolygonChunk::activate(DrawActionBase *, UInt32) { // cullFace if(_sfCullFace.getValue() != GL_NONE) { glCullFace(_sfCullFace.getValue()); glEnable(GL_CULL_FACE); } // frontFace if(_sfFrontFace.getValue() != GL_CCW) glFrontFace(_sfFrontFace.getValue()); // smooth if(_sfSmooth.getValue()) glEnable(GL_POLYGON_SMOOTH); // mode if(_sfFrontMode.getValue() != GL_FILL) glPolygonMode(GL_FRONT, _sfFrontMode.getValue()); if(_sfBackMode.getValue() != GL_FILL) glPolygonMode(GL_BACK, _sfBackMode.getValue()); // offset if(_sfOffsetFactor.getValue() != 0.f || _sfOffsetBias.getValue() != 0.f) glPolygonOffset(_sfOffsetFactor.getValue(), _sfOffsetBias.getValue()); if(_sfOffsetPoint.getValue()) glEnable(GL_POLYGON_OFFSET_POINT); if(_sfOffsetLine.getValue()) glEnable(GL_POLYGON_OFFSET_LINE); if(_sfOffsetFill.getValue()) glEnable(GL_POLYGON_OFFSET_FILL); // stipple if(_mfStipple.size() == 32) { glPolygonStipple(reinterpret_cast<const GLubyte *>(&(_mfStipple[0]))); glEnable(GL_POLYGON_STIPPLE); } }
void myDisplay (void) { glClear (GL_COLOR_BUFFER_BIT); GLubyte fillPattern [ ] = { 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, }; glPolygonStipple (fillPattern); glEnable (GL_POLYGON_STIPPLE); glBegin (GL_POLYGON); // Polygon with 4 vertices. glVertex2i (100, 100); glVertex2i (300, 100); glVertex2i (300, 300); glVertex2i (100, 300); glEnd ( ); glFlush ( ); }
void display(void) { int i; glClear(GL_COLOR_BUFFER_BIT); glDisable(GL_POLYGON_STIPPLE); glEnable(GL_POLYGON_STIPPLE); glColor3f(r, g, 1.0); glPolygonStipple(tux); glBegin(GL_POLYGON); glVertex2i(100, 63); glVertex2i(50, 150); glVertex2i(100, 237); glVertex2i(200, 237); glVertex2i(250, 150); glVertex2i(200, 63); glEnd(); glFlush(); glutSwapBuffers(); }
static void wm_method_draw_stereo3d_interlace(wmWindow *win) { wmDrawData *drawdata; int view; wm_interlace_masks_create(win); for (view = 0; view < 2; view ++) { drawdata = BLI_findlink(&win->drawdata, (view * 2) + 1); glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(view ? (GLubyte *) right_interlace_mask : (GLubyte *) left_interlace_mask); wm_triple_draw_textures(win, drawdata->triple, 1.0f); glDisable(GL_POLYGON_STIPPLE); } }
/** test that lines aren't effected by polygon stipple */ static GLboolean test_lines_no_stippling(void) { const GLfloat x0 = 5.0, x1 = 40.0, xmid = 0.5 * (x0 + x1); const GLfloat x2 = 45.0, x3 = 85.0, xmid_aa = 0.5 * (x2 + x3); const GLfloat y0 = 50.0; GLubyte stipple[4 * 32]; GLboolean pass = GL_TRUE; memset(stipple, 0, sizeof(stipple)); glPolygonStipple(stipple); glEnable(GL_POLYGON_STIPPLE); glLineWidth(3.0); /* Non-AA */ glBegin(GL_LINES); glVertex2f(x0, y0); glVertex2f(x1, y0); glEnd(); if (black_pixel(xmid, y0)) { fprintf(stderr, "Error: Line not drawn because of polygon stipple.\n"); pass = GL_FALSE; } /* AA */ glEnable(GL_LINE_SMOOTH); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glBegin(GL_LINES); glVertex2f(x2, y0); glVertex2f(x3, y0); glEnd(); if (black_pixel(xmid_aa, y0)) { fprintf(stderr, "Error: AA Line not drawn because of polygon stipple.\n"); pass = GL_FALSE; } glDisable(GL_BLEND); glDisable(GL_LINE_SMOOTH); glDisable(GL_POLYGON_STIPPLE); glLineWidth(1.0); return pass; }
static void RenderScene() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0f, 1.0f, 0.0f); //¿ªÆô¶à±ßÐεã»Ìî³ä glEnable(GL_POLYGON_STIPPLE); //ÉèÖÃÌî³äģʽ glPolygonStipple(fire); glBegin(GL_POLYGON); glVertex2f(0.0f, 0.0f); glVertex2f(50.0f, 0.0f); glVertex2f(50.0f, 50.0f); glVertex2f(0.0f, 50.0f); glEnd(); glFlush(); }
static void console_draw_sel(int sel[2], int xy[2], int str_len_draw, int cwidth, int lheight) { if(sel[0] <= str_len_draw && sel[1] >= 0) { int sta = MAX2(sel[0], 0); int end = MIN2(sel[1], str_len_draw); glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(stipple_halftone); glEnable( GL_BLEND ); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4ub(255, 255, 255, 96); glRecti(xy[0]+(cwidth*sta), xy[1]-2 + lheight, xy[0]+(cwidth*end), xy[1]-2); glDisable(GL_POLYGON_STIPPLE); glDisable( GL_BLEND ); } }
void trend::Tolder::setStipple() { const byte* tellStipple = _drawprop->getCurrentFill(); if (NULL == tellStipple) { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); } else { byte FlipStillple [128]; for (word i = 0; i < 32; i++) for (word j = 0; j < 4; j++) FlipStillple[(31-i)*4 + j] = tellStipple[i*4 + j]; glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(FlipStillple); } }
void render() { GLubyte data[32*4]; for(int i=0;i<32*4;++i) { data[i]=rand(); } // Lock surface if needed if (SDL_MUSTLOCK(screen)) if (SDL_LockSurface(screen) < 0) return; // Ask SDL for the time in milliseconds int tick = SDL_GetTicks(); glClearColor(1,0,1,0); glClear(GL_COLOR_BUFFER_BIT); // and the mighty triangle.... glPushMatrix(); glRotatef(tick*0.01, 0,0,1); glEnable(GL_POLYGON_STIPPLE); glPolygonStipple(data); glBegin(GL_TRIANGLES); // Drawing Using Triangles glVertex3f( 0.0f, 1.0f, 0.0f); // Top glVertex3f(-1.0f,-1.0f, 0.0f); // Bottom Left glVertex3f( 1.0f,-1.0f, 0.0f); // Bottom Right glEnd(); glPopMatrix(); glDisable(GL_POLYGON_STIPPLE); // Unlock if needed if (SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen); // Tell SDL to update the whole screen SDL_UpdateRect(screen, 0, 0, 640, 480); }
static void Init(void) { GLint i; if (!rgb) { for (i = 0; i < 16; i++) { glutSetColor(i+CI_OFFSET_1, 0.0, 0.0, i/15.0); glutSetColor(i+CI_OFFSET_2, 0.0, i/15.0, 0.0); } } glClearColor(0.0, 0.0, 0.0, 0.0); glClearIndex(0.0); glPolygonStipple(stippleBits); antiAlias = GL_FALSE; stipple = GL_FALSE; }