/* nurb:LoadSamplingMatrices (modelArray, perspectiveArray, viewArray) -> nurb */ static int luaglu_load_sampling_matrices(lua_State *L) { LuaGLUnurb *lnurb=luaglu_checknurb(L,1); GLfloat modelMatrix[16]; GLfloat projMatrix[16]; GLint viewport[4]; luaglu_load_matrix16f(L, 2, modelMatrix); luaglu_load_matrix16f(L, 3, projMatrix); luaglu_load_viewport(L, 4, viewport); gluLoadSamplingMatrices(lnurb->nurb,modelMatrix,projMatrix,viewport); lua_pushvalue(L,1); return 1; }
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); }
static int tolua_glu_gluLoadSamplingMatrices00(lua_State* tolua_S) { #ifndef TOLUA_RELEASE tolua_Error tolua_err; if ( !tolua_isusertype(tolua_S,1,"GLUnurbsObj",0,&tolua_err) || !tolua_istable(tolua_S,2,0,&tolua_err) || !tolua_istable(tolua_S,3,0,&tolua_err) || !tolua_istable(tolua_S,4,0,&tolua_err) || !tolua_isnoobj(tolua_S,5,&tolua_err) ) goto tolua_lerror; else #endif { GLUnurbsObj* nobj = ((GLUnurbsObj*) tolua_tousertype(tolua_S,1,0)); float modelMatrix[16]; float projMatrix[16]; int viewport[4]; { #ifndef TOLUA_RELEASE if (!tolua_isnumberarray(tolua_S,2,16,0,&tolua_err)) goto tolua_lerror; else #endif { int i; for(i=0; i<16;i++) modelMatrix[i] = ((float) tolua_tofieldnumber(tolua_S,2,i+1,0)); } } { #ifndef TOLUA_RELEASE if (!tolua_isnumberarray(tolua_S,3,16,0,&tolua_err)) goto tolua_lerror; else #endif { int i; for(i=0; i<16;i++) projMatrix[i] = ((float) tolua_tofieldnumber(tolua_S,3,i+1,0)); } } { #ifndef TOLUA_RELEASE if (!tolua_isnumberarray(tolua_S,4,4,0,&tolua_err)) goto tolua_lerror; else #endif { int i; for(i=0; i<4;i++) viewport[i] = ((int) tolua_tofieldnumber(tolua_S,4,i+1,0)); } } { gluLoadSamplingMatrices(nobj,modelMatrix,projMatrix,viewport); } { int i; for(i=0; i<16;i++) tolua_pushfieldnumber(tolua_S,2,i+1,(lua_Number) modelMatrix[i]); } { int i; for(i=0; i<16;i++) tolua_pushfieldnumber(tolua_S,3,i+1,(lua_Number) projMatrix[i]); } { int i; for(i=0; i<4;i++) tolua_pushfieldnumber(tolua_S,4,i+1,(lua_Number) viewport[i]); } } return 0; #ifndef TOLUA_RELEASE tolua_lerror: tolua_error(tolua_S,"#ferror in function 'gluLoadSamplingMatrices'.",&tolua_err); return 0; #endif }
void draw_solid(const k3d::gl::render_state& State, const k3d::double_t Radius, const k3d::double_t ZMin, const k3d::double_t ZMax, const k3d::double_t SweepAngle) { if(!Radius) return; const k3d::double_t zmin = ZMin; const k3d::double_t zmax = ZMax; const k3d::double_t thetamax = SweepAngle; const k3d::double_t phimin = (zmin > -1) ? asin(zmin) : -k3d::pi_over_2(); const k3d::double_t phimax = (zmax < 1) ? asin(zmax) : k3d::pi_over_2(); k3d::mesh::knots_t v_knots; k3d::mesh::weights_t v_weights; k3d::mesh::points_t v_arc_points; k3d::nurbs_curve::circular_arc(k3d::vector3(0, 1, 0), k3d::vector3(0, 0, 1), phimin, phimax, 2, v_knots, v_weights, v_arc_points); k3d::mesh::knots_t u_knots; k3d::mesh::weights_t u_weights; k3d::mesh::points_t u_arc_points; k3d::nurbs_curve::circular_arc(k3d::vector3(1, 0, 0), k3d::vector3(0, 1, 0), 0, thetamax, 4, u_knots, u_weights, u_arc_points); std::vector<GLfloat> gl_u_knot_vector(u_knots.begin(), u_knots.end()); std::vector<GLfloat> gl_v_knot_vector(v_knots.begin(), v_knots.end()); std::vector<GLfloat> gl_control_points; for(k3d::uint_t v = 0; v != v_arc_points.size(); ++v) { const k3d::point3 offset = v_arc_points[v][2] * k3d::point3(0, 0, 1); const k3d::double_t radius2 = v_arc_points[v][1]; const k3d::double_t v_weight = v_weights[v]; for(k3d::uint_t u = 0; u != u_arc_points.size(); ++u) { gl_control_points.push_back(v_weight * u_weights[u] * (radius2 * u_arc_points[u][0] + offset[0])); gl_control_points.push_back(v_weight * u_weights[u] * (radius2 * u_arc_points[u][1] + offset[1])); gl_control_points.push_back(v_weight * u_weights[u] * (radius2 * u_arc_points[u][2] + offset[2])); gl_control_points.push_back(v_weight * u_weights[u]); } } glPushMatrix(); k3d::gl::push_matrix(k3d::scale3(Radius)); 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, 3, GL_MAP2_VERTEX_4); gluEndSurface(nurbs_renderer); gluDeleteNurbsRenderer(nurbs_renderer); glPopMatrix(); }