ENTRYPOINT void
release_gasket(ModeInfo * mi)
{
if (gasket != NULL)
{
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
{
gasketstruct *gp = &gasket[screen];
if (gp->glx_context)
{
/* Display lists MUST be freed while their glXContext is current. */
glXMakeCurrent(MI_DISPLAY(mi), gp->window, *(gp->glx_context));
if (glIsList(gp->gasket0)) glDeleteLists(gp->gasket0, 1);
if (glIsList(gp->gasket1)) glDeleteLists(gp->gasket1, 1);
if (glIsList(gp->gasket2)) glDeleteLists(gp->gasket2, 1);
if (glIsList(gp->gasket3)) glDeleteLists(gp->gasket3, 1);
}
}
(void) free((void *) gasket);
gasket = NULL;
}
FreeAllGL(mi);
}
void free_surfaces_all()
{
if(positiveSurfaces)
{
gint i;
for(i=0;i<numberOfSurfaces;i++)
if (glIsList(positiveSurfaces[i]) == GL_TRUE) glDeleteLists(positiveSurfaces[i],1);
g_free(positiveSurfaces);
}
if(negativeSurfaces)
{
gint i;
for(i=0;i<numberOfSurfaces;i++)
if (glIsList(negativeSurfaces[i]) == GL_TRUE) glDeleteLists(negativeSurfaces[i],1);
g_free(negativeSurfaces);
}
if(nullSurfaces)
{
gint i;
for(i=0;i<numberOfSurfaces;i++)
if (glIsList(nullSurfaces[i]) == GL_TRUE) glDeleteLists(nullSurfaces[i],1);
g_free(nullSurfaces);
}
numberOfSurfaces = 0;
positiveSurfaces = NULL;
negativeSurfaces = NULL;
nullSurfaces = NULL;
free_iso_all();
deleteSurfacesPovRayFile();
}
void PointListRenderer::render() {
tgtAssert(geometryInport_.isReady(), "inport not ready");
// regenerate display list, if input data has changed
if (geometryInport_.hasChanged() || displayList_ == 0) {
if (glIsList(displayList_))
glDeleteLists(displayList_, 1);
displayList_ = 0;
// cast geometry to PointListGeometry or PointSegmentListGeometry and generate display list
PointListGeometry<vec3>* pointList = dynamic_cast< PointListGeometry<vec3>* >(geometryInport_.getData());
PointSegmentListGeometry<vec3>* segmentList = dynamic_cast< PointSegmentListGeometry<vec3>* >(geometryInport_.getData());
if (pointList)
generateDisplayList(pointList->getData());
else if (segmentList)
generateDisplayList(segmentList->getPoints());
// message on invalid geometry
if (!pointList && !segmentList) {
LWARNING("Invalid geometry. PointListGeometry<vec3> or PointSegmentListGeometry<vec3> expected.");
}
}
// render display list
if (glIsList(displayList_)) {
glCallList(displayList_);
}
}
/**
* Sends data to OpenGL (will crash if called by a non-OpenGL thread) (enforces serial entry if and only if the display list is out of date)
*/
void SurfaceMesh::draw() const {
if ( needUpdate ) {
if ( !glIsList( meshList ) ) {
meshList = glGenLists( 1 );
}
needUpdate = false;
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_COLOR_ARRAY );
glEnableClientState( GL_NORMAL_ARRAY );
glNewList( meshList, GL_COMPILE_AND_EXECUTE );
glInterleavedArrays( GL_C4F_N3F_V3F, 0, c4fn3fv3f );
glDrawElements( GL_TRIANGLES, numFaces * 3, GL_UNSIGNED_INT, triangles );
glEndList();
}
else if ( glIsList( meshList ) ) {
glCallList( meshList );
}
else {
// Nothing to draw
}
}
ENTRYPOINT void
release_planet (ModeInfo * mi)
{
if (planets != NULL) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
planetstruct *gp = &planets[screen];
if (gp->glx_context) {
/* Display lists MUST be freed while their glXContext is current. */
/* but this gets a BadMatch error. -jwz */
/*glXMakeCurrent(MI_DISPLAY(mi), gp->window, *(gp->glx_context));*/
if (glIsList(gp->platelist))
glDeleteLists(gp->platelist, 1);
if (glIsList(gp->starlist))
glDeleteLists(gp->starlist, 1);
}
}
(void) free((void *) planets);
planets = NULL;
}
FreeAllGL(mi);
}
void CLAYERS_OGL_DISP_LISTS::DrawBot() const
{
beginTransformation();
if( glIsList( m_layer_bot_triangles ) )
glCallList( m_layer_bot_triangles );
if( glIsList( m_layer_bot_segment_ends ) )
glCallList( m_layer_bot_segment_ends );
endTransformation();
}
/*=====================================================================*/
Model::~Model()
{
OPENCITY_DEBUG( "dtor" );
// Delete display lists
if (glIsList( _uiOpaqueOneSide ))
glDeleteLists( _uiOpaqueOneSide, 1 );
if (glIsList( _uiOpaqueTwoSide ))
glDeleteLists( _uiOpaqueTwoSide, 1 );
if (glIsList( _uiAlpha ))
glDeleteLists( _uiAlpha, 1 );
}
static void fini_opengl_obj(void)
{
if (xyz_list && glIsList(xyz_list)) glDeleteLists(xyz_list, 1);
if (grd_list && glIsList(grd_list)) glDeleteLists(grd_list, 1);
if (cap_list && glIsList(cap_list)) glDeleteLists(cap_list, 1);
if (cyl_list && glIsList(cyl_list)) glDeleteLists(cyl_list, 1);
if (box_list && glIsList(box_list)) glDeleteLists(box_list, 1);
box_list = 0;
cyl_list = 0;
cap_list = 0;
grd_list = 0;
xyz_list = 0;
}
void CLAYERS_OGL_DISP_LISTS::DrawBotAndMiddle() const
{
beginTransformation();
if( glIsList( m_layer_middle_contourns_quads ) )
glCallList( m_layer_middle_contourns_quads );
if( glIsList( m_layer_bot_triangles ) )
glCallList( m_layer_bot_triangles );
if( glIsList( m_layer_bot_segment_ends ) )
glCallList( m_layer_bot_segment_ends );
endTransformation();
}
ENTRYPOINT void
init_boxed(ModeInfo * mi)
{
int screen = MI_SCREEN(mi);
/* Colormap cmap; */
/* Boolean rgba, doublebuffer, cmap_installed; */
boxedstruct *gp;
MI_INIT(mi, boxed, free_boxed);
gp = &boxed[screen];
gp->window = MI_WINDOW(mi);
if ((gp->glx_context = init_GL(mi)) != NULL) {
reshape_boxed(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glDrawBuffer(GL_BACK);
if (!glIsList(gp->listobjects)) {
gp->listobjects = glGenLists(3);
gp->gllists[0] = 0;
gp->gllists[1] = 0;
gp->gllists[2] = 0;
}
pinit(mi);
} else {
MI_CLEARWINDOW(mi);
}
}
///////////////////////////////////////////
// Main logic for constructing the HDS
////////////////////////////////////////
void SubdivScene::init() {
initCamera();
//clear the HDS and list
HDS.clear();
if (glIsList(scene_list_id))
glDeleteLists(scene_list_id, 1);
//make a new list
scene_list_id = glGenLists(1);
redrawRequired = true;
switch(scenario) {
case 0:
printf("==Scenario 1:==\n");
scenario1();
break;
case 1:
printf("==Scenario 2:==\n");
scenario2();
break;
case 2:
printf("==Scenario 3:==\n");
scenario3();
break;
default:
break;
}
HDS.print();
}
void Mandel::draw() noexcept{
glClear(GL_COLOR_BUFFER_BIT);
if(glIsList(list) == GL_TRUE) glDeleteLists(list, 1);
glNewList(list, GL_COMPILE_AND_EXECUTE);
glBegin(GL_QUADS);
const double dx = 2.0/getWidth();
const double dy = 2.0/getHeight();
double x1, y1, x2, y2;
Color col;
for(int i = 0; i < width; i += res){
for(int j = 0; j < height; j += res){
if(broad){
x1 = -2.0+i*dx;
y1 = -2.0+j*dy;
}else{
x1 = -1.0+i*dx;
y1 = -1.0+j*dy;
}
x2 = x1+res*dx;
y2 = y1+res*dy;
col = blur(i, j);
glColor3d(col.r, col.g, col.b);
glVertex2d(x1, y2);
glVertex2d(x1, y1);
glVertex2d(x2, y1);
glVertex2d(x2, y2);
}
}
glEnd();
glEndList();
glFlush();
}
void CGraphics::Render() {
wglMakeCurrent(hDC,hRC);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Se borra el buffer de pantalla y profundidad
glLoadIdentity(); // Se resetea la matriz Current Modelview
if(cam) {
cam->LookAt();
}
if(gList.size()>0) {
vector<int>::iterator it;
it = gList.begin();
for(; it!=gList.end(); it++) {
if(glIsList(*it)==GL_TRUE)
glCallList(*it);
else
it = gList.erase(it);
if(it==gList.end())
break;
}
}
SwapBuffers(hDC);
}
void flag_free(void)
{
if (glIsList(flag_list))
glDeleteLists(flag_list, 1);
flag_list = 0;
}
void mark_free(void)
{
if (glIsList(mark_list))
glDeleteLists(mark_list, 1);
mark_list = 0;
}
void swch_free(void)
{
if (glIsList(swch_list))
glDeleteLists(swch_list, 2);
swch_list = 0;
}
void goal_free(void)
{
if (glIsList(goal_list))
glDeleteLists(goal_list, 1);
goal_list = 0;
}
void Geometry::draw() //Display saved geometry (default uses display list)
{
GL_Error_Check;
//Default to no shaders
if (glUseProgram) glUseProgram(0);
if (geom.size())
{
if (redraw) update();
GL_Error_Check;
redraw = false;
//Draw using display lists if available
for (unsigned int i=0; i<geom.size(); i++)
{
//Because of quad surface sorting, have to check drawable when creating lists
//When quads moved to triangle renderer can re-enable this and won't have to
//recreate display lists when hiding/showing/switching viewports
//if (drawable(i) && displaylists[i] && glIsList(displaylists[i]))
if (displaylists[i] && glIsList(displaylists[i]))
glCallList(displaylists[i]);
GL_Error_Check;
}
}
GL_Error_Check;
labels();
}
Gears::~Gears()
{
int i;
for (i = 0; i < mGearCnt; i++)
if (glIsList(mGears[i])) glDeleteLists(mGears[i], 1);
}
void Environment::createDL()
{
if((dlhandle == 0 || !glIsList(dlhandle)) && cubeMap.getUseAsDirectTextures())
{
if(dlhandle == 0)
dlhandle = glGenLists(1);
glNewList(dlhandle, GL_COMPILE);
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, environmentCubeVertices);
if(texIDhandles.empty())
texIDhandles = cubeMap.getTextureIDs();
if(texIDhandles.size() > 0)
{
if(GLEW_VERSION_1_3)
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, environmentCubeTexCoords);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, nocolor);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_REPEAT);
if(texIDhandles.size() == 1)
{
glBindTexture(GL_TEXTURE_2D, texIDhandles[0]);
glDrawArrays(GL_QUADS, 0, 24);
}
else
{
glBindTexture(GL_TEXTURE_2D, texIDhandles[0]);
glDrawArrays(GL_QUADS, 0, 4);
glBindTexture(GL_TEXTURE_2D, texIDhandles[1]);
glDrawArrays(GL_QUADS, 4, 4);
glBindTexture(GL_TEXTURE_2D, texIDhandles[2]);
glDrawArrays(GL_QUADS, 8, 4);
glBindTexture(GL_TEXTURE_2D, texIDhandles[3]);
glDrawArrays(GL_QUADS, 12, 4);
glBindTexture(GL_TEXTURE_2D, texIDhandles[4]);
glDrawArrays(GL_QUADS, 16, 4);
glBindTexture(GL_TEXTURE_2D, texIDhandles[5]);
glDrawArrays(GL_QUADS, 20, 4);
}
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_2D);
}
else
glDrawArrays(GL_QUADS, 0, 24);
glDisableClientState(GL_VERTEX_ARRAY);
}
glEndList();
}
}
/*===========================================================================*/
void DisplayList::clear()
{
if ( glIsList( m_id ) == GL_TRUE )
{
glDeleteLists( m_id, m_range );
}
}
ENTRYPOINT void
init_stairs (ModeInfo * mi)
{
int screen = MI_SCREEN(mi);
stairsstruct *sp;
if (stairs == NULL) {
if ((stairs = (stairsstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (stairsstruct))) == NULL)
return;
}
sp = &stairs[screen];
sp->step = 0.0;
sp->rotating = 0;
sp->sphere_position = NRAND(NPOSITIONS);
sp->sphere_tick = 0;
if ((sp->glx_context = init_GL(mi)) != NULL) {
reshape_stairs(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glDrawBuffer(GL_BACK);
if (!glIsList(sp->objects))
sp->objects = glGenLists(1);
pinit(mi);
} else {
MI_CLEARWINDOW(mi);
}
sp->trackball = gltrackball_init (False);
}
ENTRYPOINT void
free_splitflap (ModeInfo *mi)
{
splitflap_configuration *bp = &bps[MI_SCREEN(mi)];
int i;
if (!bp->glx_context) return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *bp->glx_context);
if (bp->flappers) free (bp->flappers);
if (bp->tc) textclient_close (bp->tc);
if (bp->trackball) gltrackball_free (bp->trackball);
if (bp->rot) free_rotator (bp->rot);
if (bp->rot2) free_rotator (bp->rot2);
if (bp->font_data) free_texture_font (bp->font_data);
if (bp->dlists) {
for (i = 0; i < countof(all_objs); i++)
if (glIsList(bp->dlists[i])) glDeleteLists(bp->dlists[i], 1);
free (bp->dlists);
}
if (bp->texinfo) {
for (i = 0; i < bp->texinfo_size; i++)
if (bp->texinfo[i].texid) glDeleteTextures (1, &bp->texinfo[i].texid);
free (bp->texinfo);
}
}
void
release_gasket(ModeInfo * mi)
{
if (gasket != NULL)
{
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
{
gasketstruct *gp = &gasket[screen];
if (gp->colors != NULL) {
XFree((caddr_t) gp->colors);
gp->colors = (XColor *) NULL;
}
if (gp->glx_context)
{
/* Display lists MUST be freed while their glXContext is current. */
glXMakeCurrent(MI_DISPLAY(mi), gp->window, *(gp->glx_context));
if (glIsList(gp->gasket1)) glDeleteLists(gp->gasket1, 1);
}
}
free(gasket);
gasket = (gasketstruct *) NULL;
}
FreeAllGL(mi);
}
void svGlyph::Render()
{
//if(STILL_UPDATE) return;
//glColor3fv(render_property.color.getValue());
if(display_mode == SV_IMMEDIATE) {
//cerr << "calling svGlyph::Render: Generate() " << endl;
Generate();
}
else if(display_mode == SV_DISPLAYLIST && glIsList(display_list)) {
//cerr << "call svGlyph::Render: displaylist... " << endl;
glCallList(display_list);
}
else if (display_mode == SV_STORE)
{
//cerr << "call svGlyph::Render(): mode is SV_STORE" << endl;
//BuildDisplayListFromStore();
/*
if(ENABLE_COLOR==true || ENABLE_LINEWIDTH==true)
RenderStoreDirect();
else
RenderStoreDirect();
*/
//RenderStore();
}
}
scene::~scene()
{
if (glIsList(1))
glDeleteLists(1, 1);
if (_fluxes!=NULL)
delete[] _fluxes;
}
void Cursor::render() {
glLoadIdentity();
glTranslatef(x, y, 0);
if (!glIsList(displayList)) {
Functions::error("no list");
}
glCallList(displayList);
}
/* all sorts of nice cleanup code should go here! */
ENTRYPOINT void free_pulsar(ModeInfo * mi)
{
pulsarstruct *gp = &Pulsar[MI_SCREEN(mi)];
if (!gp->glx_context) return;
glXMakeCurrent (MI_DISPLAY(mi), MI_WINDOW(mi), *gp->glx_context);
free(gp->quads);
if (glIsList(gp->quad_list)) glDeleteLists(gp->quad_list, 1);
}
void CBody::FreeGFX()
{
glDeleteTextures(4,(GLuint *)textures);
ZeroMemory(textures,sizeof(textures));
if (glIsList(objects[0]))
glDeleteLists(objects[0],1);
ZeroMemory(objects,sizeof(objects));
}
GLuint principalAxisGenList(GLuint axisList)
{
V4d specular = {1.0f,1.0f,1.0f,1.0f};
V4d FirstDiffuse = {1.0f,1.0f,1.0f,1.0f};
V4d FirstAmbiant = {1.0f,1.0f,1.0f,1.0f};
V4d secondDiffuse = {1.0f,1.0f,1.0f,1.0f};
V4d secondAmbiant = {1.0f,1.0f,1.0f,1.0f};
V4d thirdDiffuse = {1.0f,1.0f,1.0f,1.0f};
V4d thirdAmbiant = {1.0f,1.0f,1.0f,1.0f};
V3d firstVector = {1.0f,1.0f,1.0f};
V3d secondVector = {1.0f,1.0f,1.0f};
V3d thirdVector = {1.0f,1.0f,1.0f};
GLdouble radius = axis.radius;
gint i;
if (glIsList(axisList) == GL_TRUE) glDeleteLists(axisList,1);
compute_the_principal_axis();
if(!axis.def) return 0;
for(i=0;i<3;i++)
{
FirstDiffuse[i] = axis.firstColor[i];
secondDiffuse[i] = axis.secondColor[i];
thirdDiffuse[i] = axis.thirdColor[i];
FirstAmbiant[i] = FirstDiffuse[i]/10;
secondAmbiant[i] = secondDiffuse[i]/10;
thirdAmbiant[i] = thirdDiffuse[i]/10;
}
FirstDiffuse[3] = 1;
FirstAmbiant[3] = 1;
secondDiffuse[3] = 1;
secondAmbiant[3] = 1;
thirdDiffuse[3] = 1;
thirdAmbiant[3] = 1;
for(i=0;i<3;i++)
{
firstVector[i] = axis.firstVector[i]*axis.scal;
secondVector[i] = axis.secondVector[i]*axis.scal;
thirdVector[i] = axis.thirdVector[i]*axis.scal;
}
axisList = glGenLists(1);
glNewList(axisList, GL_COMPILE);
drawAxis(firstVector, radius, axis.origin, specular, FirstDiffuse, FirstAmbiant);
drawAxis(secondVector, radius, axis.origin, specular, secondDiffuse, secondAmbiant);
drawAxis(thirdVector, radius, axis.origin, specular, thirdDiffuse, thirdAmbiant);
glEndList();
return axisList;
}
