void
delete_splinearrow(F_spline *spline, F_point *prev_point, F_point *selected_point)
{
if (closed_spline(spline))
return;
if (prev_point == NULL) { /* selected_point is the first point */
if (!spline->back_arrow)
return;
draw_spline(spline, ERASE);
saved_back_arrow=spline->back_arrow;
if (saved_for_arrow && saved_for_arrow != spline->for_arrow)
free((char *) saved_for_arrow);
saved_for_arrow = NULL;
spline->back_arrow = NULL;
redisplay_spline(spline);
} else if (selected_point->next == NULL) { /* forward arrow */
if (!spline->for_arrow)
return;
draw_spline(spline, ERASE);
saved_for_arrow=spline->for_arrow;
if (saved_back_arrow && saved_back_arrow != spline->back_arrow)
free((char *) saved_back_arrow);
saved_back_arrow = NULL;
spline->for_arrow = NULL;
redisplay_spline(spline);
} else
return;
clean_up();
set_last_prevpoint(prev_point);
set_last_selectedpoint(selected_point);
set_latestspline(spline);
set_action_object(F_DELETE_ARROW_HEAD, O_SPLINE);
set_modifiedflag();
}
//------------------------------------------------------------------------------
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
GLfloat LightAmbient[] = { 0.4f, 0.4f, 0.4f, 1.0f};
GLfloat LightDiffuse[] = { 0.3f, 0.3f, 0.3f, 1.0f};
GLfloat LightSpecular[] = { 0.4f, 0.4f, 0.4f, 1.0f};
GLfloat LightPosition[] = { 5.0f, 5.0f, 5.0f, 1.0f};
glClearColor(0.0,0.0,0.0,0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmbient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDiffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, LightSpecular);
glLightfv(GL_LIGHT0, GL_POSITION, LightPosition);
glEnable(GL_LIGHT0);
glShadeModel(GL_SMOOTH);
draw_spline( CUBIC_SPLINE_CATMULLROM );
draw_spline( CUBIC_SPLINE_B );
draw_actor();
glutSwapBuffers();
}
//------------------------------------------------------------------------------
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
GLfloat LightAmbient[] = { 0.4f, 0.4f, 0.4f, 1.0f};
GLfloat LightDiffuse[] = { 0.3f, 0.3f, 0.3f, 1.0f};
GLfloat LightSpecular[] = { 0.4f, 0.4f, 0.4f, 1.0f};
GLfloat LightPosition[] = { 5.0f, 5.0f, 5.0f, 1.0f};
//glClearColor(0.0,0.0,0.0,0.0);
glClearColor( 0.25, 0.25, 0.25, 0.0 );
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmbient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDiffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, LightSpecular);
glLightfv(GL_LIGHT0, GL_POSITION, LightPosition);
glEnable(GL_LIGHT0);
glShadeModel(GL_SMOOTH);
draw_spline( CUBIC_SPLINE_CATMULLROM );
draw_spline( CUBIC_SPLINE_B );
if( DRAW_ACTOR )
draw_actor();
glutSwapBuffers();
if( GENERATE_MOVIE ) {
std::string ssplinebasis;
switch( SPLINE_BASIS ) {
case CATMULL_ROM:
ssplinebasis = "crom";
break;
case B_SPLINE:
default:
ssplinebasis = "bspl";
break;
}
std::string srotfun;
switch( ROTFUN ) {
case ROTFUN_EULERANGLES:
srotfun = "euler";
break;
case ROTFUN_QUATERNION:
default:
srotfun = "quat";
break;
}
sprintf( filename, "%s_%s_%s_%.04d.tif",filetitle.c_str(), ssplinebasis.c_str(), srotfun.c_str(), frame_id );
printf( "%s\n", filename );
writetiff( filename, "movie", 0, 0, Width, Height, COMPRESSION_NONE );
}
}
/* draws the spline paths */
int draw_splines(int move_selected)
{
int io;
nodes[0] = dummy_node(nodes[node_count+1], nodes[node_count]);//node et previous
for (io=1; io<node_count; io++)
{
nodes[io].x=(dock_move_xy[move_selected][io][0]+xmover_window+20);
nodes[io].y=(dock_move_xy[move_selected][io][1]+ymover_window+20);
}
for (io=1; io<node_count-1; io++)
{
draw_spline(nodes[io], nodes[io+1]);
}
// goback to begin
draw_spline(nodes[node_count], nodes[1]);
return(0);
}
void
my_display (void)
{
// Clear all pixels, reset depth.
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearColor (0.0,0.0,0.0,1.0);
gluLookAt (0,0,1, 0,0,-1, 0, 1, 0);
// Draw spline.
draw_spline ();
glutSwapBuffers ();
}
void undo_open_close(void)
{
switch (last_object) {
case O_POLYLINE:
if (saved_objects.lines->type == T_POLYGON) {
saved_objects.lines->for_arrow = last_for_arrow;
saved_objects.lines->back_arrow = last_back_arrow;
last_for_arrow = last_back_arrow = NULL;
}
toggle_polyline_polygon(saved_objects.lines, last_prev_point,
last_selected_point);
break;
case O_SPLINE:
if (saved_objects.splines->type == T_OPEN_XSPLINE) {
F_sfactor *c_tmp;
draw_spline(saved_objects.splines, ERASE);
saved_objects.splines->sfactors->s = last_origin_tension;
for (c_tmp=saved_objects.splines->sfactors ; c_tmp->next != NULL ;
c_tmp=c_tmp->next)
;
c_tmp->s = last_extremity_tension;
saved_objects.splines->type = T_CLOSED_XSPLINE;
draw_spline(saved_objects.splines, PAINT);
} else {
if (closed_spline(saved_objects.splines)) {
saved_objects.splines->for_arrow = last_for_arrow;
saved_objects.splines->back_arrow = last_back_arrow;
last_for_arrow = last_back_arrow = NULL;
}
toggle_open_closed_spline(saved_objects.splines, last_prev_point,
last_selected_point);
}
break;
}
}
void
splinepoint_deleting(F_spline *spline, F_point *previous_point, F_point *selected_point)
{
F_point *next_point;
F_sfactor *s_prev_point, *selected_sfactor;
next_point = selected_point->next;
set_temp_cursor(wait_cursor);
clean_up();
set_last_prevpoint(previous_point);
/* delete it and redraw underlying objects */
list_delete_spline(&objects.splines, spline);
draw_spline(spline, ERASE);
redisplay_spline(spline);
if (previous_point == NULL) {
spline->points = next_point;
if (open_spline(spline)) {
selected_sfactor = spline->sfactors->next;
spline->sfactors->next = selected_sfactor->next;
} else {
selected_sfactor = spline->sfactors;
spline->sfactors = spline->sfactors->next;
}
} else {
previous_point->next = next_point;
if ((next_point == NULL) && (open_spline(spline)))
previous_point = prev_point(spline->points, previous_point);
s_prev_point = search_sfactor(spline,previous_point);
selected_sfactor = s_prev_point->next;
s_prev_point->next = s_prev_point->next->next;
}
/* put it back in the list and draw the new spline */
list_add_spline(&objects.splines, spline);
/* redraw it and anything on top of it */
redisplay_spline(spline);
set_action_object(F_DELETE_POINT, O_SPLINE);
set_latestspline(spline);
set_last_selectedpoint(selected_point);
set_last_selectedsfactor(selected_sfactor);
set_last_nextpoint(next_point);
set_modifiedflag();
reset_cursor();
}
static void
init_flipspline(F_spline *old_s, int px, int py)
{
F_spline *new_s;
new_s = copy_spline(old_s);
flip_spline(new_s, px, py, flip_axis);
if (copy) {
add_spline(new_s);
} else {
toggle_splinemarker(old_s);
draw_spline(old_s, ERASE);
change_spline(old_s, new_s);
}
/* redisplay objects under this object before it was rotated */
redisplay_spline(old_s);
/* and this object and any other objects on top */
redisplay_spline(new_s);
}
/* draws the spline paths */
void draw_splines(void)
{
int i;
acquire_screen();
clear_to_color(screen, makecol(255, 255, 255));
textout_centre_ex(screen, font, "Spline curve path", SCREEN_W/2, 8,
palette_color[255], palette_color[0]);
textprintf_centre_ex(screen, font, SCREEN_W/2, 32, palette_color[255],
palette_color[0], "Curviness = %.2f",
fixtof(curviness));
textout_centre_ex(screen, font, "Up/down keys to alter", SCREEN_W/2, 44,
palette_color[255], palette_color[0]);
textout_centre_ex(screen, font, "Space to walk", SCREEN_W/2, 68,
palette_color[255], palette_color[0]);
textout_centre_ex(screen, font, "C to display control points", SCREEN_W/2,
92, palette_color[255], palette_color[0]);
textout_centre_ex(screen, font, "T to display tangents", SCREEN_W/2, 104,
palette_color[255], palette_color[0]);
for (i=1; i<node_count-2; i++)
draw_spline(nodes[i], nodes[i+1]);
for (i=1; i<node_count-1; i++) {
draw_node(i);
if (show_tangents) {
line(screen, nodes[i].x - fixtoi(fixcos(nodes[i].tangent) * 24),
nodes[i].y - fixtoi(fixsin(nodes[i].tangent) * 24),
nodes[i].x + fixtoi(fixcos(nodes[i].tangent) * 24),
nodes[i].y + fixtoi(fixsin(nodes[i].tangent) * 24),
palette_color[1]);
}
}
release_screen();
}
void
toggle_open_closed_spline(F_spline *spline, F_point *previous_point, F_point *selected_point)
{
F_point *last_pt;
F_sfactor *last_sfactor, *previous_sfactor, *selected_sfactor;
if (spline->points->next == NULL || spline->points->next->next == NULL) {
put_msg("Not enough points for a spline");
beep();
return; /* less than 3 points - don't close the spline */
}
last_pt = last_point(spline->points);
last_sfactor = search_sfactor(spline, last_pt);
if (previous_point == NULL)
{
previous_sfactor = NULL;
selected_sfactor = spline->sfactors;
}
else
{
previous_sfactor = search_sfactor(spline, previous_point);
selected_sfactor = previous_sfactor->next;
set_last_tension(selected_sfactor->s, previous_sfactor->s);
}
draw_spline(spline, ERASE);
if (closed_spline(spline))
{
if (spline->points != selected_point)
{
last_pt->next = spline->points;
last_sfactor->next = spline->sfactors;
previous_point->next = NULL;
previous_sfactor->next = NULL;
previous_sfactor->s = S_SPLINE_ANGULAR;
spline->points = selected_point;
spline->sfactors = selected_sfactor;
}
else
{
last_sfactor->s = S_SPLINE_ANGULAR;
}
spline->sfactors->s = S_SPLINE_ANGULAR;
spline->type = (x_spline(spline)) ? T_OPEN_XSPLINE :
(int_spline(spline)) ? T_OPEN_INTERP : T_OPEN_APPROX;
clean_up();
}
else
{
int type_tmp;
double s_tmp;
if(int_spline(spline))
{
s_tmp = S_SPLINE_INTERP;
type_tmp = T_CLOSED_INTERP;
}
else
if (x_spline(spline))
{
s_tmp = S_SPLINE_INTERP;
type_tmp = T_CLOSED_XSPLINE;
}
else
{
s_tmp = S_SPLINE_APPROX;
type_tmp = T_CLOSED_APPROX;
}
spline->sfactors->s = last_sfactor->s = s_tmp;
spline->type = type_tmp;
clean_up();
set_last_arrows(spline->for_arrow, spline->back_arrow);
spline->back_arrow = spline->for_arrow = NULL;
}
draw_spline(spline, PAINT);
set_action_object(F_OPEN_CLOSE, O_SPLINE);
set_last_selectedpoint(spline->points);
set_last_prevpoint(NULL);
set_latestspline(spline);
set_modifiedflag();
}
