void mouse_drag(int mouse_x, int mouse_y)
{
using namespace igl;
using namespace std;
using namespace Eigen;
bool tw_using = TwMouseMotion(mouse_x,mouse_y);
if(is_rotating)
{
glutSetCursor(GLUT_CURSOR_CYCLE);
Quaterniond q;
auto & camera = s.camera;
switch(rotation_type)
{
case ROTATION_TYPE_IGL_TRACKBALL:
{
// Rotate according to trackball
igl::trackball<double>(
width,
height,
2.0,
down_camera.m_rotation_conj.coeffs().data(),
down_x,
down_y,
mouse_x,
mouse_y,
q.coeffs().data());
break;
}
case ROTATION_TYPE_TWO_AXIS_VALUATOR_FIXED_UP:
{
// Rotate according to two axis valuator with fixed up vector
two_axis_valuator_fixed_up(
width, height,
2.0,
down_camera.m_rotation_conj,
down_x, down_y, mouse_x, mouse_y,
q);
break;
}
default:
break;
}
switch(center_type)
{
default:
case CENTER_TYPE_ORBIT:
camera.orbit(q.conjugate());
break;
case CENTER_TYPE_FPS:
camera.turn_eye(q.conjugate());
break;
}
}
}
/*! Get the position of the location relative to its body in
* the J2000 ecliptic coordinate system.
*/
Vector3d Location::getPlanetocentricPosition(double t) const
{
if (parent == NULL)
{
return position.cast<double>();
}
else
{
Quaterniond q = parent->getEclipticToBodyFixed(t);
return q.conjugate() * position.cast<double>();
}
}
void mouse_drag(int mouse_x, int mouse_y)
{
using namespace igl;
using namespace Eigen;
if(is_rotating)
{
glutSetCursor(GLUT_CURSOR_CYCLE);
Quaterniond q;
auto & camera = s.camera;
switch(rotation_type)
{
case ROTATION_TYPE_IGL_TRACKBALL:
{
// Rotate according to trackball
igl::trackball<double>(
width,
height,
2.0,
down_camera.m_rotation_conj.coeffs().data(),
down_x,
down_y,
mouse_x,
mouse_y,
q.coeffs().data());
break;
}
case ROTATION_TYPE_TWO_AXIS_VALUATOR_FIXED_UP:
{
// Rotate according to two axis valuator with fixed up vector
two_axis_valuator_fixed_up(
width, height,
2.0,
down_camera.m_rotation_conj,
down_x, down_y, mouse_x, mouse_y,
q);
break;
}
default:
break;
}
camera.orbit(q.conjugate());
}else
{
TwEventMouseMotionGLUT(mouse_x, mouse_y);
}
glutPostRedisplay();
}
static void longLatLabel(const string& labelText,
double longitude,
double latitude,
const Vector3d& viewRayOrigin,
const Vector3d& viewNormal,
const Vector3d& bodyCenter,
const Quaterniond& bodyOrientation,
const Vector3f& semiAxes,
float labelOffset,
Renderer* renderer)
{
double theta = degToRad(longitude);
double phi = degToRad(latitude);
Vector3d pos(cos(phi) * cos(theta) * semiAxes.x(),
sin(phi) * semiAxes.y(),
-cos(phi) * sin(theta) * semiAxes.z());
float nearDist = renderer->getNearPlaneDistance();
pos = pos * (1.0 + labelOffset);
double boundingRadius = semiAxes.maxCoeff();
// Draw the label only if it isn't obscured by the body ellipsoid
double t = 0.0;
if (testIntersection(Ray3d(viewRayOrigin, pos - viewRayOrigin), Ellipsoidd(semiAxes.cast<double>()), t) && t >= 1.0)
{
// Compute the position of the label
Vector3d labelPos = bodyCenter +
bodyOrientation.conjugate() * pos * (1.0 + labelOffset);
// Calculate the intersection of the eye-to-label ray with the plane perpendicular to
// the view normal that touches the front of the objects bounding sphere
double planetZ = viewNormal.dot(bodyCenter) - boundingRadius;
if (planetZ < -nearDist * 1.001)
planetZ = -nearDist * 1.001;
double z = viewNormal.dot(labelPos);
labelPos *= planetZ / z;
renderer->addObjectAnnotation(NULL, labelText,
Renderer::PlanetographicGridLabelColor,
labelPos.cast<float>());
}
}
void key(unsigned char key, int mouse_x, int mouse_y)
{
using namespace std;
using namespace igl;
using namespace Eigen;
int mod = glutGetModifiers();
const bool command_down = GLUT_ACTIVE_COMMAND & mod;
const bool shift_down = GLUT_ACTIVE_SHIFT & mod;
switch(key)
{
// ESC
case char(27):
rebar.save(REBAR_NAME);
// ^C
case char(3):
exit(0);
case 'z':
case 'Z':
if(command_down)
{
if(shift_down)
{
redo();
}else
{
undo();
}
break;
}else
{
push_undo();
Quaterniond q;
snap_to_canonical_view_quat(s.camera.m_rotation_conj,1.0,q);
s.camera.orbit(q.conjugate());
}
default:
if(!TwEventKeyboardGLUT(key,mouse_x,mouse_y))
{
cout<<"Unknown key command: "<<key<<" "<<int(key)<<endl;
}
}
}
void display()
{
using namespace Eigen;
using namespace igl;
using namespace std;
glClearColor(back[0],back[1],back[2],0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(is_animating)
{
double t = (get_seconds() - animation_start_time)/ANIMATION_DURATION;
if(t > 1)
{
t = 1;
is_animating = false;
}
const Quaterniond q = animation_from_quat.slerp(t,animation_to_quat).normalized();
s.camera.orbit(q.conjugate());
}
glDisable(GL_LIGHTING);
lights();
push_scene();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_NORMALIZE);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
push_object();
// Draw the model
// Set material properties
glEnable(GL_COLOR_MATERIAL);
const auto draw = [](
const MatrixXd & V,
const MatrixXi & F,
const MatrixXd & N,
const MatrixXd & C)
{
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_POLYGON_OFFSET_FILL); // Avoid Stitching!
glPolygonOffset(1.0,1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
draw_mesh(V,F,N,C);
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glDisable(GL_COLOR_MATERIAL);
const float black[4] = {0,0,0,1};
glColor4fv(black);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, black);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, black);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, black);
glLightfv(GL_LIGHT0, GL_AMBIENT, black);
glLightfv(GL_LIGHT0, GL_DIFFUSE, black);
glLineWidth(1.0);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
draw_mesh(V,F,N,C);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_COLOR_MATERIAL);
};
if(show_A)
{
draw(V,F,N,C);
}
if(show_B)
{
draw(U,G,W,D);
}
pop_object();
// Draw a nice floor
glPushMatrix();
const double floor_offset =
-2./bbd*(VU.col(1).maxCoeff()-mid(1));
glTranslated(0,floor_offset,0);
const float GREY[4] = {0.5,0.5,0.6,1.0};
const float DARK_GREY[4] = {0.2,0.2,0.3,1.0};
draw_floor(GREY,DARK_GREY);
glPopMatrix();
pop_scene();
report_gl_error();
TwDraw();
glutSwapBuffers();
if(is_animating)
{
glutPostRedisplay();
}
}
void key(unsigned char key, int mouse_x, int mouse_y)
{
using namespace std;
using namespace Eigen;
using namespace igl;
int mod = glutGetModifiers();
switch(key)
{
// ESC
case char(27):
rebar.save(REBAR_NAME);
// ^C
case char(3):
exit(0);
case 'I':
case 'i':
{
push_undo();
s.N *= -1.0;
F = F.rowwise().reverse().eval();
break;
}
case 'z':
case 'Z':
if(mod & GLUT_ACTIVE_COMMAND)
{
if(mod & GLUT_ACTIVE_SHIFT)
{
redo();
}else
{
undo();
}
}else
{
push_undo();
Quaterniond q;
snap_to_canonical_view_quat(s.camera.m_rotation_conj,1.0,q);
switch(center_type)
{
default:
case CENTER_TYPE_ORBIT:
s.camera.orbit(q.conjugate());
break;
case CENTER_TYPE_FPS:
s.camera.turn_eye(q.conjugate());
break;
}
}
break;
case 'u':
mouse_wheel(0, 1,mouse_x,mouse_y);
break;
case 'j':
mouse_wheel(0,-1,mouse_x,mouse_y);
break;
case 'n':
cc_selected = (cc_selected + 1) % (CC.maxCoeff() + 2);
cout << "selected cc: " << cc_selected << endl;
glutPostRedisplay();
break;
default:
if(!TwEventKeyboardGLUT(key,mouse_x,mouse_y))
{
cout<<"Unknown key command: "<<key<<" "<<int(key)<<endl;
}
}
}
void display()
{
using namespace igl;
using namespace std;
using namespace Eigen;
glClearColor(1,1,1,0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(is_animating)
{
double t = (get_seconds() - animation_start_time)/ANIMATION_DURATION;
if(t > 1)
{
t = 1;
is_animating = false;
}
Quaterniond q = animation_from_quat.slerp(t,animation_to_quat).normalized();
auto & camera = s.camera;
switch(center_type)
{
default:
case CENTER_TYPE_ORBIT:
camera.orbit(q.conjugate());
break;
case CENTER_TYPE_FPS:
camera.turn_eye(q.conjugate());
break;
}
}
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
lights();
push_scene();
push_object();
// Set material properties
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
if(wireframe_visible)
{
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
if(fill_visible)
{
glColor3f(0,0,0);
draw_mesh(V,F,s.N);
}else
{
draw_mesh(V,F,s.N,s.C);
}
// visualize selected patch
glLineWidth(10);
glBegin(GL_TRIANGLES);
glColor3d(0, 0, 0);
// loop over faces
for(int i = 0; i<F.rows();i++)
{
if (CC(i) != cc_selected) continue;
// loop over corners of triangle
for(int j = 0;j<3;j++)
{
glVertex3d(V(F(i,j),0),V(F(i,j),1),V(F(i,j),2));
}
}
glEnd();
glLineWidth(1);
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
glBegin(GL_TRIANGLES);
glColor3d(1, 0, 0);
// loop over faces
for(int i = 0; i<F.rows();i++)
{
if (CC(i) != cc_selected) continue;
// loop over corners of triangle
glNormal3d(s.N(i,0),s.N(i,1),s.N(i,2));
for(int j = 0;j<3;j++)
{
glVertex3d(V(F(i,j),0),V(F(i,j),1),V(F(i,j),2));
}
}
glEnd();
}
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
if(fill_visible)
{
glEnable(GL_POLYGON_OFFSET_FILL); // Avoid Stitching!
glPolygonOffset(1.0, 0);
draw_mesh(V,F,s.N,s.C);
}
pop_object();
// Draw a nice floor
glPushMatrix();
const double floor_offset =
-2./bbd*(V.col(1).maxCoeff()-Vmid(1));
glTranslated(0,floor_offset,0);
const float GREY[4] = {0.5,0.5,0.6,1.0};
const float DARK_GREY[4] = {0.2,0.2,0.3,1.0};
draw_floor(GREY,DARK_GREY);
glPopMatrix();
pop_scene();
report_gl_error();
TwDraw();
glutSwapBuffers();
glutPostRedisplay();
}
void display()
{
using namespace Eigen;
using namespace igl;
using namespace std;
// Update
update_arap();
glClearColor(back[0],back[1],back[2],0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(is_animating)
{
double t = (get_seconds() - animation_start_time)/ANIMATION_DURATION;
if(t > 1)
{
t = 1;
is_animating = false;
}
const Quaterniond q = animation_from_quat.slerp(t,animation_to_quat).normalized();
s.camera.orbit(q.conjugate());
}
glDisable(GL_LIGHTING);
lights();
push_scene();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_NORMALIZE);
push_object();
// Draw the model
// Set material properties
//glDisable(GL_COLOR_MATERIAL);
//glMaterialfv(GL_FRONT, GL_AMBIENT, GOLD_AMBIENT);
//glMaterialfv(GL_FRONT, GL_DIFFUSE, GOLD_DIFFUSE );
//glMaterialfv(GL_FRONT, GL_SPECULAR, GOLD_SPECULAR);
//glMaterialf (GL_FRONT, GL_SHININESS, 128);
//glMaterialfv(GL_BACK, GL_AMBIENT, SILVER_AMBIENT);
//glMaterialfv(GL_BACK, GL_DIFFUSE, FAST_GREEN_DIFFUSE );
//glMaterialfv(GL_BACK, GL_SPECULAR, SILVER_SPECULAR);
//glMaterialf (GL_BACK, GL_SHININESS, 128);
glEnable(GL_COLOR_MATERIAL);
draw_mesh(U,F,N,C);
glDisable(GL_COLOR_MATERIAL);
pop_object();
// Draw a nice floor
glPushMatrix();
const double floor_offset =
-2./bbd*(V.col(1).maxCoeff()-mid(1));
glTranslated(0,floor_offset,0);
//const float GREY[4] = {0.5,0.5,0.6,1.0};
//const float DARK_GREY[4] = {0.2,0.2,0.3,1.0};
//draw_floor(GREY,DARK_GREY);
draw_floor();
glPopMatrix();
pop_scene();
report_gl_error();
TwDraw();
glutSwapBuffers();
//if(is_animating)
//{
glutPostRedisplay();
//}
}
void key(unsigned char key, int mouse_x, int mouse_y)
{
using namespace std;
using namespace igl;
using namespace Eigen;
int mod = glutGetModifiers();
const bool command_down = GLUT_ACTIVE_COMMAND & mod;
const bool shift_down = GLUT_ACTIVE_SHIFT & mod;
switch(key)
{
// ESC
case char(27):
rebar.save(REBAR_NAME);
// ^C
case char(3):
exit(0);
case char(127):
{
push_undo();
// delete
MatrixXi new_BE(s.BE.rows(),s.BE.cols());
int count = 0;
for(int b=0;b<s.BE.rows();b++)
{
bool selected = false;
for(int si=0;si<s.sel.size();si++)
{
if(s.BE(b,0) == s.sel(si) || s.BE(b,1) == s.sel(si))
{
selected = true;
break;
}
}
if(!selected)
{
new_BE.row(count) = s.BE.row(b);
count++;
}
}
new_BE.conservativeResize(count,new_BE.cols());
const auto old_C = s.C;
VectorXi I;
remove_unreferenced(old_C,new_BE,s.C,s.BE,I);
s.sel.resize(0,1);
break;
}
case 'A':
case 'a':
{
push_undo();
s.sel = colon<int>(0,s.C.rows()-1);
break;
}
case 'C':
case 'c':
{
push_undo();
// snap close vertices
SparseMatrix<double> A;
adjacency_matrix(s.BE,A);
VectorXi J = colon<int>(0,s.C.rows()-1);
// stupid O(n²) version
for(int c = 0;c<s.C.rows();c++)
{
for(int d = c+1;d<s.C.rows();d++)
{
if(
A.coeff(c,d) == 0 && // no edge
(s.C.row(c)-s.C.row(d)).norm() < 0.02*bbd //close
)
{
// c < d
J(d) = c;
}
}
}
for(int e = 0;e<s.BE.rows();e++)
{
s.BE(e,0) = J(s.BE(e,0));
s.BE(e,1) = J(s.BE(e,1));
}
const auto old_BE = s.BE;
const auto old_C = s.C;
VectorXi I;
remove_unreferenced(old_C,old_BE,s.C,s.BE,I);
for(int i = 0;i<s.sel.size();i++)
{
s.sel(i) = J(s.sel(i));
}
VectorXi _;
igl::unique(s.sel,s.sel,_,_);
break;
}
case 'D':
case 'd':
{
push_undo();
s.sel.resize(0,1);
break;
}
case 'P':
case 'p':
{
// add bone to parents (should really only be one)
push_undo();
vector<int> new_sel;
const int old_nbe = s.BE.rows();
for(int si=0;si<s.sel.size();si++)
{
for(int b=0;b<old_nbe;b++)
{
if(s.BE(b,1) == s.sel(si))
{
// one new node
s.C.conservativeResize(s.C.rows()+1,3);
const int nc = s.C.rows();
s.C.row(nc-1) = 0.5*(s.C.row(s.BE(b,1)) + s.C.row(s.BE(b,0)));
// one new bone
s.BE.conservativeResize(s.BE.rows()+1,2);
s.BE.row(s.BE.rows()-1) = RowVector2i(nc-1,s.BE(b,1));
s.BE(b,1) = nc-1;
// select last node
new_sel.push_back(nc-1);
}
}
}
list_to_matrix(new_sel,s.sel);
break;
}
case 'R':
case 'r':
{
// re-root try at first selected
if(s.sel.size() > 0)
{
push_undo();
// only use first
s.sel.conservativeResize(1,1);
// Ideally this should only effect the connected component of s.sel(0)
const auto & C = s.C;
auto & BE = s.BE;
vector<bool> seen(C.rows(),false);
// adjacency list
vector<vector< int> > A;
adjacency_list(BE,A,false);
int e = 0;
queue<int> Q;
Q.push(s.sel(0));
seen[s.sel(0)] = true;
while(!Q.empty())
{
const int c = Q.front();
Q.pop();
for(const auto & d : A[c])
{
if(!seen[d])
{
BE(e,0) = c;
BE(e,1) = d;
e++;
Q.push(d);
seen[d] = true;
}
}
}
// only keep tree
BE.conservativeResize(e,BE.cols());
}
break;
}
case 'S':
case 's':
{
save();
break;
}
case 'U':
case 'u':
{
push_scene();
push_object();
for(int c = 0;c<s.C.rows();c++)
{
Vector3d P = project((Vector3d)s.C.row(c));
Vector3d obj;
int nhits = unproject_in_mesh(P(0),P(1),ei,obj);
if(nhits > 0)
{
s.C.row(c) = obj;
}
}
pop_object();
pop_scene();
break;
}
case 'Y':
case 'y':
{
symmetrize();
break;
}
case 'z':
case 'Z':
is_rotating = false;
is_dragging = false;
if(command_down)
{
if(shift_down)
{
redo();
}else
{
undo();
}
break;
}else
{
push_undo();
Quaterniond q;
snap_to_canonical_view_quat(camera.m_rotation_conj,1.0,q);
camera.orbit(q.conjugate());
}
break;
default:
if(!TwEventKeyboardGLUT(key,mouse_x,mouse_y))
{
cout<<"Unknown key command: "<<key<<" "<<int(key)<<endl;
}
}
glutPostRedisplay();
}
void mouse_drag(int mouse_x, int mouse_y)
{
using namespace igl;
using namespace std;
using namespace Eigen;
if(is_rotating)
{
glutSetCursor(GLUT_CURSOR_CYCLE);
Quaterniond q;
switch(rotation_type)
{
case ROTATION_TYPE_IGL_TRACKBALL:
{
// Rotate according to trackball
igl::trackball<double>(
width,
height,
2.0,
down_camera.m_rotation_conj.coeffs().data(),
down_x,
down_y,
mouse_x,
mouse_y,
q.coeffs().data());
break;
}
case ROTATION_TYPE_TWO_AXIS_VALUATOR_FIXED_UP:
{
// Rotate according to two axis valuator with fixed up vector
two_axis_valuator_fixed_up(
width, height,
2.0,
down_camera.m_rotation_conj,
down_x, down_y, mouse_x, mouse_y,
q);
break;
}
default:
break;
}
camera.orbit(q.conjugate());
}
if(is_dragging)
{
push_scene();
push_object();
if(new_leaf_on_drag)
{
assert(s.C.size() >= 1);
// one new node
s.C.conservativeResize(s.C.rows()+1,3);
const int nc = s.C.rows();
assert(s.sel.size() >= 1);
s.C.row(nc-1) = s.C.row(s.sel(0));
// one new bone
s.BE.conservativeResize(s.BE.rows()+1,2);
s.BE.row(s.BE.rows()-1) = RowVector2i(s.sel(0),nc-1);
// select just last node
s.sel.resize(1,1);
s.sel(0) = nc-1;
// reset down_C
down_C = s.C;
new_leaf_on_drag = false;
}
if(new_root_on_drag)
{
// two new nodes
s.C.conservativeResize(s.C.rows()+2,3);
const int nc = s.C.rows();
Vector3d obj;
int nhits = unproject_in_mesh(mouse_x,height-mouse_y,ei,obj);
if(nhits == 0)
{
Vector3d pV_mid = project(Vcen);
obj = unproject(Vector3d(mouse_x,height-mouse_y,pV_mid(2)));
}
s.C.row(nc-2) = obj;
s.C.row(nc-1) = obj;
// select last node
s.sel.resize(1,1);
s.sel(0) = nc-1;
// one new bone
s.BE.conservativeResize(s.BE.rows()+1,2);
s.BE.row(s.BE.rows()-1) = RowVector2i(nc-2,nc-1);
// reset down_C
down_C = s.C;
new_root_on_drag = false;
}
double z = 0;
Vector3d obj,win;
int nhits = unproject_in_mesh(mouse_x,height-mouse_y,ei,obj);
project(obj,win);
z = win(2);
for(int si = 0;si<s.sel.size();si++)
{
const int c = s.sel(si);
Vector3d pc = project((RowVector3d) down_C.row(c));
pc(0) += mouse_x-down_x;
pc(1) += (height-mouse_y)-(height-down_y);
if(nhits > 0)
{
pc(2) = z;
}
s.C.row(c) = unproject(pc);
}
pop_object();
pop_scene();
}
glutPostRedisplay();
}
void display()
{
using namespace igl;
using namespace std;
using namespace Eigen;
const float back[4] = {0.75, 0.75, 0.75,0};
glClearColor(back[0],back[1],back[2],0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
static bool first = true;
if(first)
{
sort();
first = false;
}
if(is_animating)
{
double t = (get_seconds() - animation_start_time)/ANIMATION_DURATION;
if(t > 1)
{
t = 1;
is_animating = false;
}
Quaterniond q = animation_from_quat.slerp(t,animation_to_quat).normalized();
camera.orbit(q.conjugate());
}
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_NORMALIZE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
lights();
push_scene();
// Draw a nice floor
glEnable(GL_DEPTH_TEST);
glPushMatrix();
const double floor_offset =
-2./bbd*(V.col(1).maxCoeff()-Vmid(1));
glTranslated(0,floor_offset,0);
const float GREY[4] = {0.5,0.5,0.6,1.0};
const float DARK_GREY[4] = {0.2,0.2,0.3,1.0};
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
draw_floor(GREY,DARK_GREY);
glDisable(GL_CULL_FACE);
glPopMatrix();
push_object();
const auto & draw_skeleton = []()
{
switch(skel_style)
{
default:
case SKEL_STYLE_TYPE_3D:
{
MatrixXf colors = MAYA_VIOLET.transpose().replicate(s.BE.rows(),1);
for(int si=0;si<s.sel.size();si++)
{
for(int b=0;b<s.BE.rows();b++)
{
if(s.BE(b,0) == s.sel(si) || s.BE(b,1) == s.sel(si))
{
colors.row(b) = MAYA_SEA_GREEN;
}
}
}
draw_skeleton_3d(s.C,s.BE,MatrixXd(),colors);
break;
}
case SKEL_STYLE_TYPE_VECTOR_GRAPHICS:
draw_skeleton_vector_graphics(s.C,s.BE);
break;
}
};
if(!skeleton_on_top)
{
draw_skeleton();
}
// Set material properties
glDisable(GL_COLOR_MATERIAL);
glMaterialfv(GL_FRONT, GL_AMBIENT,
Vector4f(GOLD_AMBIENT[0],GOLD_AMBIENT[1],GOLD_AMBIENT[2],alpha).data());
glMaterialfv(GL_FRONT, GL_DIFFUSE,
Vector4f(GOLD_DIFFUSE[0],GOLD_DIFFUSE[1],GOLD_DIFFUSE[2],alpha).data());
glMaterialfv(GL_FRONT, GL_SPECULAR,
Vector4f(GOLD_SPECULAR[0],GOLD_SPECULAR[1],GOLD_SPECULAR[2],alpha).data());
glMaterialf (GL_FRONT, GL_SHININESS, 128);
glMaterialfv(GL_BACK, GL_AMBIENT,
Vector4f(SILVER_AMBIENT[0],SILVER_AMBIENT[1],SILVER_AMBIENT[2],alpha).data());
glMaterialfv(GL_BACK, GL_DIFFUSE,
Vector4f(FAST_GREEN_DIFFUSE[0],FAST_GREEN_DIFFUSE[1],FAST_GREEN_DIFFUSE[2],alpha).data());
glMaterialfv(GL_BACK, GL_SPECULAR,
Vector4f(SILVER_SPECULAR[0],SILVER_SPECULAR[1],SILVER_SPECULAR[2],alpha).data());
glMaterialf (GL_BACK, GL_SHININESS, 128);
if(wireframe)
{
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
}
glLineWidth(1.0);
draw_mesh(V,sorted_F,sorted_N);
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
if(skeleton_on_top)
{
glDisable(GL_DEPTH_TEST);
draw_skeleton();
}
pop_object();
pop_scene();
report_gl_error();
TwDraw();
glutSwapBuffers();
if(is_animating)
{
glutPostRedisplay();
}
}
void display()
{
using namespace igl;
using namespace std;
using namespace Eigen;
const float back[4] = {30.0/255.0,30.0/255.0,50.0/255.0,0};
glClearColor(back[0],back[1],back[2],0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(is_animating)
{
double t = (get_seconds() - animation_start_time)/ANIMATION_DURATION;
if(t > 1)
{
t = 1;
is_animating = false;
}
Quaterniond q = animation_from_quat.slerp(t,animation_to_quat).normalized();
auto & camera = s.camera;
camera.orbit(q.conjugate());
}
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
lights();
push_scene();
// Draw a nice floor
glEnable(GL_DEPTH_TEST);
glPushMatrix();
const double floor_offset =
-2./bbd*(V.col(1).maxCoeff()-Vmid(1));
glTranslated(0,floor_offset,0);
const float GREY[4] = {0.5,0.5,0.6,1.0};
const float DARK_GREY[4] = {0.2,0.2,0.3,1.0};
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
draw_floor(GREY,DARK_GREY);
glPopMatrix();
push_object();
// Set material properties
glDisable(GL_COLOR_MATERIAL);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, SILVER_AMBIENT);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, SILVER_DIFFUSE );
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, SILVER_SPECULAR);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, 128);
typedef std::vector<
Eigen::Quaterniond,Eigen::aligned_allocator<Eigen::Quaterniond> >
RotationList;
RotationList dQ(BE.rows(),Quaterniond::Identity()),vQ;
vector<Vector3d> vT;
Matrix3d A = Matrix3d::Identity();
for(int e = 0;e<BE.rows();e++)
{
dQ[e] = AngleAxisd((sin(get_seconds()+e))*0.06*PI,A.col(e%3));
}
forward_kinematics(C,BE,P,dQ,vQ,vT);
const int dim = C.cols();
MatrixXd T(BE.rows()*(dim+1),dim);
for(int e = 0;e<BE.rows();e++)
{
Affine3d a = Affine3d::Identity();
a.translate(vT[e]);
a.rotate(vQ[e]);
T.block(e*(dim+1),0,dim+1,dim) =
a.matrix().transpose().block(0,0,dim+1,dim);
}
if(wireframe)
{
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
}
glLineWidth(1.0);
MatrixXd U = M*T;
per_face_normals(U,F,N);
draw_mesh(U,F,N);
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
if(skeleton_on_top)
{
glDisable(GL_DEPTH_TEST);
}
switch(skel_style)
{
default:
case SKEL_STYLE_TYPE_3D:
draw_skeleton_3d(C,BE,T,MAYA_VIOLET,bbd*0.5);
break;
case SKEL_STYLE_TYPE_VECTOR_GRAPHICS:
draw_skeleton_vector_graphics(C,BE,T);
break;
}
pop_object();
pop_scene();
report_gl_error();
TwDraw();
glutSwapBuffers();
glutPostRedisplay();
}
void display()
{
using namespace Eigen;
using namespace igl;
using namespace std;
glClearColor(back[0],back[1],back[2],0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(is_animating)
{
double t = (get_seconds() - animation_start_time)/ANIMATION_DURATION;
if(t > 1)
{
t = 1;
is_animating = false;
}
const Quaterniond q = animation_from_quat.slerp(t,animation_to_quat).normalized();
s.camera.orbit(q.conjugate());
}
glDisable(GL_LIGHTING);
lights();
push_scene();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_NORMALIZE);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
push_object();
// Draw the model
// Set material properties
glEnable(GL_COLOR_MATERIAL);
glColor3f(1,1,1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,tex_id);
MatrixXd _d;
MatrixXi _i;
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadIdentity();
if(flip_y)
{
glTranslated(0,1,0);
glScaled(1,-1,1);
}
if(rotate_xy)
{
glRotated(90,0,0,1);
glTranslated(-1,0,0);
}
glMatrixMode(GL_MODELVIEW);
igl::opengl2::draw_mesh(V,F,N,MatrixXi(),MatrixXd(),TC,TF,MatrixXd(),0,MatrixXi(),0);
glMatrixMode(GL_TEXTURE);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
pop_object();
// Draw a nice floor
glPushMatrix();
const double floor_offset =
-2./bbd*(V.col(1).maxCoeff()-mid(1));
glTranslated(0,floor_offset,0);
const float GREY[4] = {0.5,0.5,0.6,1.0};
const float DARK_GREY[4] = {0.2,0.2,0.3,1.0};
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(-1,1);
glBegin(GL_QUADS);
glNormal3d(0,1,0);
glTexCoord2d(0,1);
glVertex3d(-1,0,1);
glTexCoord2d(1,1);
glVertex3d(1,0,1);
glTexCoord2d(1,0);
glVertex3d(1,0,-1);
glTexCoord2d(0,0);
glVertex3d(-1,0,-1);
glEnd();
glDisable(GL_POLYGON_OFFSET_FILL);
glDisable(GL_TEXTURE_2D);
igl::opengl2::draw_floor(GREY,DARK_GREY);
glPopMatrix();
pop_scene();
igl::opengl::report_gl_error();
TwDraw();
glutSwapBuffers();
if(is_animating)
{
glutPostRedisplay();
}
}