void BasicLocator::draw( M3dView & view, const MDagPath & path,
M3dView::DisplayStyle style, M3dView::DisplayStatus status )
{ 
view.beginGL(); 
glPushAttrib( GL_CURRENT_BIT );

MPointArray pts;
getCirclePoints( pts );

glBegin(GL_LINE_STRIP);
for( unsigned int i=0; i < pts.length(); i++ )
	glVertex3f( float(pts[i].x), float(pts[i].y), float(pts[i].z) );
glEnd();

glBegin(GL_LINES);
	glVertex3f( -0.5f, 0.0f, 0.0f );
	glVertex3f( 0.5f, 0.0f, 0.0f );

	glVertex3f( 0.0f, 0.0f, -0.5f );
	glVertex3f( 0.0f, 0.0f, 0.5f );
glEnd();

glPopAttrib();
view.endGL();       
}
Exemplo n.º 2
0
void kgLocator::draw( M3dView & view, const MDagPath & path, 
					 M3dView::DisplayStyle style, M3dView::DisplayStatus status )
{
	MStatus stat;

	//First get the value of the height attribute
	//of the assocuated locator
	MObject thisNode = thisMObject();
	MFnDagNode dagFn( thisNode  );  	
	MPlug heightPlug = dagFn.findPlug( height, &stat );
	float heightValue;
	heightPlug.getValue( heightValue );
		
	view.beginGL();
	glPushAttrib( GL_CURRENT_BIT );
	
	
	glBegin( GL_LINES );
	//Draw a cross
	for(unsigned int i=0; i < pts.length(); i+= 2 )
	{
		glVertex3f(pts[i].x, pts[i].y, pts[i].z );
		glVertex3f(pts[i+1].x, pts[i+1].y, pts[i+1].z );
	}
	//And a vertical spindle
	//of the same height as 
	//the height attribute
	glVertex3f( 0.0f, 0.0f, 0.0f );
	glVertex3f( 0.0f, heightValue, 0.0f );
	
	glEnd();
	
	glPopAttrib();
	view.endGL();
}
Exemplo n.º 3
0
void mtmEnvLight::draw( M3dView & view, const MDagPath & /*path*/, 
							 M3dView::DisplayStyle style,
							 M3dView::DisplayStatus status )
{ 
	// Get the size
	//
	//MObject thisNode = thisMObject();
	//MPlug plug( thisNode, size );
	//MDistance sizeVal;
	//plug.getValue( sizeVal );

	//float multiplier = (float) sizeVal.asCentimeters();

	view.beginGL(); 
	float size2 = 0.7f * .5f;
	float scale = 2.0f;

	if ( ( style == M3dView::kFlatShaded ) || 
		 ( style == M3dView::kGouraudShaded ) ) 
	{  
		// Push the color settings
		// 
		glPushAttrib( GL_CURRENT_BIT );

		if ( status == M3dView::kActive ) {
			view.setDrawColor( 13, M3dView::kActiveColors );
		} else {
			view.setDrawColor( 13, M3dView::kDormantColors );
		}  

		glBegin( GL_TRIANGLE_FAN );
	        int i;
			int last = mtmCount - 1;
			for ( i = 0; i < last; ++i ) {
				glVertex3f( (mtm[i][0] - size2) * scale,
							(mtm[i][1]) * scale,
							(mtm[i][2] - .15f) * scale );
			} 
		glEnd();
		glPopAttrib();
	}

	// Draw the outline of the foot
	//
	glBegin( GL_LINES );
	    int i;
	    int last = mtmCount - 1;
	    for ( i = 0; i < last; ++i ) { 
				glVertex3f( (mtm[i][0] - size2) * scale,
							(mtm[i][1]),
							(mtm[i][2] - .15f) * scale );
				glVertex3f( (mtm[i+1][0] - size2) * scale,
							(mtm[i+1][1]),
							(mtm[i+1][2] - .15f) * scale );
		} 
	glEnd();
		

	view.endGL();
}
// Load the vertexProgram and fill in the necessary constants used in the vertex program.
//
void hwRefractReflectShader_NV20::loadVertexProgramGL( M3dView& view )
{
	view.beginGL();
	{
		// Don't load/initialize the vertex program more than once.
		//
		if (vertex_program_id == 0)	
			initVertexProgram(vertexProgramString, &vertex_program_id);

		// Set up the constant values.
		//
		// CONSTANTS:
		//  0- 3	4x4 ModelView-Projection composite matrix
		//  4- 7	4x4 ModelView	inverseTranspose matrix
		//  8- 11	4x4 ModelView	matrix
		//  12-15	4x4 Texture		matrix
		//
		glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0,  GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
		glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4,  GL_MODELVIEW,               GL_INVERSE_TRANSPOSE_NV);
		glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 8,  GL_MODELVIEW,               GL_IDENTITY_NV);
		glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 12, GL_TEXTURE,                 GL_IDENTITY_NV);
		
		float rIdx = fRefractionIndex;
		glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 58, rIdx, rIdx*rIdx, 0.0, 0.0);	// refraction index
		glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 59, 0.0, 0.0, 0.0, 1.0);			// eye position
		glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 64, 0.0, 1.0, 2.0, 3.0);			// misc constants
	}
	view.endGL();
}
Exemplo n.º 5
0
void octreeVizNode::draw( M3dView & view, const MDagPath & /*path*/, 
							 M3dView::DisplayStyle style,
							 M3dView::DisplayStatus status )
{
	MDagPath camera;
	view = M3dView::active3dView();
	view.getCamera(camera);
	
	MATRIX44F mat;
	double clipNear, clipFar, fov;
	int ispersp;
	
	parseCamera(camera, mat, clipNear, clipFar, fov, ispersp);
	
	view.beginGL(); 
	glPushAttrib(GL_ALL_ATTRIB_BITS);
	glShadeModel(GL_SMOOTH);
	glPointSize(3);

	if(m_pTex) {
		XYZ ori(0,0,0);
		m_pTex->setProjection(mat, fov, ispersp);
		int port[4];
	glGetIntegerv(GL_VIEWPORT, port);
		m_pTex->setPortWidth(port[2]);
		m_pTex->drawCube();
		m_pTex->testRaster(ori);
	}
	
	glPopAttrib();
	view.endGL();
}
Exemplo n.º 6
0
void fishVizNode::draw( M3dView & view, const MDagPath & /*path*/, 
							 M3dView::DisplayStyle style,
							 M3dView::DisplayStatus status )
{
	view.beginGL(); 
	glPushAttrib(GL_ALL_ATTRIB_BITS);
	unsigned num_ptc = ptc_positions.length();

	glBegin(GL_LINES);
	glColor3f(0,0,1);
	for(unsigned i=0; i<num_ptc; i++)
	{
		glVertex3f(ptc_positions[i].x, ptc_positions[i].y, ptc_positions[i].z);
		glVertex3f(ptc_positions[i].x+ptc_velocities[i].x, ptc_positions[i].y+ptc_velocities[i].y, ptc_positions[i].z+ptc_velocities[i].z);
	}
	//glColor3f(0,1,0);
	//for(unsigned i=0; i<num_ptc; i++)
	//{
	//	glVertex3f(ptc_positions[i].x, ptc_positions[i].y, ptc_positions[i].z);
	//	glVertex3f(ptc_positions[i].x+ptc_ups[i].x*m_fish_length, ptc_positions[i].y+ptc_ups[i].y*m_fish_length, ptc_positions[i].z+ptc_ups[i].z*m_fish_length);
	//}
	glColor3f(1,0,0);
	for(unsigned i=0; i<num_ptc; i++)
	{
		glVertex3f(ptc_positions[i].x, ptc_positions[i].y, ptc_positions[i].z);
		glVertex3f(ptc_positions[i].x-ptc_views[i].x*m_fish_length, ptc_positions[i].y-ptc_views[i].y*m_fish_length, ptc_positions[i].z-ptc_views[i].z*m_fish_length);
	}
	glEnd();
	glPopAttrib();
	view.endGL();
}
Exemplo n.º 7
0
void MannequinMoveManipulator::draw(M3dView &view,
  const MDagPath &path,
  M3dView::DisplayStyle style,
  M3dView::DisplayStatus status) {
  static MGLFunctionTable *gGLFT = 0;
  if (0 == gGLFT) {
    gGLFT = MHardwareRenderer::theRenderer()->glFunctionTable();
  }

  recalcMetrics();

  float size = _manipScale * MFnManip3D::globalSize();
  float handleSize = MFnManip3D::handleSize() / 100.0f; // Probably on [0, 100].
  float handleHeight = size * handleSize * 0.5f;
  float handleOfs = size - handleHeight;
  float handleRadius = handleHeight * 0.25f;

  float origin[4];
  _origin.get(origin);

  float x[4], y[4], z[4];
  (_origin + (_x * size)).get(x);
  (_origin + (_y * size)).get(y);
  (_origin + (_z * size)).get(z);

  view.beginGL();

  GLUquadricObj* quadric = gluNewQuadric();
  gluQuadricNormals(quadric, GLU_SMOOTH);
  gluQuadricTexture(quadric, true);
  gluQuadricDrawStyle(quadric, GLU_FILL);

  colorAndName(view, _glPickableItem + 0, true, xColor());
  gGLFT->glBegin(MGL_LINES);
    gGLFT->glVertex3fv(origin);
    gGLFT->glVertex3fv(x);
  gGLFT->glEnd();
  glDrawCone(quadric, _origin + (_x * handleOfs), _x, handleHeight,
    handleRadius);

  colorAndName(view, _glPickableItem + 1, true, yColor());
  gGLFT->glBegin(MGL_LINES);
    gGLFT->glVertex3fv(origin);
    gGLFT->glVertex3fv(y);
  gGLFT->glEnd();
  glDrawCone(quadric, _origin + (_y * handleOfs), _y, handleHeight,
    handleRadius);

  colorAndName(view, _glPickableItem + 2, true, zColor());
  gGLFT->glBegin(MGL_LINES);
    gGLFT->glVertex3fv(origin);
    gGLFT->glVertex3fv(z);
  gGLFT->glEnd();
  glDrawCone(quadric, _origin + (_z * handleOfs), _z, handleHeight,
    handleRadius);

  gluDeleteQuadric(quadric);

  view.endGL();
}
Exemplo n.º 8
0
void retargetLocator::draw( M3dView& view, const MDagPath& DAGPath, 
							M3dView::DisplayStyle style, M3dView::DisplayStatus status )
{
	view.beginGL();
	glPushAttrib( GL_CURRENT_BIT );
	glEnable( GL_BLEND );
	glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
	glDepthMask( GL_FALSE );
	if ( status == M3dView::kActive ) viewMode = 0;
	else if ( status == M3dView::kLead ) viewMode = 1;
    else  viewMode = 2;
	glDepthFunc( GL_ALWAYS );
	drawDiscAll( discLineAlpha*0.5f, discFillAlpha*0.5f );
	for( int i =0; i<lineAlpha.length(); i++ )
	{
		drawArrowAll( lineAlpha[i]*0.5f, fillAlpha[i]*0.5f, i );
	}
	glDepthFunc( GL_LESS );
	drawDiscAll( discLineAlpha, discFillAlpha );
	for( int i =0; i<lineAlpha.length(); i++ )
	{
		drawArrowAll( lineAlpha[i], fillAlpha[i], i );
	}
	glDepthMask( GL_TRUE );
	glDisable( GL_BLEND );
	glPopAttrib();
    view.endGL();
}
Exemplo n.º 9
0
void curvedArrows::draw( M3dView & view, const MDagPath & /*path*/, 
							 M3dView::DisplayStyle style,
							 M3dView::DisplayStatus status )
{ 
	// Get the size
	//
	MObject thisNode = thisMObject();
	MPlug tPlug = MPlug( thisNode, aTransparency ); 
	MPlug cPlug = MPlug( thisNode, aTheColor ); 

	float r, g, b, a; 
	MObject color; 

	cPlug.getValue( color ); 
	MFnNumericData data( color ); 
	data.getData( r, g, b ); 
	tPlug.getValue( a ); 

	view.beginGL(); 

	if( (style == M3dView::kFlatShaded) ||
	    (style == M3dView::kGouraudShaded) ) {
		// Push the color settings
		// 
		glPushAttrib( GL_COLOR_BUFFER_BIT | GL_CURRENT_BIT | GL_ENABLE_BIT | 
					  GL_PIXEL_MODE_BIT ); 
	
		if ( a < 1.0f ) { 
			glEnable( GL_BLEND );
			glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
		}
		
		glColor4f( r, g, b, a );			
	
		glBegin( GL_TRIANGLES ); 
		unsigned int i;
		for ( i = 0; i < fsFaceListSize; i ++ ) { 
			unsigned int *vid = fsFaceList[i];
			unsigned int *nid = fsFaceVertexNormalList[i]; 
			for ( unsigned int j = 0; j < 3; j ++ ) { 
				glNormal3d( fsNormalList[nid[j]-1][0], 
							fsNormalList[nid[j]-1][1], 
							fsNormalList[nid[j]-1][2] );
				glVertex3d( fsVertexList[vid[j]-1][0], 
							fsVertexList[vid[j]-1][1],
							fsVertexList[vid[j]-1][2] ); 
			}
		}
		glEnd(); 
	
		glPopAttrib(); 

		drawEdgeLoop( view, status ); 
	} else { 
		drawEdgeLoop( view, status ); 
	}

	view.endGL(); 
}
void areaLightNode::draw(M3dView &view, const MDagPath &path, M3dView::DisplayStyle style, M3dView::DisplayStatus status)
{

	MColor drawColor;

	drawColor.set(MColor::kRGB,1,1,0,0.5);

	if (status==M3dView::kDormant)
	{
		drawColor.set(MColor::kRGB,1,0,0,0.5);
	}

	view.setDrawColor(drawColor);
	view.beginGL();
	glBegin(GL_LINES);
	    //these are useful
	    glVertex3f(-1.0f,-1.0f,0.0f);
		glVertex3f(-1.0f,1.0f,0.0f);

		glVertex3f(-1.0f,1.0f,0.0f);
		glVertex3f(1.0f,1.0f,0.0f);

		glVertex3f(1.0f,1.0f,0.0f);
		glVertex3f(1.0f,-1.0f,0.0f);

		glVertex3f(1.0f,-1.0f,0.0f);
		glVertex3f(-1.0f,-1.0f,0.0f);

		glVertex3f(0.0f,0.0f,0.0f);
		glVertex3f(0.0f,0.0f,-3.0f);

		glVertex3f(0.0f,0.0f,-3.0f);
		glVertex3f(0.0f,-0.1f,-2.8f);

		glVertex3f(0.0f,0.0f,-3.0f);
		glVertex3f(0.0f,0.1f,-2.8f);

		//these just for fun......
		glVertex3f(-0.3f,0.5f,0.0f);
		glVertex3f(-0.85f,-0.3f,0.0f);

		glVertex3f(0.3f,0.5f,0.0f);
		glVertex3f(0.85f,-0.3f,0.0f);

		glVertex3f(-0.4f,-1.0f,0.0f);
		glVertex3f(-0.4f,-0.2f,0.0f);

		glVertex3f(-0.4f,-0.2f,0.0f);
		glVertex3f(0.4f,-0.2f,0.0f);

		glVertex3f(0.4f,-0.2f,0.0f);
		glVertex3f(0.4f,-1.0f,0.0f);

	glEnd();
	view.endGL();

}
Exemplo n.º 11
0
void VmIslandNode::draw( M3dView& i_view, const MDagPath& i_path, M3dView::DisplayStyle i_style, M3dView::DisplayStatus i_status )
{
    //fprintf( stderr, "VmIslandNode::Draw()\n" );
    
    //Start OpenGL
    i_view.beginGL();
    
    // Get all the values we need from the plugs.
    //
    // Note that for the oa_update plug, we don't actually
    // care about the value we get from it. But we do ask
    // for it to be computed, since that computation process
    // will get the internal structures up to date. But, the
    // drawStyle() plug we do care about the value of. At the
    // same time though, in the compute() method, nothing
    // needs to be computed for it.
    
    MPlug updatePlug( thisMObject(), VmIslandNode::oa_update );
    const bool updateOK = updatePlug.asBool();
    if( updateOK == false)
    {
        MGlobal::displayError( "VmIslandNode::draw() - update failed\n" );
    }
    
    MPlug drawStylePlug( thisMObject(), VmIslandNode::ia_drawStyle );
    const int drawStyle = drawStylePlug.asInt();
    
    //Check plugs
    if (drawStyle == 0){        
        drawBB();
    } else if (drawStyle == 1){        
        drawSubBB();
    } else if ( drawStyle == 2 ){
        drawPlane();
    } else if( drawStyle == 3)  {
        drawPlane();
        drawTerrainNormals();
    }else if (drawStyle == 4 ) {
        drawPlane();
        drawInstances();        
    } else if (drawStyle == 5 ) {
        drawPlane();
        drawInstances();
        drawWindVelocities();
    } else if (drawStyle == 6 ) {
        drawPlane();
        drawBB();
        drawSubBB();
        drawInstances();
        drawTerrainNormals();
        drawWindVelocities();
    }
        
    
    //Close OpenGL
    i_view.endGL();
}
Exemplo n.º 12
0
//MStatus pointLightNode::compute(const MPlug &plug, MDataBlock &data)
//{
//	MStatus stat;
//	return stat=MStatus::kSuccess;
//}
void pointLightNode::draw(M3dView &view, const MDagPath &path, M3dView::DisplayStyle style, M3dView::DisplayStatus status)
{
	MColor drawColor;

	drawColor.set(MColor::kRGB,1,1,0);

	if (status==M3dView::kDormant)
	{
		drawColor.set(MColor::kRGB,1,0,0);
	}
	if (status==M3dView::kTemplate)
	{
		drawColor.set(MColor::kRGB,0,1,0);
	}
	view.setDrawColor(drawColor);
	view.beginGL();
	glBegin(GL_LINES);
	                        glVertex3f(0.0f,0.1f,0.0f);
		                    glVertex3f(0.1f,0.0f,0.0f);

							glVertex3f(0.0f,0.1f,0.0f);
		                    glVertex3f(-0.1f,0.0f,0.0f);

							glVertex3f(0.0f,0.1f,0.0f);
		                    glVertex3f(0.0f,0.0f,0.1f);

							glVertex3f(0.0f,0.1f,0.0f);
		                    glVertex3f(0.0f,0.0f,-0.1f);

							glVertex3f(0.0f,-0.1f,0.0f);
		                    glVertex3f(0.1f,0.0f,0.0f);

							glVertex3f(0.0f,-0.1f,0.0f);
		                    glVertex3f(-0.1f,0.0f,0.0f);

							glVertex3f(0.0f,-0.1f,0.0f);
		                    glVertex3f(0.0f,0.0f,0.1f);

							glVertex3f(0.0f,-0.1f,0.0f);
		                    glVertex3f(0.0f,0.0f,-0.1f);

							glVertex3f(-0.1f,0.0f,0.0f);
		                    glVertex3f(0.0f,0.0f,0.1f);

							glVertex3f(0.0f,0.0f,0.1f);
		                    glVertex3f(0.1f,0.0f,0.0f);

							glVertex3f(0.1f,0.0f,0.0f);
		                    glVertex3f(0.0f,0.0f,-0.1f);

							glVertex3f(0.0f,0.0f,-0.1f);
		                    glVertex3f(-0.1f,0.0f,0.0f);


    glEnd();
	view.endGL();
}
Exemplo n.º 13
0
//------------------------------------------------------------------------------
//
RasterSelect::RasterSelect(
    MSelectInfo& selectInfo
) 
    : fSelectInfo(selectInfo),
      fMinZ(std::numeric_limits<float>::max())
{
    M3dView view = fSelectInfo.view();

    view.beginGL();

    unsigned int sxl, syl, sw, sh;
    fSelectInfo.selectRect(sxl, syl, sw, sh);

    unsigned int vxl, vyl, vw, vh;
    view.viewport(vxl, vyl, vw, vh);

    // Compute a new matrix that, when it is post-multiplied with the
    // projection matrix, will cause the picking region to fill only
    // a small region.

    const unsigned int width = (MAX_RASTER_SELECT_RENDER_SIZE < sw) ?
        MAX_RASTER_SELECT_RENDER_SIZE : sw;
    const unsigned int height = (MAX_RASTER_SELECT_RENDER_SIZE < sh) ?
        MAX_RASTER_SELECT_RENDER_SIZE : sh;

    const double sx = double(width) / double(sw);
    const double sy = double(height) / double(sh);

    const double fx = 2.0 / double(vw);
    const double fy = 2.0 / double(vh);
    
    MMatrix  selectMatrix;
    selectMatrix.matrix[0][0] = sx;
    selectMatrix.matrix[1][1] = sy;
    selectMatrix.matrix[3][0] = -1.0 - sx * (fx * (sxl - vxl) - 1.0);
    selectMatrix.matrix[3][1] = -1.0 - sy * (fy * (syl - vyl) - 1.0);
    
        
    MMatrix projMatrix;
    view.projectionMatrix(projMatrix);

    ::glMatrixMode(GL_PROJECTION);
    ::glPushMatrix();
    ::glLoadMatrixd(selectMatrix[0]);
    ::glMultMatrixd(projMatrix[0]);
    ::glMatrixMode(GL_MODELVIEW);

    ::glScissor(vxl, vyl, width, height);
    ::glEnable(GL_SCISSOR_TEST);
    ::glClear(GL_DEPTH_BUFFER_BIT);

    fWasDepthTestEnabled = ::glIsEnabled(GL_DEPTH_TEST);
    if (!fWasDepthTestEnabled) {
        ::glEnable(GL_DEPTH_TEST);
    }
}
Exemplo n.º 14
0
void bruiseMapNode::draw( M3dView & view, const MDagPath & /*path*/, 
							 M3dView::DisplayStyle style,
							 M3dView::DisplayStatus status )
{
	view.beginGL(); 
	glPointSize(2);
	if(m_base->hasBase()) m_base->draw();

	view.endGL();
}
// Load the textures, update the necessary variable values, initialize register combiners,
// save and load the matrices with the proper values
//
MStatus	hwRefractReflectShader_NV20::preDraw(const MDrawRequest& request, M3dView& view)
{
	MStatus stat = loadTextures( request, view);

	if( MS::kSuccess != stat )		return stat;

	// get the reflectivity value
	//
	MPlug	tPlug(thisMObject(), reflectivity);
	if( tPlug.getValue( fReflectivity ) )
	{
		if( fReflectivity < 0.01f )	fReflectivity = 0.01f;
		if( fReflectivity > 1.0f )	fReflectivity = 1.0f;
	}
	else	fReflectivity = 0.5f;
	
	// get the refraction index value
	//
	MPlug	rPlug(thisMObject(), refractionIndex);
	if( rPlug.getValue( fRefractionIndex ) )
	{
		if ( fRefractionIndex < 1.0f )	fRefractionIndex = 1.0f;
		if ( fRefractionIndex > 2.0f )	fRefractionIndex = 2.0f;
	}
	else	fRefractionIndex = 1.0f;
	
	initCombiners( request, view );
	
	// Compute the camera rotation angle and axis
	//
	MDagPath	cameraPath;
	MStatus		status = view.getCamera( cameraPath );
	MMatrix		mmatrix = cameraPath.inclusiveMatrix( &status );
	MTransformationMatrix tmatrix( mmatrix );
	
	MQuaternion camRotation = tmatrix.rotation();
	MVector		camAxis;
	double		camTheta;
	camRotation.getAxisAngle(  camAxis, camTheta );
	
	// Convert to degrees from radians
	camTheta *= 57.295779513082320876798154814105;	// == (180 / M_PI)
	
	view.beginGL();
		glMatrixMode( GL_TEXTURE );
		glPushMatrix();
		glLoadIdentity();
		glScalef(1.0, -1.0, 1.0);
		glRotated( camTheta, camAxis[0], camAxis[1], camAxis[2]);
		glMatrixMode( GL_MODELVIEW );
	view.endGL();

	return stat;
}
Exemplo n.º 16
0
/* virtual */
MStatus	hwUnlitShader::unbind(const MDrawRequest& request,
			   M3dView& view)
{
	view.beginGL();	
	glPopClientAttrib();
	glPopAttrib();

	view.endGL();

	return MS::kSuccess;
}
Exemplo n.º 17
0
void sixdofConstraintNode::draw( M3dView & view, const MDagPath &path,
                             M3dView::DisplayStyle style,
                             M3dView::DisplayStatus status )
{
  //  std::cout << "sixdofConstraintNode::draw" << std::endl;

    update();

    view.beginGL();
    glPushAttrib( GL_ALL_ATTRIB_BITS );

//	glPushMatrix();
    glDisable(GL_LIGHTING);

    if( !(status == M3dView::kActive ||
        status == M3dView::kLead ||
        status == M3dView::kHilite ||
        ( style != M3dView::kGouraudShaded && style != M3dView::kFlatShaded )) ) {
        glColor3f(1.0, 1.0, 0.0); 
    }

	vec3f posA;
	vec3f posB;
	if (m_constraint) {
		vec3f world;
		m_constraint->get_world(world);
		quatf rotA;
		m_constraint->rigid_bodyA()->get_transform(posA, rotA);
		posA = posA - world;
		quatf rotB;
		m_constraint->rigid_bodyB()->get_transform(posB, rotB);
		posB = posB - world;
	}

//	glLoadIdentity();
    glBegin(GL_LINES);
    glVertex3f(posA[0], posA[1], posA[2]);
    glVertex3f(posB[0], posB[1], posB[2]);

    glVertex3f(-1.0, 0.0, 0.0);
    glVertex3f(1.0, 0.0, 0.0);

    glVertex3f(0.0, -1.0, 0.0);
    glVertex3f(0.0, 1.0, 0.0);

    glVertex3f(0.0, 0.0, -1.0);
    glVertex3f(0.0, 0.0, 1.0);
    glEnd();

//	glPopMatrix();

    glPopAttrib();
    view.endGL();
}
Exemplo n.º 18
0
void rigidBodyNode::draw( M3dView & view, const MDagPath &path,
                             M3dView::DisplayStyle style,
                             M3dView::DisplayStatus status )
{
	
  //  std::cout << "rigidBodyNode::draw" << std::endl;
	MObject thisObject(thisMObject());
    update();
	
    view.beginGL();
    glPushAttrib( GL_ALL_ATTRIB_BITS );

    if(m_rigid_body) {
        //remove the scale, since it's already included in the node transform 
        vec3f scale;
        m_rigid_body->collision_shape()->get_scale(scale);

        glPushMatrix();
        glScalef(1/scale[0], 1/scale[1], 1/scale[2]); 
    
        if(style == M3dView::kFlatShaded || style == M3dView::kGouraudShaded) {
            glEnable(GL_LIGHTING);
			MPlug plug(thisObject, rigidBodyNode::ia_mass);
			float mass;
			plug.getValue(mass);
			if (mass) {
				float material[] = { 0.2f, 1.0f, 0.2f, 1.0f };
				glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, material);
			} else {
				float material[] = { 1.0f, 0.3f, 0.1f, 1.0f };
				glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, material);
			}
            //glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, material);
            m_rigid_body->collision_shape()->gl_draw(collision_shape_t::kDSSolid);
        } 
    
    
        if( status == M3dView::kActive ||
            status == M3dView::kLead ||
            status == M3dView::kHilite ||
            ( style != M3dView::kGouraudShaded && style != M3dView::kFlatShaded ) ) {
            
            glDisable(GL_LIGHTING);
            m_rigid_body->collision_shape()->gl_draw(collision_shape_t::kDSWireframe);
    
        }
        glPopMatrix();
    }
    glPopAttrib();
    view.endGL();
}
Exemplo n.º 19
0
void DrawableHolderUI::draw( const MDrawRequest &request, M3dView &view ) const
{
	MDrawData drawData = request.drawData();
	DrawableHolder *drawableHolder = (DrawableHolder *)drawData.geometry();
	assert( drawableHolder );

	IECoreGL::ConstScenePtr s = drawableHolder->scene();
	if( !s )
	{
		return;
	}

	view.beginGL();

		// maya can sometimes leave an error from it's own code,
		// and we don't want that to confuse us in our drawing code.
		while( glGetError()!=GL_NO_ERROR )
		{
		}

		// if we're being drawn as part of a selection operation we need
		// to make sure there's a name on the name stack, as the IECoreGL::NameStateComponent
		// expects to be able to load a name into it (it fails with an invalid operation if
		// there's no name slot to load into).
		if( view.selectMode() )
		{
			view.pushName( 0 );
		}

		try
		{
			// do the main render
			s->render( m_displayStyle.baseState( request.displayStyle() ) );

			// do a wireframe render over the top if we're selected and we just did a solid
			// draw.
			bool selected = request.displayStatus()==M3dView::kActive || request.displayStatus()==M3dView::kLead;
			bool solid = request.displayStyle()==M3dView::kFlatShaded || request.displayStyle()==M3dView::kGouraudShaded;
			if( selected && solid )
			{
				s->render( m_displayStyle.baseState( M3dView::kWireFrame ) );
			}
		}
		catch( std::exception &e )
		{
			IECore::msg( IECore::Msg::Error, "DrawableHolderUI::draw", e.what() );
		}

	view.endGL();
}
Exemplo n.º 20
0
void swissArmyLocatorManip::draw(M3dView & view, 
								 const MDagPath &path, 
								 M3dView::DisplayStyle style,
								 M3dView::DisplayStatus status)
{ 
    MPxManipContainer::draw(view, path, style, status);
    view.beginGL(); 

    MPoint textPos = nodeTranslation();
	char str[100];
    sprintf(str, "Swiss Army Manipulator"); 
    MString distanceText(str);
    view.drawText(distanceText, textPos, M3dView::kLeft);
    view.endGL();
}
Exemplo n.º 21
0
void wingVizNode::draw( M3dView & view, const MDagPath & /*path*/, 
							 M3dView::DisplayStyle style,
							 M3dView::DisplayStatus status )
{ 
	view.beginGL(); 

	//glPushAttrib( GL_POLYGON_BIT );
	//glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
	//glFrontFace(GL_CW);
	//glEnable(GL_CULL_FACE);
	//if(i_show_v) m_base->drawVelocity();
	m_base->draw();
	//glPopAttrib();
	view.endGL();
}
Exemplo n.º 22
0
/* virtual */
MStatus	pnTriangles::unbind(const MDrawRequest& request,
						    M3dView& view)
