void Win3D::capturing() {
glClear(GL_ACCUM_BUFFER_BIT);
for (int jitter = 0; jitter < 4; jitter++) {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
accPerspective(mPersp,
static_cast<double>(mWinWidth)
/ static_cast<double>(mWinHeight),
0.1, 10.0, Jitter::j4[jitter].x, Jitter::j4[jitter].y,
0.0, 0.0, 1.0);
gluLookAt(mEye[0], mEye[1], mEye[2], 0.0, 0.0, -1.0, 0.0, 1.0, 0.0);
initGL();
mTrackBall.applyGLRotation();
glScalef(mZoom, mZoom, mZoom);
glTranslatef(mTrans[0]*0.001, mTrans[1]*0.001, mTrans[2]*0.001);
initLights();
draw();
glAccum(GL_ACCUM, 0.25);
}
glAccum(GL_RETURN, 1.0);
}
void InstantRadiosity( int N, double rho )
{
double Start = N;
for ( int Reflections = 0, End = N; End > 0; End = (int)Start, Reflections++ ) {
Start *= rho;
for ( int i = (int)Start; i < End; i++ ) {
// Select starting point on light source
Point y( phi( 2, i ), phi( 3, i ) );
Color L( Le( y ) ); // Le( y ) * supp Le; supp Le?
double w = N;
// trace reflections
for ( int j = 0; j <= Reflections; j++ ) {
glRenderShadowedScene( N / floor( w ) * L, y );
glAccum( GL_ACCUM, 1 / N );
// diffuse scattering
Vector ω = ωd( phi( 2 * j + 2, i ), phi( 2 * j + 3, ( i ) );
//trace ray from y into direction ω
y = h( y, ω );
// Attenuate and compensate
L *= fd( y );
w *= ρ;
}
}
}
glAccum( GL_RETURN, 1.0 );
}
void CALLBACK Paint(void)
{
int jitter;
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT,viewport);
if(!viewport[3])return;
glClear(GL_ACCUM_BUFFER_BIT);
for(jitter=0;jitter<8;jitter++)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
accPerspective(45.0,(GLdouble)viewport[2]/(GLdouble)viewport[3],
1.0,15.0,0.0,0.0,0.33*j8[jitter].x,0.33*j8[jitter].y,5.0);
renderTeapot(-1.1,-0.5,-4.5,0.1745,0.01175,0.01175,
0.61424,0.04136,0.04136,0.727811,0.626959,0.626959,0.6);
renderTeapot(-0.5,-0.5,-5.0,0.24725,0.1995,0.0745,
0.75164,0.60648,0.22648,0.628281,0.555802,0.366065,0.4);
renderTeapot(0.2,-0.5,-5.5,0.19225,0.19225,0.19225,
0.50754,0.50754,0.50754,0.508273,0.508273,0.508273,0.4);
renderTeapot(1.0,-0.5,-6.0,0.0215,0.1745,0.0215,
0.07568,0.61424,0.07568,0.633,0.727811,0.633,0.6);
renderTeapot(1.8,-0.5,-6.5,0.0,0.1,0.06,0.0,0.50980392,
0.50980392,0.50196078,0.50196078,0.50196078,0.25);
glAccum(GL_ACCUM,0.125);
glFlush();
auxSwapBuffers();
}
glAccum(GL_RETURN,1.0);
glFlush();
auxSwapBuffers();
}
void
acfilter(int width, int height)
{
glClear(GL_COLOR_BUFFER_BIT | GL_ACCUM_BUFFER_BIT);
glMatrixMode(GL_TEXTURE);
if (pause) {
draw_rect(width, height);
stop();
glClear(GL_COLOR_BUFFER_BIT);
}
draw_rect(width / 2, height / 2);
stop();
glAccum(GL_ACCUM, 0.25);
glTranslatef(1.0 / width, 0, 0);
draw_rect(width / 2, height / 2);
stop();
glAccum(GL_ACCUM, 0.25);
glLoadIdentity();
glTranslatef(0, 1.0 / height, 0);
draw_rect(width / 2, height / 2);
stop();
glAccum(GL_ACCUM, 0.25);
glLoadIdentity();
glTranslatef(1.0 / width, 1.0 / height, 0);
draw_rect(width / 2, height / 2);
stop();
glAccum(GL_ACCUM, 0.25);
glAccum(GL_RETURN, 1.0);
glMatrixMode(GL_MODELVIEW);
}
void MotionBlurDrawCallback::operator()(osgProducer::OsgSceneHandler &handler, Producer::Camera &camera)
{
double t = handler.getSceneView()->getFrameStamp()->getReferenceTime();
if (!cleared_)
{
// clear the accumulation buffer
glClearColor(0, 0, 0, 0);
glClear(GL_ACCUM_BUFFER_BIT);
cleared_ = true;
t0_ = t;
}
double dt = fabs(t - t0_);
t0_ = t;
// call the scene handler's draw function
handler.drawImplementation(camera);
// compute the blur factor
double s = powf(0.2, dt / globalData.odeConfig.motionPersistence);
// scale, accumulate and return
glAccum(GL_MULT, s);
glAccum(GL_ACCUM, 1 - s);
glAccum(GL_RETURN, 1.0f);
}
static void Draw(void)
{
glPushMatrix();
glScalef(0.8, 0.8, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glCallList(thing1);
glAccum(GL_LOAD, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
glCallList(thing2);
glAccum(GL_ACCUM, 0.5);
glAccum(GL_RETURN, 1.0);
glPopMatrix();
if (doubleBuffer) {
glutSwapBuffers();
}
else {
glFlush();
}
}
void GraphicsSubsystem::accumFrame(int cur, int n)
{
if(cur == 0)
glAccum(GL_LOAD, 1.0f / n);
else
glAccum(GL_ACCUM, 1.0f / n);
}
void draw(int vertex_count) {
// Copy the previous frame's buffer back in
glAccum(GL_RETURN, 1);
renderer_once::draw(vertex_count);
// Store the screen contents back to the buffer
glAccum(GL_LOAD, 1);
}
void Interface::Display (void)
{
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
switch (_this->status) {
case 5:
glRotatef(_this->randomA, 0, 1, 0);
glRotatef(_this->randomB, 1, 0, 0);
glRotatef(_this->randomC, 0, 0, 1);
break;
}
if(_this->blurActive) { //para efeito Blur
for(int i = 0; i < _this->blurFrames; i++) {//para efeito Blur
if(_this->blurFirstFrame) {//para efeito Blur
glAccum(GL_LOAD, 5);//para efeito Blur
_this->blurFirstFrame = false;//para efeito Blur
}
glPushMatrix();
glRotatef( 45, 0, 1, 0);
_this->magicCube->draws ();
glPopMatrix();
glAccum(GL_MULT, _this->blurQ);//para efeito Blur
glAccum(GL_ACCUM, 1-_this->blurQ);//para efeito Blur
}
glAccum(GL_RETURN, 1.0);//para efeito Blur
}
glPushMatrix();
_this->info();//Monstra texto
glPopMatrix();
glutSwapBuffers();
}
void displayAccum(int accsize)
{
int i;
glClear(GL_ACCUM_BUFFER_BIT);
loaddxdy(accsize);
for (i = 0; i < accsize; i++) {
#ifdef DEBUG
printf("Pass %d\n", i);
#endif
glPushMatrix();
glTranslatef(dx[i], dy[i], 0.0);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
/* draw the scene */
zeichne_geometrie();
glPopMatrix();
glAccum(GL_ACCUM, 1.0/accsize);
}
#ifdef DEBUG
printf("final job\n");
#endif
glAccum(GL_RETURN, 1.0); /* return accum. picture to screen */
glFlush();
}
void
my_display(void)
{
#ifdef ANTIALIASING
int passes = 8;
int i;
#endif
#ifdef BLACK_LETTERS_WHITE_BACKGROUND
glClearColor(1.0, 1.0, 1.0, 0.0);
#else
glClearColor(0.0, 0.0, 0.0, 0.0);
#endif
#ifdef ANTIALIASING
glClear(GL_ACCUM_BUFFER_BIT);
for (i=0; i<passes; i++) {
glClear(GL_COLOR_BUFFER_BIT);
do_ortho(GL_TRUE, j8[i].x, j8[i].y);
draw_logo(scale);
glAccum(GL_ACCUM, 1.0/(GLfloat)passes);
}
glAccum(GL_RETURN, 1.0);
glFlush();
#else
glClear(GL_COLOR_BUFFER_BIT);
do_ortho(GL_FALSE, 0.0, 0.0);
draw_logo(scale);
#endif
glutSwapBuffers();
}
void display(void)
{
GLint viewport[4];
int jitter;
glGetIntegerv (GL_VIEWPORT, viewport);
glClear(GL_ACCUM_BUFFER_BIT);
for (jitter = 0; jitter < ACSIZE; jitter++) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix ();
/* Note that 4.5 is the distance in world space between
* left and right and bottom and top.
* This formula converts fractional pixel movement to
* world coordinates.
*/
glTranslatef (j8[jitter].x*4.5/viewport[2],
j8[jitter].y*4.5/viewport[3], 0.0);
displayObjects ();
glPopMatrix ();
glAccum(GL_ACCUM, 1.0/ACSIZE);
}
glAccum (GL_RETURN, 1.0);
glFlush();
}
// redraw the window
void display(void)
{
mgr->getNavigator()->updateCameraTransformation();
mgr->getWindow()->activate();
mgr->getWindow()->frameInit();
raction->setWindow(getCPtr(mgr->getWindow()));
ViewportPtr viewport = mgr->getWindow()->getPort(0);
glClear(GL_ACCUM_BUFFER_BIT);
for (int i=0; i < JITTERSIZE[activeJitter]; i++) {
beginEditCP(cameraDecorator);
cameraDecorator->setOffset(
(JITTER[activeJitter][i].x() - 0.5) * jitterRadius,
(JITTER[activeJitter][i].y() - 0.5) * jitterRadius);
endEditCP(cameraDecorator);
viewport->render(raction);
glAccum(GL_ACCUM, 1.0f / float(JITTERSIZE[activeJitter]));
glAccum(GL_RETURN, float(JITTERSIZE[activeJitter]) / float(i + 1));
}
glAccum(GL_RETURN, 1.0f);
mgr->getWindow()->swap();
mgr->getWindow()->frameExit();
}
void render_efxMotionBlurAccum () {
local = (efxMotionBlurAccum_section *) mySection->vars;
glAccum(GL_MULT, local->decay);
glAccum(GL_ACCUM, 1 - local->decay);
glAccum(GL_RETURN, 1);
}
void display(){
float xRotTrad = (rotateX/180 * 3.141592654f);
float yRotTrad = (rotateY/180 * 3.141592654f);
if (moveForward) {
cameraX -= float(sinf(yRotTrad));
cameraY += float(sinf(xRotTrad));
cameraZ += float(cosf(yRotTrad));
}
if (moveBack) {
cameraX += float(sinf(yRotTrad));
cameraY -= float(sinf(xRotTrad));
cameraZ -= float(cosf(yRotTrad));
}
if (moveLeft) {
cameraX += float(cosf(yRotTrad));
cameraZ += float(sinf(yRotTrad));
}
if (moveRight) {
cameraX -= float(cosf(yRotTrad));
cameraZ -= float(sinf(yRotTrad));
}
// writeText();
glLoadIdentity();
initLight();
glRotatef(rotateX, 1, 0, 0);
glRotatef(rotateY, 0, 1, 0);
//chase camera?
glTranslatef(cameraX, 0, cameraZ);
glClearColor(0, 0, 0, 1);
glPushMatrix();
boidsList->renderBoids();
glPopMatrix();
//draw boundary cube
if(showCube){
glColor3f(1, 1, 1);
glutWireCube(boidsList->getBounds()*2);
}
//accumulation buffer, for fake motion blur
if(pos == 0)
glAccum(GL_LOAD, 1.0 / n);
else
glAccum(GL_ACCUM, 1.0 / n);
pos++;
if(pos >= n) {
pos = 0;
glAccum(GL_RETURN, 1.0);
glutSwapBuffers();
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
}
}
void display(void) {
if (rptr==wptr) {
glutSwapBuffers();
glutPostRedisplay();
return;
}
glDrawBuffer(GL_BACK);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
int n;
double x, y;
glBegin(GL_LINES);
glColor4f(0,1,0,0.7);
glVertex2f(last_x, last_y);
n = 0;
again:
while (rptr != wptr) {
x = biquad_filt(&lpf_x, ringbuf[rptr*4] / 32768.0);
y = biquad_filt(&lpf_y, ringbuf[rptr*4+1] / 32768.0);
if (!fullbright)
glColor4f(0, ringbuf[rptr*4+2]/32768.0, 0,0.7);
rptr++;
if (rptr>=RING_SIZE) {
rptr = 0;
fprintf(stderr, "r");
}
glVertex2f(x, y);
glVertex2f(x, y);
n++;
}
if (n < 1000) {
glutSwapBuffers();
goto again;
}
glVertex2f(x, y);
last_x = x; last_y = y;
glEnd();
#define SKIP_ACCUM // accumulation buffer gives nice smooth decay effect, but is slow as tar on most machines
#ifndef SKIP_ACCUM
glAccum(GL_MULT, 0.7);
glAccum(GL_ACCUM, 1.0);
glDrawBuffer(GL_FRONT);
glAccum(GL_RETURN, 1.0);
glFlush();
#else
//glDrawBuffer(GL_BACK);
glutSwapBuffers();
#endif
glutPostRedisplay();
}
void aa_display(float *ep, float *vp) {
int view_pass;
glClear(GL_ACCUM_BUFFER_BIT);
for( view_pass=0; view_pass<VPASSES; view_pass++ ){
view_volume(ep, vp, 1);
draw_array();
glAccum(GL_ACCUM,1.0/(float)(VPASSES));
}
glAccum(GL_RETURN,1.0);
glutSwapBuffers();
}
void go()
{
int view_pass;
glClear(GL_ACCUM_BUFFER_BIT);
for(view_pass=0;view_pass<VPASSES;view_pass++){
jitter_view();
draw_stuff();
glFlush();
glAccum(GL_ACCUM,1.0/(float)(VPASSES));
}
glAccum(GL_RETURN,1.0);
}
void tui::LayoutCanvas::OnpaintGL(wxPaintEvent& event) {
wxPaintDC dc(this);
#ifndef __WXMOTIF__
if (!GetContext()) return;
#endif
SetCurrent();
// invalid_window indicates zooming.
// event.GetEventType() == event.GetId() should means that database is updated
// In both cases - the entire window is redrawn
if ((invalid_window) || (event.GetEventType() == event.GetId()))
{
glMatrixMode( GL_MODELVIEW );
glShadeModel( GL_FLAT ); // Single color
update_viewport();
//@TODO !! Check somewhere that RGBA mode is available!?
// CTM matrix stuff
glLoadIdentity();
glOrtho(lp_BL.x(),lp_TR.x(),lp_TR.y(),lp_BL.y(),-1.0,1.0);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClear(GL_ACCUM_BUFFER_BIT);
DATC->openGL_draw(_LayCTM); // draw data
glAccum(GL_LOAD, 1.0);
invalid_window = false;
if (rubber_band) rubber_paint();
}
else
{
glAccum(GL_RETURN, 1.0);
if (tmp_wnd) wnd_paint();
else if (rubber_band) rubber_paint();
}
// deal with the long cursor
if (reperX || reperY)
{
glColor4f(1, 1, 1, .5);
glBegin(GL_LINES);
if (reperX)
{
glVertex2i(lp_BL.x(), ScrMARK.y()) ;
glVertex2i(lp_TR.x(), ScrMARK.y());
}
if (reperY)
{
glVertex2i(ScrMARK.x() , lp_BL.y()) ;
glVertex2i(ScrMARK.x() , lp_TR.y());
}
glEnd();
}
SwapBuffers();
}
void
balance(void)
{
if (reset) {
memset(null, luma, width * height * sizeof *null);
reset = 0;
}
glDrawPixels(width, height, format, GL_UNSIGNED_BYTE, image);
glAccum(GL_LOAD, alpha / 2.);
glDrawPixels(width, height, format, GL_UNSIGNED_BYTE, null);
glAccum(GL_ACCUM, (1 - alpha) / 2.);
glAccum(GL_RETURN, 2.0);
}
void Camera::renderingInstructions(VisualizationParameterSet& visParams)
{
// set some values
graphicsManager->getShaderUsage(visParams);
// prepare shadow maps
while(graphicsManager->prepareLightForShadowMapping(visParams))
rootNode->quickDraw();
// prepare cube map
graphicsManager->getShaderUsage(visParams);
renderCubeMap(visParams);
// prepare rendering
glClearColor(clearColor[0], clearColor[1], clearColor[2], clearColor[3]);
graphicsManager->prepareRendering(visParams, resolutionX, resolutionY,
aspect, Functions::toDeg(angleY), minRange, maxRange, fbo_reg);
// get motion blur values and clear view
graphicsManager->setUpMotionBlurSettings(visParams);
// do the motion blur render passes (if motion blur is off -> 1 pass)
for(; visParams.mb_currentPass <= visParams.mb_renderPasses; visParams.mb_currentPass++)
{
// set the view
graphicsManager->setPerspective();
setCamera(visParams);
glClear(default_clear);
// update light positions
graphicsManager->updateLights(true, visParams.renderPasses == 2, visParams.provideUniforms);
// prepare surface properties
graphicsManager->renderEnvironment(maxRange);
glCallList(graphicsManager->enableStateDL[visParams.surfaceStyle]);
// render
rootNode->draw(visParams);
if(visParams.renderPasses == 2)
{
graphicsManager->updateLights(true, false, visParams.provideUniforms);
rootNode->draw(visParams);
}
// undo surface properties
glCallList(graphicsManager->disableStateDL[visParams.surfaceStyle]);
graphicsManager->revertLightTextureUnits(visParams.provideUniforms);
// load to accumulation buffer, blend with accumulation buffer or just do nothing (default)
if(visParams.mb_useAccum && visParams.mb_currentPass == 1)
glAccum(GL_LOAD, 1.0f/visParams.mb_renderPasses);
else if(visParams.mb_useAccum)
glAccum(GL_ACCUM, 1.0f/visParams.mb_renderPasses);
// render post production and swap render targets if multi pass rendering with fbo usage
graphicsManager->finishRendering(visParams, false);
}
// write back result if accum was used
if(visParams.mb_useAccum)
glAccum(GL_RETURN, 1.0f);
glFlush();
}
void tui::LayoutCanvas::OnpaintGL(wxPaintEvent& event) {
#ifndef __WXMOTIF__
if (!GetContext()) return;
#endif
// invalid_window indicates zooming or refreshing after a tell operation.
if (invalid_window)
{
wxPaintDC dc(this);
SetCurrent();
glMatrixMode( GL_MODELVIEW );
glShadeModel( GL_FLAT ); // Single color
update_viewport();
// CTM matrix stuff
glLoadIdentity();
glOrtho(lp_BL.x(),lp_TR.x(),lp_TR.y(),lp_BL.y(),-1.0,1.0);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClear(GL_ACCUM_BUFFER_BIT);
DATC->openGL_draw(_LayCTM); // draw data
glAccum(GL_LOAD, 1.0);
invalid_window = false;
if (rubber_band) rubber_paint();
}
else
{
glAccum(GL_RETURN, 1.0);
if (tmp_wnd) wnd_paint();
else if (rubber_band) rubber_paint();
}
// deal with the long cursor
if (reperX || reperY)
{
glColor4f(1, 1, 1, .5);
glBegin(GL_LINES);
if (reperX)
{
glVertex2i(lp_BL.x(), ScrMARK.y()) ;
glVertex2i(lp_TR.x(), ScrMARK.y());
}
if (reperY)
{
glVertex2i(ScrMARK.x() , lp_BL.y()) ;
glVertex2i(ScrMARK.x() , lp_TR.y());
}
glEnd();
}
SwapBuffers();
}
void draw() {
int current_time = glutGet(GLUT_ELAPSED_TIME);
//cout << "fps: " << 1000.0 / (current_time - last_render_time) << endl;
last_render_time = current_time;
game->draw();
if(ALLOW_BLUR) {
glAccum(GL_MULT, blur_factor);
glAccum(GL_ACCUM, 1.0-blur_factor);
glAccum(GL_RETURN, 1.0);
}
glutSwapBuffers();
//glutPostRedisplay();
//glFlush();
}
void acc_convolve(void)
{
int x, y;
for (y = 0; y < kern->h; y++) {
for (x = 0; x < kern->w; x++) {
glRasterPos2i(0, 0);
glBitmap(0, 0, 0, 0, -x, -y, 0);
glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, img);
glAccum(GL_ACCUM, kern->kern[y*kern->w + x]*kernScale);
}
}
glAccum(GL_RETURN, 1./kernScale);
}
void Projector::_show_buffer (char* output)
{ //effects using accumulation buffer
//reverse colors
if (reverse_colors) {
glAccum(GL_MULT, -1.0f);
glAccum(GL_ADD, 1.0f);
}
//increase contrast & invert colors
if (high_contrast) {
glAccum(GL_ADD, -0.25f);
glAccum(GL_RETURN, 2.0f);
glAccum(GL_ADD, 0.25f);
} else {
glAccum(GL_RETURN, 1.0f);
}
//draw image as soon as possible
#ifdef CAPTURE
if (output) _capture_little(output);
#endif
finish_buffer();
//restore colors
if (reverse_colors) {
glAccum(GL_MULT, -1.0f);
glAccum(GL_ADD, 1.0f);
}
}
void reshape(int w, int h)
{
float asp = float(w) / float(h); // aspect ratio (종횡비)
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
width = w;
height = h;
gluPerspective(45, asp, 0.1, 100);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glAccum(GL_ACCUM, 1.0);
glAccum(GL_RETURN, 1.0);
glutPostRedisplay();
}
void View::display_antialiased()
{
glClear(GL_ACCUM_BUFFER_BIT);
for (int i = 0; i < 16; i++)
{
jitter_x = jitter16[i][0];
jitter_y = jitter16[i][1];
set_ortho_projection();
clear_background();
on_display();
glAccum(GL_ACCUM, 1.0 / 16);
}
glAccum(GL_RETURN, 1.0);
jitter_x = jitter_y = 0.0;
}
void tui::LayoutCanvas::wnd_paint() {
glAccum(GL_RETURN, 1.0);
glColor4f(0.7, 0.7, 0.7, 0.4); // gray
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glRecti(presspoint.x(),presspoint.y(), n_ScrMARKold.x(), n_ScrMARKold.y());
glRecti(presspoint.x(),presspoint.y(), n_ScrMARK.x(), n_ScrMARK.y());
}
void tui::LayoutCanvas::OnpaintGL(wxPaintEvent&) {
wxPaintDC dc(this);
#ifndef __WXMOTIF__
if (!GetContext()) return;
#endif
SetCurrent();
update_viewport();
//@TODO !! Check somewhere that RGBA mode is available!?
// CTM matrix stuff
glLoadIdentity();
glOrtho(lp_BL.x(),lp_TR.x(),lp_TR.y(),lp_BL.y(),-1.0,1.0);
if (invalid_window || !(tmp_wnd || rubber_band)) {
// invalid_window indicates zooming. If that is false and the rest two
// variables are not set, means that the system request repaint
// In both cases - the entire window is redrawn
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClear(GL_ACCUM_BUFFER_BIT);
Properties->drawGrid();
DATC->openGL_draw(Properties->drawprop()); // draw data
glAccum(GL_LOAD, 1.0);
if (rubber_band) rubber_paint();
invalid_window = false;
}
else if (tmp_wnd)
// zooming using the mouse
wnd_paint();
else if (n_ScrMARKold != n_ScrMARK)
// the only reason to get to this point remains rubber_band == true
// so the paint will be invoked only if we have something new to show on
//the screen
rubber_paint();
SwapBuffers();
}
void go() {
if(lookAround) {
drawStuff();
return;
}
float xt;
glClear(GL_ACCUM_BUFFER_BIT);
for(xt = (float)-EYEDX; xt < EYEDX; xt += EYEDX / 10.0){
vv(xt);
drawStuff();
glAccum(GL_ACCUM,0.05);
}
glAccum(GL_RETURN,1.0);
glFlush();
}
