/* Initialize material property and depth buffer.
*/
static void init(void)
{
GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 100.0 };
glClearColor (0.0, 0.0, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
init_surface();
theNurb = gluNewNurbsRenderer();
gluNurbsProperty(theNurb, GLU_NURBS_MODE,
GLU_NURBS_TESSELLATOR);
gluNurbsProperty(theNurb, GLU_SAMPLING_TOLERANCE, 25.0);
gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL);
gluNurbsCallback(theNurb, GLU_ERROR, nurbsError);
gluNurbsCallback(theNurb, GLU_NURBS_BEGIN, beginCallback);
gluNurbsCallback(theNurb, GLU_NURBS_VERTEX, vertexCallback);
gluNurbsCallback(theNurb, GLU_NURBS_NORMAL, normalCallback);
gluNurbsCallback(theNurb, GLU_NURBS_END, endCallback);
}
void init(void)
{
GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 100.0 };
glClearColor (0.0, 0.0, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
init_surface();
theNurb = gluNewNurbsRenderer();
gluNurbsProperty(theNurb, GLU_SAMPLING_TOLERANCE, 25.0);
gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL);
gluNurbsCallback(theNurb, GLU_ERROR,
(GLvoid (*)()) nurbsError);
}
// This function does any needed initialization on the rendering
// context. Here it sets up and initializes the lighting for
// the scene.
void SetupRC()
{
// Light values and coordinates
GLfloat whiteLight[] = {0.7f, 0.7f, 0.7f, 1.0f };
GLfloat specular[] = { 0.7f, 0.7f, 0.7f, 1.0f};
GLfloat shine[] = { 100.0f };
// Clear Window to white
glClearColor(1.0f, 1.0f, 1.0f, 1.0f );
// Enable lighting
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// Enable color tracking
glEnable(GL_COLOR_MATERIAL);
// Set Material properties to follow glColor values
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
glMaterialfv(GL_FRONT, GL_SHININESS, shine);
// Automatically generate normals for evaluated surfaces
glEnable(GL_AUTO_NORMAL);
// Setup the Nurbs object
pNurb = gluNewNurbsRenderer();
gluNurbsProperty(pNurb, GLU_SAMPLING_TOLERANCE, 25.0f);
gluNurbsProperty(pNurb, GLU_DISPLAY_MODE, (GLfloat)GLU_FILL);
}
/* Initialize material property, light source, lighting model,
* and depth buffer.
*/
static void myinit(void)
{
GLfloat mat_ambient[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_diffuse[] = { 1.0, 0.2, 1.0, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 50.0 };
GLfloat light0_position[] = { 1.0, 0.1, 1.0, 0.0 };
GLfloat light1_position[] = { -1.0, 0.1, 1.0, 0.0 };
GLfloat lmodel_ambient[] = { 0.3, 0.3, 0.3, 1.0 };
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
glEnable(GL_AUTO_NORMAL);
theNurb = gluNewNurbsRenderer();
gluNurbsProperty(theNurb, GLU_SAMPLING_TOLERANCE, 25.0);
gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL);
}
void Sample_12_7::initGL()
{
glPushAttrib(GL_ALL_ATTRIB_BITS);
GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 100.0 };
glClearColor (0.0, 0.0, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
m_theNurb = gluNewNurbsRenderer();
gluNurbsProperty(m_theNurb, GLU_NURBS_MODE,
GLU_NURBS_TESSELLATOR);
gluNurbsProperty(m_theNurb, GLU_SAMPLING_TOLERANCE, 25.0);
gluNurbsProperty(m_theNurb, GLU_DISPLAY_MODE, GLU_FILL);
gluNurbsCallback(m_theNurb, GLU_ERROR, (GLvoid (*) ()) &errorCallbackNURBS);
gluNurbsCallback(m_theNurb, GLU_NURBS_BEGIN, (GLvoid (*) ()) &beginCallbackNURBS);
gluNurbsCallback(m_theNurb, GLU_NURBS_VERTEX, (GLvoid (*) ()) &vertexCallbackNURBS);
gluNurbsCallback(m_theNurb, GLU_NURBS_NORMAL, (GLvoid (*) ()) &normalCallbackNURBS);
gluNurbsCallback(m_theNurb, GLU_NURBS_END, endCallbackNURBS);
}
//-*****************************************************************************
INuPatchDrw::INuPatchDrw( INuPatch &iNuPatch )
: IObjectDrw( iNuPatch, false )
, m_nuPatch( iNuPatch )
{
// create our nurb renderer.
nurb = gluNewNurbsRenderer();
gluNurbsProperty(nurb, GLU_SAMPLING_TOLERANCE, 25.0);
gluNurbsProperty(nurb, GLU_DISPLAY_MODE, GLU_FILL);
// Get out if problems.
if ( !m_nuPatch.valid() )
{
return;
}
// The object has already set up the min time and max time of
// all the children.
// if we have a non-constant time sampling, we should get times
// out of it.
TimeSamplingPtr iTsmp = m_nuPatch.getSchema().getTimeSampling();
if ( !m_nuPatch.getSchema().isConstant() )
{
size_t numSamps = m_nuPatch.getSchema().getNumSamples();
if ( numSamps > 0 )
{
chrono_t minTime = iTsmp->getSampleTime( 0 );
m_minTime = std::min( m_minTime, minTime );
chrono_t maxTime = iTsmp->getSampleTime( numSamps-1 );
m_maxTime = std::max( m_maxTime, maxTime );
}
}
}
/* Initialize material property and depth buffer.
*/
void myinit(void)
{
GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 100.0 };
glClearColor (0.0, 0.0, 0.0, 1.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
init_surface();
theNurb = gluNewNurbsRenderer();
gluNurbsProperty(theNurb, GLU_SAMPLING_TOLERANCE, 25.0);
gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef (0.0, 0.0, -5.0);
}
/* Opens a square window, and initializes the window, interesting devices,
* viewing volume, material, and lights.
*/
static void
initialize(void) {
GLfloat mat_diffuse[] = { .8, .1, .8, 1. };
GLfloat mat_specular[] = { .6, .6, .6, 1. };
GLfloat mat_ambient[] = { .1, .1, .1, 1. };
glClearColor(.58, .58, .58, 0.);
glClearDepth(1.);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
gluPerspective(60,1.0,1.0,10.0);
glMatrixMode(GL_MODELVIEW);
glTranslatef(0., 0., -6.);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 32.0);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
nurbsflag = gluNewNurbsRenderer();
gluNurbsProperty(nurbsflag, GLU_SAMPLING_TOLERANCE, 100.0);
gluNurbsProperty(nurbsflag, GLU_DISPLAY_MODE, GLU_FILL);
init_trims();
}
void create_nurbs()
{
nrb_obj = gluNewNurbsRenderer();
gluNurbsProperty(nrb_obj, GLU_SAMPLING_TOLERANCE, 100.0);
gluNurbsProperty(nrb_obj, GLU_DISPLAY_MODE, GLU_FILL);
}
void SetupRC()
{
GLfloat whiteLight[] = {0.7f, 0.7f, 0.7f, 1.0f };
GLfloat specular[] = { 0.7f, 0.7f, 0.7f, 1.0f};
GLfloat shine[] = { 100.0f };
glClearColor(1.0f, 1.0f, 1.0f, 1.0f );
//开启光照
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// 开启颜色追踪
glEnable(GL_COLOR_MATERIAL);
//设置材料属性
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
glMaterialfv(GL_FRONT, GL_SHININESS, shine);
//自动生成法线
glEnable(GL_AUTO_NORMAL);
//创建NURBS渲染器
pNurb = gluNewNurbsRenderer();
//设置NURBS出错处理函数
gluNurbsCallback(pNurb, GLU_ERROR, (CallBack)NurbsErrorHandler);
//设置采样容差
gluNurbsProperty(pNurb, GLU_SAMPLING_TOLERANCE, 25.0f);
//设置显示模式
gluNurbsProperty(pNurb, GLU_DISPLAY_MODE, GLU_FILL);
}
ON_BOOL32 myInitGL( const ON_Viewport& viewport, GLUnurbsObj*& nobj )
{
// set the model view transform
SetGLModelViewMatrix( viewport );
// this stuff works with MSVC 4.2's Open GL. Changes may be needed for other
// GLs.
//ON_Color background_color(0,128,128);
ON_Color background_color(0,63,127);
//background_color = glb_model->m_settings.m_RenderSettings.m_background_color;
glClearColor( (float)background_color.FractionRed(),
(float)background_color.FractionGreen(),
(float)background_color.FractionBlue(),
1.0f
);
glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );
glDisable( GL_CULL_FACE );
// Rhino viewports have camera "Z" pointing at the camera in a right
// handed coordinate system.
glClearDepth( 0.0f );
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_GEQUAL );
glEnable( GL_LIGHTING );
glEnable( GL_DITHER );
//glEnable( GL_AUTO_NORMAL );
//glEnable( GL_NORMALIZE );
// default material
ON_GL( (ON_Material*)NULL );
// GL rendering of NURBS objects requires a GLUnurbsObj.
nobj = gluNewNurbsRenderer();
if ( !nobj )
return false;
gluNurbsProperty( nobj, GLU_SAMPLING_TOLERANCE, 20.0f );
gluNurbsProperty( nobj, GLU_PARAMETRIC_TOLERANCE, 0.5f );
gluNurbsProperty( nobj, GLU_DISPLAY_MODE, (GLfloat)GLU_FILL );
//gluNurbsProperty( nobj, GLU_DISPLAY_MODE, GLU_OUTLINE_POLYGON );
//gluNurbsProperty( nobj, GLU_DISPLAY_MODE, GLU_OUTLINE_PATCH );
gluNurbsProperty( nobj, GLU_SAMPLING_METHOD, (GLfloat)GLU_PATH_LENGTH );
//gluNurbsProperty( nobj, GLU_SAMPLING_METHOD, GLU_PARAMETRIC_ERROR );
//gluNurbsProperty( nobj, GLU_SAMPLING_METHOD, GLU_DOMAIN_DISTANCE );
gluNurbsProperty( nobj, GLU_CULLING, (GLfloat)GL_FALSE );
// register GL NURBS error callback
{
// hack to get around C vs C++ type checking trauma
RHINO_GL_NURBS_ERROR fn;
fn = (RHINO_GL_NURBS_ERROR)myNurbsErrorCallback;
gluNurbsCallback( nobj, GLU_ERROR, fn );
}
return true;
}
void init_scene(int width, int height)
{
int u, v;
/* Setup our viewport for OpenGL ES */
glViewport(0, 0, (GLint)width, (GLint)height);
/* Setup our viewport for GLU ES (required when using OpenGL ES 1.0 only) */
gluViewport(0, 0, (GLint)width, (GLint)height);
/* Set black background color */
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
/* Since GL ES has no GL_AUTO_NORMAL, we implement it in GLU */
gluEnable(GLU_AUTO_NORMAL);
nurb=gluNewNurbsRenderer();
gluNurbsProperty(nurb, GLU_SAMPLING_TOLERANCE, 25.0f);
gluNurbsProperty(nurb, GLU_DISPLAY_MODE, GLU_FILL);
for (u=0; u<4; u++)
{
for (v=0; v<4; v++)
{
ctlpoints[u][v][0]=2.0f*((GLfloat)u-1.5f);
ctlpoints[u][v][1]=2.0f*((GLfloat)v-1.5f);
if ((u==1 || u==2) && (v==1 || v==2))
{
ctlpoints[u][v][2]=3.0f;
}
else
{
ctlpoints[u][v][2]=-3.0f;
}
}
}
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, (GLfloat)window_width/(GLfloat)window_height, 3.0f, 24.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0f, 0.5f, -9.0f);
glRotatef(330.0f, 1.0f, 0.0f, 0.0f);
}
// This function does any needed initialization on the rendering
// context. Here it sets up and initializes the lighting for
// the scene.
void SetupRC()
{
// Clear Window to white
glClearColor(1.0f, 1.0f, 1.0f, 1.0f );
// Setup the Nurbs object
pNurb = gluNewNurbsRenderer();
gluNurbsProperty(pNurb, GLU_SAMPLING_TOLERANCE, 25.0f);
gluNurbsProperty(pNurb, GLU_DISPLAY_MODE, (GLfloat)GLU_FILL);
}
void GraphicsPainter::drawNurbsSurface(const QVector<Point3f> &controlPoints, const QVector<float> &uKnots, const QVector<float> &vKnots, int uOrder, int vOrder)
{
// nurbs control points
QVector<float> points(controlPoints.size() * 3);
for(int i = 0; i < controlPoints.size(); i++){
points[i*3+0] = controlPoints[i].x();
points[i*3+1] = controlPoints[i].y();
points[i*3+2] = controlPoints[i].z();
}
// nurbs knot vectors
QVector<float> uKnotVector(uKnots.size());
for(int i = 0; i < uKnots.size(); i++)
uKnotVector[i] = uKnots[i];
QVector<float> vKnotVector(vKnots.size());
for(int i = 0; i < vKnots.size(); i++)
vKnotVector[i] = vKnots[i];
int uStride = 3 * (vKnotVector.size() - vOrder);
int vStride = 3;
glEnable(GL_AUTO_NORMAL);
GLUnurbsObj *nurb = gluNewNurbsRenderer();
gluNurbsProperty(nurb, GLU_CULLING, GL_TRUE); // only render visible parts of the surface
gluNurbsProperty(nurb, GLU_V_STEP, 4);
gluNurbsProperty(nurb, GLU_U_STEP, 10);
gluNurbsProperty(nurb, GLU_SAMPLING_METHOD, GLU_DOMAIN_DISTANCE);
#ifdef Q_OS_WIN
gluNurbsCallback(nurb, GLU_ERROR, (void (__stdcall *)()) nurbsErrorCallback);
#else
gluNurbsCallback(nurb, GLU_ERROR, (void (*)()) nurbsErrorCallback);
#endif
gluBeginSurface(nurb);
gluNurbsSurface(nurb,
uKnotVector.size(),
uKnotVector.data(),
vKnotVector.size(),
vKnotVector.data(),
uStride,
vStride,
points.data(),
uOrder,
vOrder,
GL_MAP2_VERTEX_3);
gluEndSurface(nurb);
gluDeleteNurbsRenderer(nurb);
glDisable(GL_AUTO_NORMAL);
}
void Quiddiards::initializeGL(){
glClearColor(0.0, 0.0, 0.0, 0.0);
glClearDepth(1.0);
glEnable(GL_AUTO_NORMAL);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
//glDisable(GL_BLEND);
//glBlendFunc(GL_ONE, GL_ZERO);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
/* camera */
camera = FOLLOW;
theta = 45;
phi = 45;
radius = MAXRANGE / 2;
initObjects(); // init objects first, since others may base on them
loadResources();
initLights();
ambLight = true;
sunLight = true;
spotLight = true;
pause = false;
/* flag nurbs object */
nurbs = gluNewNurbsRenderer();
gluNurbsProperty(nurbs, GLU_SAMPLING_TOLERANCE, 25.0);
gluNurbsProperty(nurbs, GLU_DISPLAY_MODE, GLU_FILL);
/* quadric object */
quad = gluNewQuadric();
gluQuadricDrawStyle(quad, GLU_FILL);
gluQuadricNormals(quad, GLU_SMOOTH);
gluQuadricTexture(quad, true);
timer = new QTimer;
connect(timer, SIGNAL(timeout()), SLOT(animate()));
timer->start(interval);
msec = clock();
/* particle system */
ps = new ParticleSystem(200, -10.0f);
}
void Initial()
{
glClearColor(1.0f, 1.0f, 1.0f, 1.0f );
glLineWidth(3.0f);
//初始化NURBS对象
pNurb = gluNewNurbsRenderer();
//采样的最大长度为25
gluNurbsProperty(pNurb, GLU_SAMPLING_TOLERANCE, 25.0f);
//显示模式为GLU_FILL
gluNurbsProperty(pNurb, GLU_DISPLAY_MODE, (GLfloat)GLU_FILL);
}
void CMeter2DGraphView::initializeGL()
{
TRACE_FUN( Routine, "CMeter2DGraphView::initializeGL" );
CAbstractMeterView::initializeGL();
_meshList = glGenLists( 1 );
_nurbsRenderer = gluNewNurbsRenderer();
gluNurbsProperty( _nurbsRenderer, GLU_SAMPLING_TOLERANCE, 5. );
gluNurbsProperty( _nurbsRenderer, GLU_DISPLAY_MODE, GLU_FILL );
}
void init(void)
{
if (!pNurb2)
{
pNurb2 = gluNewNurbsRenderer();
gluNurbsProperty(pNurb2, GLU_SAMPLING_TOLERANCE, 5.0f);
gluNurbsProperty(pNurb2, GLU_DISPLAY_MODE, GLU_OUTLINE_POLYGON);
/* gluNurbsProperty(pNurb2, GLU_DISPLAY_MODE, GLU_FILL); */
gluNurbsCallback(pNurb2, GLU_ERROR, (GLvoid (*) ()) nurbsError);
}
glClearColor(1.0, 1.0, 1.0, 0.0);
glShadeModel(GL_SMOOTH);
glLineWidth(7.0);
glTranslatef(0., 0., -1.5);
}
GLUnurbsObj* LICE_GL_ctx::GetNurbsObj(int linetol)
{
if (!IsValid()) return 0;
if (!m_nurbs) m_nurbs = gluNewNurbsRenderer();
if (m_nurbs) gluNurbsProperty(m_nurbs, GLU_SAMPLING_TOLERANCE, (float)linetol);
return m_nurbs;
}
static int tolua_glu_gluNurbsProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"GLUnurbsObj",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!tolua_isnumber(tolua_S,3,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,4,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
GLUnurbsObj* nobj = ((GLUnurbsObj*) tolua_tousertype(tolua_S,1,0));
int property = (( int) tolua_tonumber(tolua_S,2,0));
float value = (( float) tolua_tonumber(tolua_S,3,0));
{
gluNurbsProperty(nobj,property,value);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'gluNurbsProperty'.",&tolua_err);
return 0;
#endif
}
void draw_solid(const k3d::gl::render_state& State, const k3d::double_t Height, const k3d::double_t Radius, const k3d::double_t SweepAngle)
{
if(!Radius)
return;
k3d::mesh::knots_t knots;
k3d::mesh::weights_t weights;
k3d::mesh::points_t arc_points;
k3d::nurbs_curve::circular_arc(k3d::vector3(1, 0, 0), k3d::vector3(0, 1, 0), 0, SweepAngle, 4, knots, weights, arc_points);
std::vector<GLfloat> gl_u_knot_vector(knots.begin(), knots.end());
std::vector<GLfloat> gl_v_knot_vector;
std::vector<GLfloat> gl_control_points;
gl_v_knot_vector.insert(gl_v_knot_vector.end(), 2, 0);
gl_v_knot_vector.insert(gl_v_knot_vector.end(), 1);
gl_v_knot_vector.insert(gl_v_knot_vector.end(), 2, 2);
const k3d::point3 offset = Height * k3d::point3(0, 0, 1);
for(k3d::uint_t i = 0; i <= 2; ++i)
{
const k3d::double_t radius2 = k3d::mix(Radius, 0.001 * Radius, static_cast<k3d::double_t>(i) / static_cast<k3d::double_t>(2));
for(k3d::uint_t j = 0; j != arc_points.size(); ++j)
{
gl_control_points.push_back(weights[j] * (radius2 * arc_points[j][0] + offset[0]));
gl_control_points.push_back(weights[j] * (radius2 * arc_points[j][1] + offset[1]));
gl_control_points.push_back(weights[j] * (radius2 * arc_points[j][2] + offset[2]));
gl_control_points.push_back(weights[j]);
}
}
GLUnurbsObj* const nurbs_renderer = gluNewNurbsRenderer();
// Important! We load our own matrices for efficiency (saves round-trips to the server) and to prevent problems with selection
gluNurbsProperty(nurbs_renderer, GLU_AUTO_LOAD_MATRIX, GL_FALSE);
gluNurbsProperty(nurbs_renderer, GLU_CULLING, GL_TRUE);
GLfloat gl_modelview_matrix[16];
glGetFloatv(GL_MODELVIEW_MATRIX, gl_modelview_matrix);
gluLoadSamplingMatrices(nurbs_renderer, gl_modelview_matrix, State.gl_projection_matrix, State.gl_viewport);
gluBeginSurface(nurbs_renderer);
gluNurbsSurface(nurbs_renderer, gl_u_knot_vector.size(), &gl_u_knot_vector[0], gl_v_knot_vector.size(), &gl_v_knot_vector[0], 4, 36, &gl_control_points[0], 3, 2, GL_MAP2_VERTEX_4);
gluEndSurface(nurbs_renderer);
gluDeleteNurbsRenderer(nurbs_renderer);
}
void init_scene(int width, int height)
{
int knot;
/* Setup our viewport for OpenGL ES */
glViewport(0, 0, (GLint)width, (GLint)height);
/* Setup our viewport for GLU ES (required when using OpenGL ES 1.0 only) */
gluViewport(0, 0, (GLint)width, (GLint)height);
/* setup a perspective projection */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustumf(-1.0f, 1.0f, -0.75f, 0.75f, 1.0f, 100.0f);
/* set the modelview matrix */
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* set point size for the cv rendering */
glPointSize(4.0f);
/* set the clear colour to black */
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
/* no lighting needed */
glDisable(GL_LIGHTING);
/* position the camera in the world */
glTranslatef(0.0f, 0.0f, -1.0f);
glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);
glRotatef(90.0f, 0.0f, 0.0f, 1.0f);
/* now, make the nurbs tesselator we are going to use */
mynurbs=gluNewNurbsRenderer();
/* these lines set how to tesselate the curve - */
/* simply by chopping it up into 100 line segments */
gluNurbsProperty(mynurbs, GLU_SAMPLING_METHOD, GLU_DOMAIN_DISTANCE);
gluNurbsProperty(mynurbs, GLU_U_STEP, 100);
gluNurbsProperty(mynurbs, GLU_DISPLAY_MODE, GLU_FILL);
/* set up the knot vector - make it continuous */
for (knot=0; knot<numknots; knot++)
{
knots[knot]=knot;
}
}
void
menu(int value)
{
switch (value) {
case 0:
case 1:
showPoints = value;
break;
case 2:
gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL);
break;
case 3:
gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_OUTLINE_POLYGON);
break;
}
glutPostRedisplay();
}
void init(void){
glClearColor(0.0, 0.0, 0.0, 0.0);
spline=NURBS;
nc= gluNewNurbsRenderer();
gluNurbsProperty(nc, GLU_SAMPLING_TOLERANCE, 5.0);
glEnable(GL_MAP1_VERTEX_3);
display();
}
static void Init(void)
{
theNurbs = gluNewNurbsRenderer();
gluNurbsCallback(theNurbs, GLU_ERROR, ErrorCallback);
gluNurbsProperty(theNurbs, GLU_SAMPLING_TOLERANCE, 15.0);
gluNurbsProperty(theNurbs, GLU_DISPLAY_MODE, GLU_OUTLINE_PATCH);
expectedError = GLU_INVALID_ENUM;
gluNurbsProperty(theNurbs, ~0, 15.0);
expectedError = GLU_NURBS_ERROR13;
gluEndSurface(theNurbs);
expectedError = 0;
glColor3f(1.0, 1.0, 1.0);
}
void nurbsInit(void)
{
theNurbs = gluNewNurbsRenderer();
gluNurbsCallback(theNurbs, GLU_ERROR, ErrorCallback);
gluNurbsProperty(theNurbs,GLU_NURBS_MODE,GLU_NURBS_TESSELLATOR);
gluNurbsCallback(theNurbs,GLU_NURBS_BEGIN,beginCallback);
gluNurbsCallback(theNurbs,GLU_NURBS_END,endCallback);
gluNurbsCallback(theNurbs,GLU_NURBS_VERTEX,vertexCallback);
gluNurbsProperty(theNurbs, GLU_SAMPLING_TOLERANCE, 15.0);
gluNurbsProperty(theNurbs, GLU_DISPLAY_MODE, GLU_OUTLINE_PATCH);
expectedError = GLU_INVALID_ENUM;
gluNurbsProperty(theNurbs, ~0, 15.0);
expectedError = GLU_NURBS_ERROR13;
gluEndSurface(theNurbs);
expectedError = 0;
}
void draw_local()
{
int i,j;
GLfloat knots[8] = {0,1,2,3,4,5,6,7};
GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 100.0 };
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
theNurb = gluNewNurbsRenderer();
gluNurbsProperty(theNurb, GLU_SAMPLING_TOLERANCE, 25.0);
gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL);
gluNurbsCallback(theNurb, GLU_ERROR, (GLvoid (*)()) nurbsError);
gluBeginSurface(theNurb);
gluNurbsSurface(theNurb,
8, knots, 8, knots,
3*6, 3, &ctlpoints[0][0][0],
2, 2, GL_MAP2_VERTEX_3);
gluEndSurface(theNurb);
if (showPoints) {
glPointSize(5.0);
glDisable(GL_LIGHTING);
glColor3f(1.0, 1.0, 0.0);
glBegin(GL_POINTS);
for (i=0; i<6; i++) {
for (j=0; j<6; j++) {
glVertex3f(ctlpoints[i][j][0],
ctlpoints[i][j][1],
ctlpoints[i][j][2]);
}
}
glEnd();
glEnable(GL_LIGHTING);
}
gluDeleteNurbsRenderer(theNurb);
}
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
theNurb = gluNewNurbsRenderer();
gluNurbsProperty (theNurb, GLU_SAMPLING_TOLERANCE, 10.0);
gluNurbsCallback(theNurb, GLU_ERROR, (GLvoid (*)()) nurbsError);
setup();
}
void init(void) {
GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 100.0 };
GLfloat light_position[] = { 1.0, 1.0, 8.0, 1.0};
GLfloat light_ambient[] = { 0.2, 0.2, 0.2, 1.0};
glClearColor (0.0, 0.0, 0.0, 1.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
gera_superficie();
nc= gluNewNurbsRenderer();
gluNurbsProperty(nc, GLU_SAMPLING_TOLERANCE, 5.0);
gluNurbsProperty(nc, GLU_DISPLAY_MODE, GLU_FILL);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef (0.0, 0.0, -5.0);
spline=NURBS;
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_SMOOTH);
glEnable(GL_MAP2_VERTEX_3);
display();
}
static void
Menu(int value)
{
switch (value) {
case 1:
trimming ^= 1; break;
case 2:
filled ^= 1;
gluNurbsProperty(nurbsflag, GLU_DISPLAY_MODE,
filled ? GLU_FILL : GLU_OUTLINE_POLYGON);
break;
case 3:
hull ^= 1; break;
case 4:
exit(0); break;
default:
break;
}
}