//
// Description:
//		
//
{
	view.beginGL();

	// Disable vertex shader
	if (fTestVertexProgram)
	{
		glDisable(GL_VERTEX_SHADER_EXT);
	}
	// Disable fragment shader
	else if (fTestFragmentProgram)
	{
		glDisable(GL_FRAGMENT_SHADER_ATI);
	}
	// Disable regular material state
	else
	{
		glDisable( GL_TEXTURE_2D );
		glDisable(GL_COLOR_MATERIAL);

		if (fInTexturedMode)
		{
			glMatrixMode(GL_TEXTURE);
			glPopMatrix();
			glMatrixMode(GL_MODELVIEW);
		}
	}

	// Disable PN triangles extension if needed
	//
	if (fExtensionSupported[kPNTriangesEXT] || (fSubdivisions == 0))
	{
		if (fSubdivisions != 0)
			glDisable( GL_PN_TRIANGLES_ATI );
	}
	
	glPopClientAttrib();
	glPopAttrib();

	view.endGL();

	return MS::kSuccess;
}
Exemplo n.º 23
0
void mpBox::draw( M3dView & view, const MDagPath & path,
                  M3dView::DisplayStyle style, M3dView::DisplayStatus status )
{
    float xsize, ysize, zsize;
    MObject thisNode = thisMObject();
    float r, g, b, a;
    float rotx, roty, rotz, ba;
    int lw, dt;
    MObject color;
    MObject rotate;
    _COMMON_ATTR_READ_;
    //zsize
    MPlug xsPlug = MPlug( thisNode, aXsize );
    xsPlug.getValue( xsize );
    //ysize
    MPlug ysPlug = MPlug( thisNode, aYsize );
    ysPlug.getValue( ysize );
    //zsize
    MPlug zsPlug = MPlug( thisNode, aZsize );
    zsPlug.getValue( zsize );
    //drawType
    MPlug drPlug = MPlug( thisNode, aDrawType );
    drPlug.getValue( dt );

    view.beginGL();
    glPushMatrix();
    glRotatef(rotx ,1.0,0.0,0.0);
    glRotatef(roty ,0.0,1.0,0.0);
    glRotatef(rotz ,0.0,0.0,1.0);
    glPushAttrib(GL_ALL_ATTRIB_BITS);
    glEnable( GL_BLEND );
    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
    //draw Infront
    glDepthFunc(GL_LESS);
    glColor4f( r, g, b, a );
    drawStyle(style, dt, lw);
    drawCube(xsize, ysize, zsize);
    //draw Behind
    glDepthFunc(GL_GREATER);
    glColor4f( r, g, b, ba );
    drawStyle(style, dt, lw);
    drawCube(xsize, ysize, zsize);

    glPopAttrib();
    glPopMatrix();
    view.endGL();
}
Exemplo n.º 24
0
void BCIViz::draw( M3dView & view, const MDagPath & path, 
							 M3dView::DisplayStyle style,
							 M3dView::DisplayStatus status )
{ 	
	MObject thisNode = thisMObject();
	view.beginGL(); 
	
	glPushAttrib (GL_CURRENT_BIT);
	glDisable(GL_DEPTH_TEST);
	drawDriver();
	drawTargets();
	drawNeighbours();
	drawWeights();
	glEnable(GL_DEPTH_TEST);
	glPopAttrib();
	view.endGL();
}
Exemplo n.º 25
0
MStatus marqueeContext::doPress( MEvent & event )
//
// Begin marquee drawing (using OpenGL)
// Get the start position of the marquee 
//
{

		// Figure out which modifier keys were pressed, and set up the
	// listAdjustment parameter to reflect what to do with the selected points.
	if (event.isModifierShift() || event.isModifierControl() ) {
		if ( event.isModifierShift() ) {
			if ( event.isModifierControl() ) {
				// both shift and control pressed, merge new selections
				listAdjustment = MGlobal::kAddToList;
			} else {
				// shift only, xor new selections with previous ones
				listAdjustment = MGlobal::kXORWithList;
			}
		} else if ( event.isModifierControl() ) {
			// control only, remove new selections from the previous list
			listAdjustment = MGlobal::kRemoveFromList; 
		}
	} else {
		listAdjustment = MGlobal::kReplaceList;
	}

	// Extract the event information
	//
	event.getPosition( start_x, start_y );

	// Enable OpenGL drawing on viewport
	view = M3dView::active3dView();
	view.beginGL();

#ifdef USE_SOFTWARE_OVERLAYS
	p_last_x = start_x;
	p_last_y = start_y;

	fsDrawn = false;
#else
	// If HW overlays supported then initialize the overlay plane for drawing.
	view.beginOverlayDrawing();
#endif

	return MS::kSuccess;		
}
Exemplo n.º 26
0
/* virtual */
MStatus	hwDecalBumpShader_NV20::unbind(const MDrawRequest& request,
			   M3dView& view)
{
	view.beginGL();
	
	glDisable(GL_REGISTER_COMBINERS_NV);
	glDisable(GL_TEXTURE_SHADER_NV);

	glActiveTextureARB( GL_TEXTURE0_ARB );

	glPopClientAttrib();
	glPopAttrib();

	view.endGL();

	return MS::kSuccess;
}
Exemplo n.º 27
0
void hwPhongShader::releaseEverything()
{
    if (phong_map_id != 0) {
		M3dView view = M3dView::active3dView();

        // The M3dView class doesn't return the correct status if there isn't
        // an active 3D view, so we rely on the success of beginGL() which
        // will make the context current.
        //
        if (view.beginGL()) {
		    glDeleteTextures( 1, &phong_map_id );
        
            phong_map_id = 0;
        }

        view.endGL();
    }
}
Exemplo n.º 28
0
/* virtual */
MStatus	hwUnlitShader::geometry( const MDrawRequest& request,
								M3dView& view,
							    int prim,
								unsigned int writable,
								int indexCount,
								const unsigned int * indexArray,
								int vertexCount,
								const int * vertexIDs,
								const float * vertexArray,
								int normalCount,
								const float ** normalArrays,
								int colorCount,
								const float ** colorArrays,
								int texCoordCount,
								const float ** texCoordArrays)
{
	view.beginGL();

	glVertexPointer(3, GL_FLOAT, 0, vertexArray);
	glEnableClientState(GL_VERTEX_ARRAY);

	if (normalCount > 0)
	{
		// Technically, we don't need the normals for this example. But
		// most of the 3rd party plug-ins will probably want the normal,
		// which is why the following lines were kept.
		glNormalPointer(GL_FLOAT, 0, normalArrays[0]);
		glEnableClientState(GL_NORMAL_ARRAY);
	}

	if (texCoordCount > 0)
	{
		glTexCoordPointer(2, GL_FLOAT, 0, texCoordArrays[0]);
		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	}

	glDrawElements(prim, indexCount, GL_UNSIGNED_INT, indexArray);

	view.endGL();

	return MS::kSuccess;
}
// Initialize the register combiners setting
//
void	hwRefractReflectShader_NV20::initCombiners(const MDrawRequest& request, M3dView& view)
{
	view.beginGL();
	{
		// Use only the 1st stage of the register combiner stages
		//
		glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 1);

		{
			float refractivity[4], reflectivity[4];
			refractivity[0] = refractivity[1] = refractivity[2] = refractivity[3] = 1.0f - fReflectivity;
			reflectivity[0] = reflectivity[1] = reflectivity[2] = reflectivity[3] = fReflectivity;

			glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, refractivity);
			glCombinerParameterfvNV(GL_CONSTANT_COLOR1_NV, reflectivity);
		}
		
		// combiner 0
		// a*b+c*d
		// a is from the refractive color
		// c is from the refrlective texture
		glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
		glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
		glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE1_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
		glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_CONSTANT_COLOR1_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
		
		// output:
		// (stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum)
		glCombinerOutputNV(GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
		
		// final combiner
		// output: Frgb = A*B + (1-A)*C + D
		// (variable, input, mapping, componentUsage);
		// Just pass through the D variable
		//
		glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
		glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
		glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
		glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
	}
	view.endGL();
}
Exemplo n.º 30
0
void sgBLocator_fromGeo::draw( M3dView& view, const MDagPath& dagPath, M3dView::DisplayStyle displayStyle, M3dView::DisplayStatus status )
{
	view.beginGL();

	glPushAttrib( GL_CURRENT_BIT );
    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
    glDepthMask( GL_FALSE );

	glDisable ( GL_LIGHTING );

    if ( status == M3dView::kActive )
    {
        glColor3f( m_colorActive.r, m_colorActive.g, m_colorActive.b );
    }
    else if ( status == M3dView::kLead )
    {
        glColor3f( m_colorLead.r, m_colorLead.g, m_colorLead.b );
    }
    else
    {
		glColor3f( m_colorDefault.r, m_colorDefault.g, m_colorDefault.b );
    }
    
	glLineWidth( m_lineWidth );
	glBegin( GL_LINES );
    glVertex3f( m_pointArr[0].x, m_pointArr[0].y, m_pointArr[0].z );
	glVertex3f( m_pointArr[1].x, m_pointArr[1].y, m_pointArr[1].z );

    glVertex3f( m_pointArr[2].x, m_pointArr[2].y, m_pointArr[2].z );
	glVertex3f( m_pointArr[3].x, m_pointArr[3].y, m_pointArr[3].z );

    glVertex3f( m_pointArr[4].x, m_pointArr[4].y, m_pointArr[4].z );
	glVertex3f( m_pointArr[5].x, m_pointArr[5].y, m_pointArr[5].z );
    glEnd();

	glLineWidth( 1 );
	glDepthMask( GL_TRUE );
	glPopAttrib();
    view.endGL();
}