Exemplo n.º 1
0
///////////////////////////////////////////////////////////
// Render the torus and sphere
void DrawObjects(void)
	{
	// Save the matrix state and do the rotations
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();

	// Translate the whole scene out and into view	
	glTranslatef(-0.75f, 0.0f, -2.5f);	

	// Initialize the names stack
	glInitNames();
	glPushName(0);

	// Set material color, Yellow
	// torus
	glColor3f(1.0f, 1.0f, 0.0f);
	glLoadName(TORUS);
	glPassThrough((GLfloat)TORUS);
	DrawTorus(40, 20);


	// Draw Sphere
	glColor3f(0.5f, 0.0f, 0.0f);
	glTranslatef(1.5f, 0.0f, 0.0f);
	glLoadName(SPHERE);
	glPassThrough((GLfloat)SPHERE);	
	DrawSphere(0.5f);

	// Restore the matrix state
	glPopMatrix();	// Modelview matrix
	}
Exemplo n.º 2
0
///////////////////////////////////////////////////////////
// Render the torus and sphere
void DrawObjects(void)
{
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();

  glTranslatef(-0.75f, 0.0f, -2.5f);	

  //初始化名称栈 
  glInitNames();
  glPushName(0);

  //圆环
  glColor3f(1.0f, 1.0f, 0.0f);
  //圆环的名称
  glLoadName(TORUS);
  //设置一个自定义的过渡标记,与圆环的名称相同,以便后面的解析判断
  glPassThrough((GLfloat)TORUS);
  DrawTorus(40, 20);


  //球体
  glColor3f(0.5f, 0.0f, 0.0f);
  glTranslatef(1.5f, 0.0f, 0.0f);
  //球体的名称
  glLoadName(SPHERE);
  //球体的过渡标记
  glPassThrough((GLfloat)SPHERE);	
  DrawSphere(0.5f);

  glPopMatrix();	
}
Exemplo n.º 3
0
// Render the cube and sphere
void DrawObjects(void)
	{
	// Save the matrix state and do the rotations
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();

	// Translate the whole scene out and into view	
	glTranslatef(-80.0f, 0.0f, -300.0f);	

	// Initialize the names stack
	glInitNames();
	glPushName(0);

	// Set material color, Yellow
	// Cube
	glRGB(255, 255, 0);
	glLoadName(CUBE);
	glPassThrough((GLfloat)CUBE);
	glutSolidCube(75.0f);


	// Draw Sphere
	glRGB(128,0,0);
	glTranslatef(130.0f, 0.0f, 0.0f);
	glLoadName(SPHERE);
	glPassThrough((GLfloat)SPHERE);	
	glutSolidSphere(50.0f, 15, 15);

	// Restore the matrix state
	glPopMatrix();	// Modelview matrix
	}
void CPhysEnv::GetNearestPoint(int x, int y)
{
/// Local Variables ///////////////////////////////////////////////////////////
	float *feedBuffer;
	int hitCount;
	tParticle *tempParticle;
	int loop;
///////////////////////////////////////////////////////////////////////////////
	// INITIALIZE A PLACE TO PUT ALL THE FEEDBACK INFO (3 DATA, 1 TAG, 2 TOKENS)
	feedBuffer = (float *)malloc(sizeof(GLfloat) * m_ParticleCnt * 6);
	// TELL OPENGL ABOUT THE BUFFER
	glFeedbackBuffer(m_ParticleCnt * 6,GL_3D,feedBuffer);
	(void)glRenderMode(GL_FEEDBACK);	// SET IT IN FEEDBACK MODE

	tempParticle = m_CurrentSys;
	for (loop = 0; loop < m_ParticleCnt; loop++)
	{
		// PASS THROUGH A MARKET LETTING ME KNOW WHAT VERTEX IT WAS
		glPassThrough((float)loop);
		// SEND THE VERTEX
		glBegin(GL_POINTS);
		glVertex3fv((float *)&tempParticle->pos);
		glEnd();
		tempParticle++;
	}
	hitCount = glRenderMode(GL_RENDER); // HOW MANY HITS DID I GET
	//fout<<"hit count "<<hitCount<,endl;

	CompareBuffer(hitCount,feedBuffer,(float)x,(float)y);		// CHECK THE HIT 
	free(feedBuffer);		// GET RID OF THE MEMORY
}
Exemplo n.º 5
0
/* Draw a few lines and two points, one of which will 
 * be clipped.  If in feedback mode, a passthrough token 
 * is issued between the each primitive.
 */
