/* 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();
}