void drawGeometryFeedback(GLenum mode) {
	glBegin(GL_LINE_STRIP);
	glNormal3f(0.0, 0.0, 1.0);
	glVertex3f(30.0, 30.0, 0.0);
	glVertex3f(50.0, 60.0, 0.0);
	glVertex3f(70.0, 40.0, 0.0);
	glEnd();
	if (mode == GL_FEEDBACK)
		glPassThrough(1.0);
	glBegin(GL_POINTS);
	glVertex3f(-100.0, -100.0, -100.0); /*  will be clipped  */
	glEnd();
	if (mode == GL_FEEDBACK)
		glPassThrough(2.0);
	glBegin(GL_POINTS);
	glNormal3f(0.0, 0.0, 1.0);
	glVertex3f(50.0, 50.0, 0.0);
	glEnd();
}
Exemplo n.º 6
0
void DrawObjects(void)
{

  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();

  if (gridFlag == 1){drawGrid();}
  glTranslatef(0.0f, 0.0f, -120.5f);

  glInitNames();
  glPushName(0);











  if (scene.size() != 0)
    {
      for (int i = 0; i < scene.size(); ++i)
	{

	  glColor3f((GLfloat)(rand() % 1000) * 0.001,(GLfloat)(rand() % 1000) * 0.001,(GLfloat)(rand() % 1000) * 0.001);
	  printf("%f\n", (GLfloat)(rand() % 1000) * 0.001);

	  glLoadName(i + 1);
	  glPassThrough((GLfloat)i + 1);
	  glPushMatrix();
	  scene[i]->paintMyself();
	  glPopMatrix();
	}
    }
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
}
Exemplo n.º 7
0
void GlNode::draw(float lod,GlGraphInputData* data,Camera*) {
  const Color& colorSelect2=data->parameters->getSelectionColor();

  glEnable(GL_CULL_FACE);

  node n=node(id);

  if (data->getElementSelected()->getNodeValue(n)) {
    glDisable(GL_DEPTH_TEST);

    if(data->getGraph()->isMetaNode(n)) {
      glStencilFunc(GL_LEQUAL,data->parameters->getSelectedMetaNodesStencil(),0xFFFF);
    }
    else {
      glStencilFunc(GL_LEQUAL,data->parameters->getSelectedNodesStencil(),0xFFFF);
    }
  }
  else {
    glEnable(GL_DEPTH_TEST);

    if(data->getGraph()->isMetaNode(n)) {
      glStencilFunc(GL_LEQUAL,data->parameters->getMetaNodesStencil(),0xFFFF);
    }
    else {
      glStencilFunc(GL_LEQUAL,data->parameters->getNodesStencil(),0xFFFF);
    }
  }

  const Coord &nodeCoord = data->getElementLayout()->getNodeValue(n);

  const Size &nodeSize = data->getElementSize()->getNodeValue(n);

  const Color& fillColor = data->getElementColor()->getNodeValue(n);

  const Color& strokeColor = data->getElementBorderColor()->getNodeValue(n);

  const Color& textColor = data->getElementLabelColor()->getNodeValue(n);

  GlTextureManager::getInst().setAnimationFrame(data->getElementAnimationFrame()->getNodeValue(n));

  if(data->parameters->getFeedbackRender()) {
    glPassThrough(TLP_FB_COLOR_INFO);
    glPassThrough(fillColor[0]);
    glPassThrough(fillColor[1]);
    glPassThrough(fillColor[2]);
    glPassThrough(fillColor[3]);
    glPassThrough(strokeColor[0]);
    glPassThrough(strokeColor[1]);
    glPassThrough(strokeColor[2]);
    glPassThrough(strokeColor[3]);
    glPassThrough(textColor[0]);
    glPassThrough(textColor[1]);
    glPassThrough(textColor[2]);
    glPassThrough(textColor[3]);

    glPassThrough(TLP_FB_BEGIN_NODE);
    glPassThrough(static_cast<float>(id)); //id of the node for the feed back mode
  }

  bool selected = data->getElementSelected()->getNodeValue(n);

  if (lod < data->parameters->getPointModeLOD()) { //less than four pixel on screen, we use points instead of glyphs
    if (lod < 1) lod = 1;

    int size= static_cast<int>(sqrt(lod));

    if(data->getGlVertexArrayManager()->renderingIsBegin()) {
      if(size<2)
        data->getGlVertexArrayManager()->activatePointNodeDisplay(this,true,selected);
      else
        data->getGlVertexArrayManager()->activatePointNodeDisplay(this,false,selected);
    }
    else {
      if(size>2)
        size=2;

      const Color& color = selected ? colorSelect2 : fillColor;

      OpenGlConfigManager::getInst().activateLineAndPointAntiAliasing();
      glDisable(GL_LIGHTING);
      setColor(color);
      glPointSize(static_cast<float>(size));
      glBegin(GL_POINTS);
      glVertex3f(nodeCoord[0], nodeCoord[1], nodeCoord[2]+nodeSize[2]/2.f);
      glEnd();
      glEnable(GL_LIGHTING);
      OpenGlConfigManager::getInst().desactivateLineAndPointAntiAliasing();
    }

    return;

  }

  //draw a glyph or make recursive call for meta nodes
  glPushMatrix();
  glTranslatef(nodeCoord[0], nodeCoord[1], nodeCoord[2]);
  glRotatef(static_cast<float>(data->getElementRotation()->getNodeValue(n)), 0.f, 0.f, 1.f);

  // If node size in z is equal to 0 we have to scale with FLT_EPSILON to preserve normal
  // (because if we do a scale of (x,y,0) and if we have a normal like (0,0,1) the new normal after scale will be (0,0,0) and we will have light problem)
  if(nodeSize[2]==0)
    glScalef(nodeSize[0], nodeSize[1],FLT_EPSILON);
  else
    glScalef(nodeSize[0], nodeSize[1],nodeSize[2]);

  data->glyphs.get(data->getElementShape()->getNodeValue(n))->draw(n,lod);

  if (selected) {
    OpenGlConfigManager::getInst().activateLineAndPointAntiAliasing();
    selectionBox->setStencil(data->parameters->getSelectedNodesStencil()-1);
    selectionBox->setOutlineColor(colorSelect2);
    selectionBox->draw(10,NULL);
    OpenGlConfigManager::getInst().desactivateLineAndPointAntiAliasing();
  }

  glPopMatrix();

  if (selected) {
    glStencilFunc(GL_LEQUAL,data->parameters->getNodesStencil(),0xFFFF);
  }

  GlTextureManager::getInst().setAnimationFrame(0);

  if(data->parameters->getFeedbackRender()) {
    glPassThrough(TLP_FB_END_NODE);
  }
}
Exemplo n.º 8
0
M(void, glPassThrough, jfloat token) {
	glPassThrough(token);
}
Exemplo n.º 9
0
/////////////////////////////////////////////////////////
// Render
//
void GEMglPassThrough :: render(GemState *state) {
    glPassThrough (token);
}
Exemplo n.º 10
0
Arquivo: g_render.c Projeto: aosm/X11
void __glXDisp_PassThrough(GLbyte *pc)
{
	glPassThrough( 
		*(GLfloat  *)(pc + 0)
	);
}
Exemplo n.º 11
0
/* draw a model in feedback mode and return the list of visible vertices */
void
DrawModelFeedbackMode( Model *model, int width, int height, 
                       Viewer3dParam *par, vector<int> &vertexIndices )
{

    glEnable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);
    glRenderMode (GL_RENDER);
    GlClearWindow(1);
    
    Setup3d( par );
    DrawModel( model, 0);

    GLfloat *pixels = (GLfloat*)malloc(3*width*height*sizeof(GLfloat));
    glReadPixels(0,0,width, height, GL_DEPTH_COMPONENT,GL_FLOAT,(void*)pixels);

    // no texture
    int ii;
    
    // init feedback mode
    int BUFSIZE_FEEDBACK = 6 * ( model->NVertices() + 1 );
    GLfloat *feedbackBuffer = (GLfloat *)malloc(BUFSIZE_FEEDBACK*sizeof(GLfloat));
    if ( feedbackBuffer == NULL ) {
        dbg(DBG_INFO, "Failed to init feedback data!\n");
    }
    glFeedbackBuffer(BUFSIZE_FEEDBACK,GL_3D,feedbackBuffer);
    
    // set mode to feedback
    glRenderMode(GL_FEEDBACK);

    Setup3d( par );
    
    for (ii=0;ii<model->NVertices();ii++) {
        Vec3f vx = model->GetVertex(ii).v();
        
        // pass index in feedback mode
        glPassThrough(ii);

        glBegin(GL_POINTS);
        glVertex3f( vx[0], vx[1], vx[2] );
        glEnd();
    }

    // retrieve feedback
    GLuint hits = glRenderMode( GL_RENDER );

    // parse hits
    if ( (int)hits != -1 ) {
        GLfloat *ptr = (GLfloat*)feedbackBuffer;
        GLfloat x,y,z;
        GLint code,id;
        int counter =0;

        for (ii=0;ii<(int)hits;ii++) {

            code = (int)*ptr;
            
            if ( code == GL_PASS_THROUGH_TOKEN ) {
                id = (int)*(ptr+1);
                ptr+=2;
                ii+=1;
                continue;
            }

            if ( code == GL_POINT_TOKEN ) {
                x = *(ptr+1);
                y = *(ptr+2);
                z = *(ptr+3);
                int xx = x - floor(x) > 0.5 ? int(floor(x))+1 : int(floor(x));
                int yy = y - floor(y) > 0.5 ? int(floor(y))+1 : int(floor(y));
                
                if ( xx < width - 1 && xx > 1 && \
                     yy < height - 1 && yy > 1 ) {
         
                    float thresh = MAX( MAX( MAX( pixels[yy*width+xx], 
                                                  pixels[(yy-1)*width+xx]), 
                                             pixels[yy*width+xx-1] ), 
                                        pixels[(yy-1)*width+xx-1] );

                    if ( z <= thresh + 1E-5 ) {
                        vertexIndices.push_back( id );
                        counter++;
                    }
                }

                ptr += 4;
                ii += 3;
                continue;
            }
        }

        dbg(DBG_INFO,"%d visible points (%d model points)\n", counter, model->NVertices());
    }    

    // free memory

    delete ( feedbackBuffer );
    delete ( pixels );

}