source/blender/editors/space_view3d/drawarmature.c

   1 /**
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) 2005 by the Blender Foundation.
  21  * All rights reserved.
  22  *
  23  * The Original Code is: all of this file.
  24  *
  25  * Contributor(s): none yet.
  26  *
  27  * ***** END GPL LICENSE BLOCK *****
  28  */
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <math.h>
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include <config.h>
  36 #endif
  37
  38 #include "MEM_guardedalloc.h"
  39
  40 #include "BMF_Api.h"
  41
  42 #include "DNA_action_types.h"
  43 #include "DNA_armature_types.h"
  44 #include "DNA_constraint_types.h"
  45 #include "DNA_ID.h"
  46 #include "DNA_nla_types.h"
  47 #include "DNA_object_types.h"
  48 #include "DNA_scene_types.h"
  49 #include "DNA_screen_types.h"
  50 #include "DNA_space_types.h"
  51 #include "DNA_view3d_types.h"
  52 #include "DNA_userdef_types.h"
  53
  54 #include "BLI_blenlib.h"
  55 #include "BLI_arithb.h"
  56
  57 #include "BKE_action.h"
  58 #include "BKE_armature.h"
  59 #include "BKE_constraint.h"
  60 #include "BKE_context.h"
  61 #include "BKE_depsgraph.h"
  62 #include "BKE_DerivedMesh.h"
  63 #include "BKE_global.h"
  64 #include "BKE_main.h"
  65 #include "BKE_modifier.h"
  66 #include "BKE_object.h"
  67 #include "BKE_utildefines.h"
  68
  69 #include "BIF_gl.h"
  70 #include "BIF_glutil.h"
  71
  72 #include "ED_armature.h"
  73 #include "ED_keyframes_draw.h"
  74
  75 #include "WM_api.h"
  76 #include "WM_types.h"
  77
  78 #include "UI_resources.h"
  79
  80 #include "view3d_intern.h"
  81
  82
  83 /* *************** Armature Drawing - Coloring API ***************************** */
  84
  85 /* global here is reset before drawing each bone */
  86 static ThemeWireColor *bcolor= NULL;
  87
  88 /* values of colCode for set_pchan_glcolor */
  89 enum {
  90         PCHAN_COLOR_NORMAL      = 0,            /* normal drawing */
  91         PCHAN_COLOR_SOLID,                              /* specific case where "solid" color is needed */
  92         PCHAN_COLOR_CONSTS,                             /* "constraint" colors (which may/may-not be suppressed) */
  93
  94         PCHAN_COLOR_SPHEREBONE_BASE,    /* for the 'stick' of sphere (envelope) bones */
  95         PCHAN_COLOR_SPHEREBONE_END,             /* for the ends of sphere (envelope) bones */
  96         PCHAN_COLOR_LINEBONE                    /* for the middle of line-bones */
  97 };
  98
  99 /* This function sets the color-set for coloring a certain bone */
 100 static void set_pchan_colorset (Object *ob, bPoseChannel *pchan)
 101 {
 102         bPose *pose= (ob) ? ob->pose : NULL;
 103         bArmature *arm= (ob) ? ob->data : NULL;
 104         bActionGroup *grp= NULL;
 105         short color_index= 0;
 106
 107         /* sanity check */
 108         if (ELEM4(NULL, ob, arm, pose, pchan)) {
 109                 bcolor= NULL;
 110                 return;
 111         }
 112
 113         /* only try to set custom color if enabled for armature */
 114         if (arm->flag & ARM_COL_CUSTOM) {
 115                 /* currently, a bone can only use a custom color set if it's group (if it has one),
 116                  * has been set to use one
 117                  */
 118                 if (pchan->agrp_index) {
 119                         grp= (bActionGroup *)BLI_findlink(&pose->agroups, (pchan->agrp_index - 1));
 120                         if (grp)
 121                                 color_index= grp->customCol;
 122                 }
 123         }
 124
 125         /* bcolor is a pointer to the color set to use. If NULL, then the default
 126          * color set (based on the theme colors for 3d-view) is used.
 127          */
 128         if (color_index > 0) {
 129                 bTheme *btheme= U.themes.first;
 130                 bcolor= &btheme->tarm[(color_index - 1)];
 131         }
 132         else if (color_index == -1) {
 133                 /* use the group's own custom color set */
 134                 bcolor= (grp)? &grp->cs : NULL;
 135         }
 136         else
 137                 bcolor= NULL;
 138 }
 139
 140 /* This function is for brightening/darkening a given color (like UI_ThemeColorShade()) */
 141 static void cp_shade_color3ub (char cp[], int offset)
 142 {
 143         int r, g, b;
 144
 145         r= offset + (int) cp[0];
 146         CLAMP(r, 0, 255);
 147         g= offset + (int) cp[1];
 148         CLAMP(g, 0, 255);
 149         b= offset + (int) cp[2];
 150         CLAMP(b, 0, 255);
 151
 152         cp[0]= r;
 153         cp[1]= g;
 154         cp[2]= b;
 155 }
 156
 157 /* This function sets the gl-color for coloring a certain bone (based on bcolor) */
 158 static short set_pchan_glColor (short colCode, int armflag, int boneflag, int constflag)
 159 {
 160         switch (colCode) {
 161         case PCHAN_COLOR_NORMAL:
 162         {
 163                 if (bcolor) {
 164                         char cp[3];
 165
 166                         if (boneflag & BONE_ACTIVE) {
 167                                 VECCOPY(cp, bcolor->active);
 168                         }
 169                         else if (boneflag & BONE_SELECTED) {
 170                                 VECCOPY(cp, bcolor->select);
 171                         }
 172                         else {
 173                                 /* a bit darker than solid */
 174                                 VECCOPY(cp, bcolor->solid);
 175                                 cp_shade_color3ub(cp, -50);
 176                         }
 177
 178                         glColor3ub(cp[0], cp[1], cp[2]);
 179                 }
 180                 else {
 181                         if (boneflag & BONE_ACTIVE) UI_ThemeColorShade(TH_BONE_POSE, 40);
 182                         else if (boneflag & BONE_SELECTED) UI_ThemeColor(TH_BONE_POSE);
 183                         else UI_ThemeColor(TH_WIRE);
 184                 }
 185
 186                 return 1;
 187         }
 188                 break;
 189
 190         case PCHAN_COLOR_SOLID:
 191         {
 192                 if (bcolor) {
 193                         char *cp= bcolor->solid;
 194                         glColor3ub(cp[0], cp[1], cp[2]);
 195                 }
 196                 else
 197                         UI_ThemeColor(TH_BONE_SOLID);
 198
 199                 return 1;
 200         }
 201                 break;
 202
 203         case PCHAN_COLOR_CONSTS:
 204         {
 205                 if ( (bcolor == NULL) || (bcolor->flag & TH_WIRECOLOR_CONSTCOLS) ) {
 206                         if (constflag & PCHAN_HAS_STRIDE) glColor4ub(0, 0, 200, 80);
 207                         else if (constflag & PCHAN_HAS_TARGET) glColor4ub(255, 150, 0, 80);
 208                         else if (constflag & PCHAN_HAS_IK) glColor4ub(255, 255, 0, 80);
 209                         else if (constflag & PCHAN_HAS_CONST) glColor4ub(0, 255, 120, 80);
 210                         else if (constflag) UI_ThemeColor4(TH_BONE_POSE);       // PCHAN_HAS_ACTION
 211
 212                         return 1;
 213                 }
 214                 else
 215                         return 0;
 216         }
 217                 break;
 218
 219         case PCHAN_COLOR_SPHEREBONE_BASE:
 220         {
 221                 if (bcolor) {
 222                         char cp[3];
 223
 224                         if (boneflag & BONE_ACTIVE) {
 225                                 VECCOPY(cp, bcolor->active);
 226                         }
 227                         else if (boneflag & BONE_SELECTED) {
 228                                 VECCOPY(cp, bcolor->select);
 229                         }
 230                         else {
 231                                 VECCOPY(cp, bcolor->solid);
 232                         }
 233
 234                         glColor3ub(cp[0], cp[1], cp[2]);
 235                 }
 236                 else {
 237                         if (boneflag & BONE_ACTIVE) UI_ThemeColorShade(TH_BONE_POSE, 40);
 238                         else if (boneflag & BONE_SELECTED) UI_ThemeColor(TH_BONE_POSE);
 239                         else UI_ThemeColor(TH_BONE_SOLID);
 240                 }
 241
 242                 return 1;
 243         }
 244                 break;
 245         case PCHAN_COLOR_SPHEREBONE_END:
 246         {
 247                 if (bcolor) {
 248                         char cp[3];
 249
 250                         if (boneflag & BONE_ACTIVE) {
 251                                 VECCOPY(cp, bcolor->active);
 252                                 cp_shade_color3ub(cp, 10);
 253                         }
 254                         else if (boneflag & BONE_SELECTED) {
 255                                 VECCOPY(cp, bcolor->select);
 256                                 cp_shade_color3ub(cp, -30);
 257                         }
 258                         else {
 259                                 VECCOPY(cp, bcolor->solid);
 260                                 cp_shade_color3ub(cp, -30);
 261                         }
 262
 263                         glColor3ub(cp[0], cp[1], cp[2]);
 264                 }
 265                 else {
 266                         if (boneflag & BONE_ACTIVE) UI_ThemeColorShade(TH_BONE_POSE, 10);
 267                         else if (boneflag & BONE_SELECTED) UI_ThemeColorShade(TH_BONE_POSE, -30);
 268                         else UI_ThemeColorShade(TH_BONE_SOLID, -30);
 269                 }
 270         }
 271                 break;
 272
 273         case PCHAN_COLOR_LINEBONE:
 274         {
 275                 /* inner part in background color or constraint */
 276                 if ( (constflag) && ((bcolor==NULL) || (bcolor->flag & TH_WIRECOLOR_CONSTCOLS)) ) {
 277                         if (constflag & PCHAN_HAS_STRIDE) glColor3ub(0, 0, 200);
 278                         else if (constflag & PCHAN_HAS_TARGET) glColor3ub(255, 150, 0);
 279                         else if (constflag & PCHAN_HAS_IK) glColor3ub(255, 255, 0);
 280                         else if (constflag & PCHAN_HAS_CONST) glColor3ub(0, 255, 120);
 281                         else if (constflag) UI_ThemeColor(TH_BONE_POSE);        /* PCHAN_HAS_ACTION */
 282                 }
 283                 else {
 284                         if (bcolor) {
 285                                 char *cp= bcolor->solid;
 286                                 glColor4ub(cp[0], cp[1], cp[2], 204);
 287                         }
 288                         else
 289                                 UI_ThemeColorShade(TH_BACK, -30);
 290                 }
 291
 292                 return 1;
 293         }
 294                 break;
 295         }
 296
 297         return 0;
 298 }
 299
 300
 301 /* *************** Armature drawing, helper calls for parts ******************* */
 302
 303 /* half the cube, in Y */
 304 static float cube[8][3] = {
 305 {-1.0,  0.0, -1.0},
 306 {-1.0,  0.0,  1.0},
 307 {-1.0,  1.0,  1.0},
 308 {-1.0,  1.0, -1.0},
 309 { 1.0,  0.0, -1.0},
 310 { 1.0,  0.0,  1.0},
 311 { 1.0,  1.0,  1.0},
 312 { 1.0,  1.0, -1.0},
 313 };
 314
 315 static void drawsolidcube_size(float xsize, float ysize, float zsize)
 316 {
 317         static GLuint displist=0;
 318         float n[3];
 319
 320         glScalef(xsize, ysize, zsize);
 321
 322         n[0]=0; n[1]=0; n[2]=0;
 323
 324         if(displist==0) {
 325                 displist= glGenLists(1);
 326                 glNewList(displist, GL_COMPILE_AND_EXECUTE);
 327
 328                 glBegin(GL_QUADS);
 329                 n[0]= -1.0;
 330                 glNormal3fv(n);
 331                 glVertex3fv(cube[0]); glVertex3fv(cube[1]); glVertex3fv(cube[2]); glVertex3fv(cube[3]);
 332                 n[0]=0;
 333                 n[1]= -1.0;
 334                 glNormal3fv(n);
 335                 glVertex3fv(cube[0]); glVertex3fv(cube[4]); glVertex3fv(cube[5]); glVertex3fv(cube[1]);
 336                 n[1]=0;
 337                 n[0]= 1.0;
 338                 glNormal3fv(n);
 339                 glVertex3fv(cube[4]); glVertex3fv(cube[7]); glVertex3fv(cube[6]); glVertex3fv(cube[5]);
 340                 n[0]=0;
 341                 n[1]= 1.0;
 342                 glNormal3fv(n);
 343                 glVertex3fv(cube[7]); glVertex3fv(cube[3]); glVertex3fv(cube[2]); glVertex3fv(cube[6]);
 344                 n[1]=0;
 345                 n[2]= 1.0;
 346                 glNormal3fv(n);
 347                 glVertex3fv(cube[1]); glVertex3fv(cube[5]); glVertex3fv(cube[6]); glVertex3fv(cube[2]);
 348                 n[2]=0;
 349                 n[2]= -1.0;
 350                 glNormal3fv(n);
 351                 glVertex3fv(cube[7]); glVertex3fv(cube[4]); glVertex3fv(cube[0]); glVertex3fv(cube[3]);
 352                 glEnd();
 353
 354                 glEndList();
 355         }
 356         else glCallList(displist);
 357
 358 }
 359
 360 static void drawcube_size(float xsize, float ysize, float zsize)
 361 {
 362         static GLuint displist=0;
 363
 364         glScalef(xsize, ysize, zsize);
 365
 366         if(displist == 0) {
 367                 displist= glGenLists(1);
 368                 glNewList(displist, GL_COMPILE_AND_EXECUTE);
 369
 370                 glBegin(GL_LINE_STRIP);
 371                 glVertex3fv(cube[0]); glVertex3fv(cube[1]);glVertex3fv(cube[2]); glVertex3fv(cube[3]);
 372                 glVertex3fv(cube[0]); glVertex3fv(cube[4]);glVertex3fv(cube[5]); glVertex3fv(cube[6]);
 373                 glVertex3fv(cube[7]); glVertex3fv(cube[4]);
 374                 glEnd();
 375
 376                 glBegin(GL_LINES);
 377                 glVertex3fv(cube[1]); glVertex3fv(cube[5]);
 378                 glVertex3fv(cube[2]); glVertex3fv(cube[6]);
 379                 glVertex3fv(cube[3]); glVertex3fv(cube[7]);
 380                 glEnd();
 381
 382                 glEndList();
 383         }
 384         else glCallList(displist);
 385
 386 }
 387
 388
 389 static void draw_bonevert(void)
 390 {
 391         static GLuint displist=0;
 392
 393         if (displist == 0) {
 394                 GLUquadricObj   *qobj;
 395
 396                 displist= glGenLists(1);
 397                 glNewList(displist, GL_COMPILE_AND_EXECUTE);
 398
 399                 glPushMatrix();
 400
 401                 qobj    = gluNewQuadric();
 402                 gluQuadricDrawStyle(qobj, GLU_SILHOUETTE);
 403                 gluDisk(qobj, 0.0,  0.05, 16, 1);
 404
 405                 glRotatef(90, 0, 1, 0);
 406                 gluDisk(qobj, 0.0,  0.05, 16, 1);
 407
 408                 glRotatef(90, 1, 0, 0);
 409                 gluDisk(qobj, 0.0,  0.05, 16, 1);
 410
 411                 gluDeleteQuadric(qobj);
 412
 413                 glPopMatrix();
 414                 glEndList();
 415         }
 416         else
 417                 glCallList(displist);
 418 }
 419
 420 static void draw_bonevert_solid(void)
 421 {
 422         static GLuint displist=0;
 423
 424         if (displist == 0) {
 425                 GLUquadricObj   *qobj;
 426
 427                 displist= glGenLists(1);
 428                 glNewList(displist, GL_COMPILE_AND_EXECUTE);
 429
 430                 qobj    = gluNewQuadric();
 431                 gluQuadricDrawStyle(qobj, GLU_FILL);
 432                 glShadeModel(GL_SMOOTH);
 433                 gluSphere(qobj, 0.05, 8, 5);
 434                 glShadeModel(GL_FLAT);
 435                 gluDeleteQuadric(qobj);
 436
 437                 glEndList();
 438         }
 439         else
 440                 glCallList(displist);
 441 }
 442
 443 static void draw_bone_octahedral()
 444 {
 445         static GLuint displist=0;
 446
 447         if (displist == 0) {
 448                 float vec[6][3];
 449
 450                 displist= glGenLists(1);
 451                 glNewList(displist, GL_COMPILE_AND_EXECUTE);
 452
 453                 vec[0][0]= vec[0][1]= vec[0][2]= 0.0f;
 454                 vec[5][0]= vec[5][2]= 0.0f; vec[5][1]= 1.0f;
 455
 456                 vec[1][0]= 0.1f; vec[1][2]= 0.1f; vec[1][1]= 0.1f;
 457                 vec[2][0]= 0.1f; vec[2][2]= -0.1f; vec[2][1]= 0.1f;
 458                 vec[3][0]= -0.1f; vec[3][2]= -0.1f; vec[3][1]= 0.1f;
 459                 vec[4][0]= -0.1f; vec[4][2]= 0.1f; vec[4][1]= 0.1f;
 460
 461                 /*      Section 1, sides */
 462                 glBegin(GL_LINE_LOOP);
 463                 glVertex3fv(vec[0]);
 464                 glVertex3fv(vec[1]);
 465                 glVertex3fv(vec[5]);
 466                 glVertex3fv(vec[3]);
 467                 glVertex3fv(vec[0]);
 468                 glVertex3fv(vec[4]);
 469                 glVertex3fv(vec[5]);
 470                 glVertex3fv(vec[2]);
 471                 glEnd();
 472
 473                 /*      Section 1, square */
 474                 glBegin(GL_LINE_LOOP);
 475                 glVertex3fv(vec[1]);
 476                 glVertex3fv(vec[2]);
 477                 glVertex3fv(vec[3]);
 478                 glVertex3fv(vec[4]);
 479                 glEnd();
 480
 481                 glEndList();
 482         }
 483         else
 484                 glCallList(displist);
 485 }
 486
 487 static void draw_bone_solid_octahedral(void)
 488 {
 489         static GLuint displist=0;
 490
 491         if (displist == 0) {
 492                 float vec[6][3], nor[3];
 493
 494                 displist= glGenLists(1);
 495                 glNewList(displist, GL_COMPILE_AND_EXECUTE);
 496
 497                 vec[0][0]= vec[0][1]= vec[0][2]= 0.0f;
 498                 vec[5][0]= vec[5][2]= 0.0f; vec[5][1]= 1.0f;
 499
 500                 vec[1][0]= 0.1f; vec[1][2]= 0.1f; vec[1][1]= 0.1f;
 501                 vec[2][0]= 0.1f; vec[2][2]= -0.1f; vec[2][1]= 0.1f;
 502                 vec[3][0]= -0.1f; vec[3][2]= -0.1f; vec[3][1]= 0.1f;
 503                 vec[4][0]= -0.1f; vec[4][2]= 0.1f; vec[4][1]= 0.1f;
 504
 505
 506                 glBegin(GL_TRIANGLES);
 507                 /* bottom */
 508                 CalcNormFloat(vec[2], vec[1], vec[0], nor);
 509                 glNormal3fv(nor);
 510                 glVertex3fv(vec[2]); glVertex3fv(vec[1]); glVertex3fv(vec[0]);
 511
 512                 CalcNormFloat(vec[3], vec[2], vec[0], nor);
 513                 glNormal3fv(nor);
 514                 glVertex3fv(vec[3]); glVertex3fv(vec[2]); glVertex3fv(vec[0]);
 515
 516                 CalcNormFloat(vec[4], vec[3], vec[0], nor);
 517                 glNormal3fv(nor);
 518                 glVertex3fv(vec[4]); glVertex3fv(vec[3]); glVertex3fv(vec[0]);
 519
 520                 CalcNormFloat(vec[1], vec[4], vec[0], nor);
 521                 glNormal3fv(nor);
 522                 glVertex3fv(vec[1]); glVertex3fv(vec[4]); glVertex3fv(vec[0]);
 523
 524                 /* top */
 525                 CalcNormFloat(vec[5], vec[1], vec[2], nor);
 526                 glNormal3fv(nor);
 527                 glVertex3fv(vec[5]); glVertex3fv(vec[1]); glVertex3fv(vec[2]);
 528
 529                 CalcNormFloat(vec[5], vec[2], vec[3], nor);
 530                 glNormal3fv(nor);
 531                 glVertex3fv(vec[5]); glVertex3fv(vec[2]); glVertex3fv(vec[3]);
 532
 533                 CalcNormFloat(vec[5], vec[3], vec[4], nor);
 534                 glNormal3fv(nor);
 535                 glVertex3fv(vec[5]); glVertex3fv(vec[3]); glVertex3fv(vec[4]);
 536
 537                 CalcNormFloat(vec[5], vec[4], vec[1], nor);
 538                 glNormal3fv(nor);
 539                 glVertex3fv(vec[5]); glVertex3fv(vec[4]); glVertex3fv(vec[1]);
 540
 541                 glEnd();
 542
 543                 glEndList();
 544         }
 545         else
 546                 glCallList(displist);
 547 }
 548
 549 /* *************** Armature drawing, bones ******************* */
 550
 551
 552 static void draw_bone_points(int dt, int armflag, unsigned int boneflag, int id)
 553 {
 554         /*      Draw root point if we are not connected */
 555         if ((boneflag & BONE_CONNECTED)==0) {
 556                 if (id != -1)
 557                         glLoadName(id | BONESEL_ROOT);
 558
 559                 if(dt <= OB_WIRE) {
 560                         if (armflag & ARM_EDITMODE) {
 561                                 if (boneflag & BONE_ROOTSEL) UI_ThemeColor(TH_VERTEX_SELECT);
 562                                 else UI_ThemeColor(TH_VERTEX);
 563                         }
 564                 }
 565                 else {
 566                         if (armflag & ARM_POSEMODE)
 567                                 set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, 0);
 568                         else
 569                                 UI_ThemeColor(TH_BONE_SOLID);
 570                 }
 571
 572                 if (dt > OB_WIRE)
 573                         draw_bonevert_solid();
 574                 else
 575                         draw_bonevert();
 576         }
 577
 578         /*      Draw tip point */
 579         if (id != -1)
 580                 glLoadName(id | BONESEL_TIP);
 581
 582         if (dt <= OB_WIRE) {
 583                 if (armflag & ARM_EDITMODE) {
 584                         if (boneflag & BONE_TIPSEL) UI_ThemeColor(TH_VERTEX_SELECT);
 585                         else UI_ThemeColor(TH_VERTEX);
 586                 }
 587         }
 588         else {
 589                 if (armflag & ARM_POSEMODE)
 590                         set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, 0);
 591                 else
 592                         UI_ThemeColor(TH_BONE_SOLID);
 593         }
 594
 595         glTranslatef(0.0f, 1.0f, 0.0f);
 596         if (dt > OB_WIRE)
 597                 draw_bonevert_solid();
 598         else
 599                 draw_bonevert();
 600         glTranslatef(0.0f, -1.0f, 0.0f);
 601
 602 }
 603
 604 /* 16 values of sin function (still same result!) */
 605 static float si[16] = {
 606         0.00000000f,
 607         0.20129852f, 0.39435585f,
 608         0.57126821f, 0.72479278f,
 609         0.84864425f, 0.93775213f,
 610         0.98846832f, 0.99871650f,
 611         0.96807711f, 0.89780453f,
 612         0.79077573f, 0.65137248f,
 613         0.48530196f, 0.29936312f,
 614         0.10116832f
 615 };
 616 /* 16 values of cos function (still same result!) */
 617 static float co[16] ={
 618         1.00000000f,
 619         0.97952994f, 0.91895781f,
 620         0.82076344f, 0.68896691f,
 621         0.52896401f, 0.34730525f,
 622         0.15142777f, -0.05064916f,
 623         -0.25065253f, -0.44039415f,
 624         -0.61210598f, -0.75875812f,
 625         -0.87434661f, -0.95413925f,
 626         -0.99486932f
 627 };
 628
 629
 630
 631 /* smat, imat = mat & imat to draw screenaligned */
 632 static void draw_sphere_bone_dist(float smat[][4], float imat[][4], int boneflag, bPoseChannel *pchan, EditBone *ebone)
 633 {
 634         float head, tail, length, dist;
 635         float *headvec, *tailvec, dirvec[3];
 636
 637         /* figure out the sizes of spheres */
 638         if (ebone) {
 639                 /* this routine doesn't call set_matrix_editbone() that calculates it */
 640                 ebone->length = VecLenf(ebone->head, ebone->tail);
 641
 642                 length= ebone->length;
 643                 tail= ebone->rad_tail;
 644                 dist= ebone->dist;
 645                 if (ebone->parent && (ebone->flag & BONE_CONNECTED))
 646                         head= ebone->parent->rad_tail;
 647                 else
 648                         head= ebone->rad_head;
 649                 headvec= ebone->head;
 650                 tailvec= ebone->tail;
 651         }
 652         else {
 653                 length= pchan->bone->length;
 654                 tail= pchan->bone->rad_tail;
 655                 dist= pchan->bone->dist;
 656                 if (pchan->parent && (pchan->bone->flag & BONE_CONNECTED))
 657                         head= pchan->parent->bone->rad_tail;
 658                 else
 659                         head= pchan->bone->rad_head;
 660                 headvec= pchan->pose_head;
 661                 tailvec= pchan->pose_tail;
 662         }
 663
 664         /* ***** draw it ***** */
 665
 666         /* move vector to viewspace */
 667         VecSubf(dirvec, tailvec, headvec);
 668         Mat4Mul3Vecfl(smat, dirvec);
 669         /* clear zcomp */
 670         dirvec[2]= 0.0f;
 671         /* move vector back */
 672         Mat4Mul3Vecfl(imat, dirvec);
 673
 674         if (0.0f != Normalize(dirvec)) {
 675                 float norvec[3], vec1[3], vec2[3], vec[3];
 676                 int a;
 677
 678                 //VecMulf(dirvec, head);
 679                 Crossf(norvec, dirvec, imat[2]);
 680
 681                 glBegin(GL_QUAD_STRIP);
 682
 683                 for (a=0; a<16; a++) {
 684                         vec[0]= - *(si+a) * dirvec[0] + *(co+a) * norvec[0];
 685                         vec[1]= - *(si+a) * dirvec[1] + *(co+a) * norvec[1];
 686                         vec[2]= - *(si+a) * dirvec[2] + *(co+a) * norvec[2];
 687
 688                         vec1[0]= headvec[0] + head*vec[0];
 689                         vec1[1]= headvec[1] + head*vec[1];
 690                         vec1[2]= headvec[2] + head*vec[2];
 691                         vec2[0]= headvec[0] + (head+dist)*vec[0];
 692                         vec2[1]= headvec[1] + (head+dist)*vec[1];
 693                         vec2[2]= headvec[2] + (head+dist)*vec[2];
 694
 695                         glColor4ub(255, 255, 255, 50);
 696                         glVertex3fv(vec1);
 697                         //glColor4ub(255, 255, 255, 0);
 698                         glVertex3fv(vec2);
 699                 }
 700
 701                 for (a=15; a>=0; a--) {
 702                         vec[0]= *(si+a) * dirvec[0] + *(co+a) * norvec[0];
 703                         vec[1]= *(si+a) * dirvec[1] + *(co+a) * norvec[1];
 704                         vec[2]= *(si+a) * dirvec[2] + *(co+a) * norvec[2];
 705
 706                         vec1[0]= tailvec[0] + tail*vec[0];
 707                         vec1[1]= tailvec[1] + tail*vec[1];
 708                         vec1[2]= tailvec[2] + tail*vec[2];
 709                         vec2[0]= tailvec[0] + (tail+dist)*vec[0];
 710                         vec2[1]= tailvec[1] + (tail+dist)*vec[1];
 711                         vec2[2]= tailvec[2] + (tail+dist)*vec[2];
 712
 713                         //glColor4ub(255, 255, 255, 50);
 714                         glVertex3fv(vec1);
 715                         //glColor4ub(255, 255, 255, 0);
 716                         glVertex3fv(vec2);
 717                 }
 718                 /* make it cyclic... */
 719
 720                 vec[0]= - *(si) * dirvec[0] + *(co) * norvec[0];
 721                 vec[1]= - *(si) * dirvec[1] + *(co) * norvec[1];
 722                 vec[2]= - *(si) * dirvec[2] + *(co) * norvec[2];
 723
 724                 vec1[0]= headvec[0] + head*vec[0];
 725                 vec1[1]= headvec[1] + head*vec[1];
 726                 vec1[2]= headvec[2] + head*vec[2];
 727                 vec2[0]= headvec[0] + (head+dist)*vec[0];
 728                 vec2[1]= headvec[1] + (head+dist)*vec[1];
 729                 vec2[2]= headvec[2] + (head+dist)*vec[2];
 730
 731                 //glColor4ub(255, 255, 255, 50);
 732                 glVertex3fv(vec1);
 733                 //glColor4ub(255, 255, 255, 0);
 734                 glVertex3fv(vec2);
 735
 736                 glEnd();
 737         }
 738 }
 739
 740
 741 /* smat, imat = mat & imat to draw screenaligned */
 742 static void draw_sphere_bone_wire(float smat[][4], float imat[][4], int armflag, int boneflag, int constflag, unsigned int id, bPoseChannel *pchan, EditBone *ebone)
 743 {
 744         float head, tail, length;
 745         float *headvec, *tailvec, dirvec[3];
 746
 747         /* figure out the sizes of spheres */
 748         if (ebone) {
 749                 /* this routine doesn't call set_matrix_editbone() that calculates it */
 750                 ebone->length = VecLenf(ebone->head, ebone->tail);
 751
 752                 length= ebone->length;
 753                 tail= ebone->rad_tail;
 754                 if (ebone->parent && (boneflag & BONE_CONNECTED))
 755                         head= ebone->parent->rad_tail;
 756                 else
 757                         head= ebone->rad_head;
 758                 headvec= ebone->head;
 759                 tailvec= ebone->tail;
 760         }
 761         else {
 762                 length= pchan->bone->length;
 763                 tail= pchan->bone->rad_tail;
 764                 if ((pchan->parent) && (boneflag & BONE_CONNECTED))
 765                         head= pchan->parent->bone->rad_tail;
 766                 else
 767                         head= pchan->bone->rad_head;
 768                 headvec= pchan->pose_head;
 769                 tailvec= pchan->pose_tail;
 770         }
 771
 772         /* sphere root color */
 773         if (armflag & ARM_EDITMODE) {
 774                 if (boneflag & BONE_ROOTSEL) UI_ThemeColor(TH_VERTEX_SELECT);
 775                 else UI_ThemeColor(TH_VERTEX);
 776         }
 777         else if (armflag & ARM_POSEMODE)
 778                 set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
 779
 780         /*      Draw root point if we are not connected */
 781         if ((boneflag & BONE_CONNECTED)==0) {
 782                 if (id != -1)
 783                         glLoadName(id | BONESEL_ROOT);
 784
 785                 drawcircball(GL_LINE_LOOP, headvec, head, imat);
 786         }
 787
 788         /*      Draw tip point */
 789         if (armflag & ARM_EDITMODE) {
 790                 if (boneflag & BONE_TIPSEL) UI_ThemeColor(TH_VERTEX_SELECT);
 791                 else UI_ThemeColor(TH_VERTEX);
 792         }
 793
 794         if (id != -1)
 795                 glLoadName(id | BONESEL_TIP);
 796
 797         drawcircball(GL_LINE_LOOP, tailvec, tail, imat);
 798
 799         /* base */
 800         if (armflag & ARM_EDITMODE) {
 801                 if (boneflag & BONE_SELECTED) UI_ThemeColor(TH_SELECT);
 802                 else UI_ThemeColor(TH_WIRE);
 803         }
 804
 805         VecSubf(dirvec, tailvec, headvec);
 806
 807         /* move vector to viewspace */
 808         Mat4Mul3Vecfl(smat, dirvec);
 809         /* clear zcomp */
 810         dirvec[2]= 0.0f;
 811         /* move vector back */
 812         Mat4Mul3Vecfl(imat, dirvec);
 813
 814         if (0.0f != Normalize(dirvec)) {
 815                 float norvech[3], norvect[3], vec[3];
 816
 817                 VECCOPY(vec, dirvec);
 818
 819                 VecMulf(dirvec, head);
 820                 Crossf(norvech, dirvec, imat[2]);
 821
 822                 VecMulf(vec, tail);
 823                 Crossf(norvect, vec, imat[2]);
 824
 825                 if (id != -1)
 826                         glLoadName(id | BONESEL_BONE);
 827
 828                 glBegin(GL_LINES);
 829                 vec[0]= headvec[0] + norvech[0];
 830                 vec[1]= headvec[1] + norvech[1];
 831                 vec[2]= headvec[2] + norvech[2];
 832                 glVertex3fv(vec);
 833                 vec[0]= tailvec[0] + norvect[0];
 834                 vec[1]= tailvec[1] + norvect[1];
 835                 vec[2]= tailvec[2] + norvect[2];
 836                 glVertex3fv(vec);
 837                 vec[0]= headvec[0] - norvech[0];
 838                 vec[1]= headvec[1] - norvech[1];
 839                 vec[2]= headvec[2] - norvech[2];
 840                 glVertex3fv(vec);
 841                 vec[0]= tailvec[0] - norvect[0];
 842                 vec[1]= tailvec[1] - norvect[1];
 843                 vec[2]= tailvec[2] - norvect[2];
 844                 glVertex3fv(vec);
 845
 846                 glEnd();
 847         }
 848 }
 849
 850 /* does wire only for outline selecting */
 851 static void draw_sphere_bone(int dt, int armflag, int boneflag, int constflag, unsigned int id, bPoseChannel *pchan, EditBone *ebone)
 852 {
 853         GLUquadricObj   *qobj;
 854         float head, tail, length;
 855         float fac1, fac2;
 856
 857         glPushMatrix();
 858         qobj    = gluNewQuadric();
 859
 860         /* figure out the sizes of spheres */
 861         if (ebone) {
 862                 length= ebone->length;
 863                 tail= ebone->rad_tail;
 864                 if (ebone->parent && (boneflag & BONE_CONNECTED))
 865                         head= ebone->parent->rad_tail;
 866                 else
 867                         head= ebone->rad_head;
 868         }
 869         else {
 870                 length= pchan->bone->length;
 871                 tail= pchan->bone->rad_tail;
 872                 if (pchan->parent && (boneflag & BONE_CONNECTED))
 873                         head= pchan->parent->bone->rad_tail;
 874                 else
 875                         head= pchan->bone->rad_head;
 876         }
 877
 878         /* move to z-axis space */
 879         glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);
 880
 881         if (dt==OB_SOLID) {
 882                 /* set up solid drawing */
 883                 glEnable(GL_COLOR_MATERIAL);
 884                 glEnable(GL_LIGHTING);
 885
 886                 gluQuadricDrawStyle(qobj, GLU_FILL);
 887                 glShadeModel(GL_SMOOTH);
 888         }
 889         else {
 890                 gluQuadricDrawStyle(qobj, GLU_SILHOUETTE);
 891         }
 892
 893         /* sphere root color */
 894         if (armflag & ARM_EDITMODE) {
 895                 if (boneflag & BONE_ROOTSEL) UI_ThemeColor(TH_VERTEX_SELECT);
 896                 else UI_ThemeColorShade(TH_BONE_SOLID, -30);
 897         }
 898         else if (armflag & ARM_POSEMODE)
 899                 set_pchan_glColor(PCHAN_COLOR_SPHEREBONE_END, armflag, boneflag, constflag);
 900         else if (dt==OB_SOLID)
 901                 UI_ThemeColorShade(TH_BONE_SOLID, -30);
 902
 903         /*      Draw root point if we are not connected */
 904         if ((boneflag & BONE_CONNECTED)==0) {
 905                 if (id != -1)
 906                         glLoadName(id | BONESEL_ROOT);
 907                 gluSphere(qobj, head, 16, 10);
 908         }
 909
 910         /*      Draw tip point */
 911         if (armflag & ARM_EDITMODE) {
 912                 if (boneflag & BONE_TIPSEL) UI_ThemeColor(TH_VERTEX_SELECT);
 913                 else UI_ThemeColorShade(TH_BONE_SOLID, -30);
 914         }
 915
 916         if (id != -1)
 917                 glLoadName(id | BONESEL_TIP);
 918
 919         glTranslatef(0.0f, 0.0f, length);
 920         gluSphere(qobj, tail, 16, 10);
 921         glTranslatef(0.0f, 0.0f, -length);
 922
 923         /* base */
 924         if (armflag & ARM_EDITMODE) {
 925                 if (boneflag & BONE_SELECTED) UI_ThemeColor(TH_SELECT);
 926                 else UI_ThemeColor(TH_BONE_SOLID);
 927         }
 928         else if (armflag & ARM_POSEMODE)
 929                 set_pchan_glColor(PCHAN_COLOR_SPHEREBONE_BASE, armflag, boneflag, constflag);
 930         else if (dt == OB_SOLID)
 931                 UI_ThemeColor(TH_BONE_SOLID);
 932
 933         fac1= (length-head)/length;
 934         fac2= (length-tail)/length;
 935
 936         if (length > (head+tail)) {
 937                 if (id != -1)
 938                         glLoadName (id | BONESEL_BONE);
 939
 940                 glEnable(GL_POLYGON_OFFSET_FILL);
 941                 glPolygonOffset(-1.0f, -1.0f);
 942
 943                 glTranslatef(0.0f, 0.0f, head);
 944                 gluCylinder(qobj, fac1*head + (1.0f-fac1)*tail, fac2*tail + (1.0f-fac2)*head, length-head-tail, 16, 1);
 945                 glTranslatef(0.0f, 0.0f, -head);
 946
 947                 glDisable(GL_POLYGON_OFFSET_FILL);
 948
 949                 /* draw sphere on extrema */
 950                 glTranslatef(0.0f, 0.0f, length-tail);
 951                 gluSphere(qobj, fac2*tail + (1.0f-fac2)*head, 16, 10);
 952                 glTranslatef(0.0f, 0.0f, -length+tail);
 953
 954                 glTranslatef(0.0f, 0.0f, head);
 955                 gluSphere(qobj, fac1*head + (1.0f-fac1)*tail, 16, 10);
 956         }
 957         else {
 958                 /* 1 sphere in center */
 959                 glTranslatef(0.0f, 0.0f, (head + length-tail)/2.0f);
 960                 gluSphere(qobj, fac1*head + (1.0f-fac1)*tail, 16, 10);
 961         }
 962
 963         /* restore */
 964         if (dt==OB_SOLID) {
 965                 glShadeModel(GL_FLAT);
 966                 glDisable(GL_LIGHTING);
 967                 glDisable(GL_COLOR_MATERIAL);
 968         }
 969
 970         glPopMatrix();
 971         gluDeleteQuadric(qobj);
 972 }
 973
 974 static GLubyte bm_dot6[]= {0x0, 0x18, 0x3C, 0x7E, 0x7E, 0x3C, 0x18, 0x0};
 975 static GLubyte bm_dot8[]= {0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C};
 976
 977 static GLubyte bm_dot5[]= {0x0, 0x0, 0x10, 0x38, 0x7c, 0x38, 0x10, 0x0};
 978 static GLubyte bm_dot7[]= {0x0, 0x38, 0x7C, 0xFE, 0xFE, 0xFE, 0x7C, 0x38};
 979
 980
 981 static void draw_line_bone(int armflag, int boneflag, int constflag, unsigned int id, bPoseChannel *pchan, EditBone *ebone)
 982 {
 983         float length;
 984
 985         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 986
 987         if (pchan)
 988                 length= pchan->bone->length;
 989         else
 990                 length= ebone->length;
 991
 992         glPushMatrix();
 993         glScalef(length, length, length);
 994
 995         /* this chunk not in object mode */
 996         if (armflag & (ARM_EDITMODE|ARM_POSEMODE)) {
 997                 glLineWidth(4.0f);
 998                 if (armflag & ARM_POSEMODE)
 999                         set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
1000                 else if (armflag & ARM_EDITMODE) {
1001                         UI_ThemeColor(TH_WIRE);
1002                 }
1003
1004                 /*      Draw root point if we are not connected */
1005                 if ((boneflag & BONE_CONNECTED)==0) {
1006                         if (G.f & G_PICKSEL) {  // no bitmap in selection mode, crashes 3d cards...
1007                                 glLoadName (id | BONESEL_ROOT);
1008                                 glBegin(GL_POINTS);
1009                                 glVertex3f(0.0f, 0.0f, 0.0f);
1010                                 glEnd();
1011                         }
1012                         else {
1013                                 glRasterPos3f(0.0f, 0.0f, 0.0f);
1014                                 glBitmap(8, 8, 4, 4, 0, 0, bm_dot8);
1015                         }
1016                 }
1017
1018                 if (id != -1)
1019                         glLoadName((GLuint) id|BONESEL_BONE);
1020
1021                 glBegin(GL_LINES);
1022                 glVertex3f(0.0f, 0.0f, 0.0f);
1023                 glVertex3f(0.0f, 1.0f, 0.0f);
1024                 glEnd();
1025
1026                 /* tip */
1027                 if (G.f & G_PICKSEL) {
1028                         /* no bitmap in selection mode, crashes 3d cards... */
1029                         glLoadName(id | BONESEL_TIP);
1030                         glBegin(GL_POINTS);
1031                         glVertex3f(0.0f, 1.0f, 0.0f);
1032                         glEnd();
1033                 }
1034                 else {
1035                         glRasterPos3f(0.0f, 1.0f, 0.0f);
1036                         glBitmap(8, 8, 4, 4, 0, 0, bm_dot7);
1037                 }
1038
1039                 /* further we send no names */
1040                 if (id != -1)
1041                         glLoadName(id & 0xFFFF);        /* object tag, for bordersel optim */
1042
1043                 if (armflag & ARM_POSEMODE)
1044                         set_pchan_glColor(PCHAN_COLOR_LINEBONE, armflag, boneflag, constflag);
1045         }
1046
1047         glLineWidth(2.0);
1048
1049         /*Draw root point if we are not connected */
1050         if ((boneflag & BONE_CONNECTED)==0) {
1051                 if ((G.f & G_PICKSEL)==0) {
1052                         /* no bitmap in selection mode, crashes 3d cards... */
1053                         if (armflag & ARM_EDITMODE) {
1054                                 if (boneflag & BONE_ROOTSEL) UI_ThemeColor(TH_VERTEX_SELECT);
1055                                 else UI_ThemeColor(TH_VERTEX);
1056                         }
1057                         glRasterPos3f(0.0f, 0.0f, 0.0f);
1058                         glBitmap(8, 8, 4, 4, 0, 0, bm_dot6);
1059                 }
1060         }
1061
1062         if (armflag & ARM_EDITMODE) {
1063                 if (boneflag & BONE_SELECTED) UI_ThemeColor(TH_EDGE_SELECT);
1064                 else UI_ThemeColorShade(TH_BACK, -30);
1065         }
1066         glBegin(GL_LINES);
1067         glVertex3f(0.0f, 0.0f, 0.0f);
1068         glVertex3f(0.0f, 1.0f, 0.0f);
1069         glEnd();
1070
1071         /* tip */
1072         if ((G.f & G_PICKSEL)==0) {
1073                 /* no bitmap in selection mode, crashes 3d cards... */
1074                 if (armflag & ARM_EDITMODE) {
1075                         if (boneflag & BONE_TIPSEL) UI_ThemeColor(TH_VERTEX_SELECT);
1076                         else UI_ThemeColor(TH_VERTEX);
1077                 }
1078                 glRasterPos3f(0.0f, 1.0f, 0.0f);
1079                 glBitmap(8, 8, 4, 4, 0, 0, bm_dot5);
1080         }
1081
1082         glLineWidth(1.0);
1083
1084         glPopMatrix();
1085 }
1086
1087 static void draw_b_bone_boxes(int dt, bPoseChannel *pchan, float xwidth, float length, float zwidth)
1088 {
1089         int segments= 0;
1090
1091         if (pchan)
1092                 segments= pchan->bone->segments;
1093
1094         if ((segments > 1) && (pchan)) {
1095                 float dlen= length/(float)segments;
1096                 Mat4 *bbone= b_bone_spline_setup(pchan, 0);
1097                 int a;
1098
1099                 for (a=0; a<segments; a++, bbone++) {
1100                         glPushMatrix();
1101                         glMultMatrixf(bbone->mat);
1102                         if (dt==OB_SOLID) drawsolidcube_size(xwidth, dlen, zwidth);
1103                         else drawcube_size(xwidth, dlen, zwidth);
1104                         glPopMatrix();
1105                 }
1106         }
1107         else {
1108                 glPushMatrix();
1109                 if (dt==OB_SOLID) drawsolidcube_size(xwidth, length, zwidth);
1110                 else drawcube_size(xwidth, length, zwidth);
1111                 glPopMatrix();
1112         }
1113 }
1114
1115 static void draw_b_bone(int dt, int armflag, int boneflag, int constflag, unsigned int id, bPoseChannel *pchan, EditBone *ebone)
1116 {
1117         float xwidth, length, zwidth;
1118
1119         if (pchan) {
1120                 xwidth= pchan->bone->xwidth;
1121                 length= pchan->bone->length;
1122                 zwidth= pchan->bone->zwidth;
1123         }
1124         else {
1125                 xwidth= ebone->xwidth;
1126                 length= ebone->length;
1127                 zwidth= ebone->zwidth;
1128         }
1129
1130         /* draw points only if... */
1131         if (armflag & ARM_EDITMODE) {
1132                 /* move to unitspace */
1133                 glPushMatrix();
1134                 glScalef(length, length, length);
1135                 draw_bone_points(dt, armflag, boneflag, id);
1136                 glPopMatrix();
1137                 length*= 0.95f; // make vertices visible
1138         }
1139
1140         /* colors for modes */
1141         if (armflag & ARM_POSEMODE) {
1142                 if (dt <= OB_WIRE)
1143                         set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
1144                 else
1145                         set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, constflag);
1146         }
1147         else if (armflag & ARM_EDITMODE) {
1148                 if (dt==OB_WIRE) {
1149                         if (boneflag & BONE_ACTIVE) UI_ThemeColor(TH_EDGE_SELECT);
1150                         else if (boneflag & BONE_SELECTED) UI_ThemeColorShade(TH_EDGE_SELECT, -20);
1151                         else UI_ThemeColor(TH_WIRE);
1152                 }
1153                 else
1154                         UI_ThemeColor(TH_BONE_SOLID);
1155         }
1156
1157         if (id != -1) {
1158                 glLoadName ((GLuint) id|BONESEL_BONE);
1159         }
1160
1161         /* set up solid drawing */
1162         if (dt > OB_WIRE) {
1163                 glEnable(GL_COLOR_MATERIAL);
1164                 glEnable(GL_LIGHTING);
1165
1166                 if (armflag & ARM_POSEMODE)
1167                         set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, constflag);
1168                 else
1169                         UI_ThemeColor(TH_BONE_SOLID);
1170
1171                 draw_b_bone_boxes(OB_SOLID, pchan, xwidth, length, zwidth);
1172
1173                 /* disable solid drawing */
1174                 glDisable(GL_COLOR_MATERIAL);
1175                 glDisable(GL_LIGHTING);
1176         }
1177         else {
1178                 /* wire */
1179                 if (armflag & ARM_POSEMODE) {
1180                         if (constflag) {
1181                                 /* set constraint colors */
1182                                 if (set_pchan_glColor(PCHAN_COLOR_CONSTS, armflag, boneflag, constflag)) {
1183                                         glEnable(GL_BLEND);
1184
1185                                         draw_b_bone_boxes(OB_SOLID, pchan, xwidth, length, zwidth);
1186
1187                                         glDisable(GL_BLEND);
1188                                 }
1189
1190                                 /* restore colors */
1191                                 set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
1192                         }
1193                 }
1194
1195                 draw_b_bone_boxes(OB_WIRE, pchan, xwidth, length, zwidth);
1196         }
1197 }
1198
1199 static void draw_bone(int dt, int armflag, int boneflag, int constflag, unsigned int id, float length)
1200 {
1201
1202         /*      Draw a 3d octahedral bone, we use normalized space based on length,
1203             for glDisplayLists */
1204
1205         glScalef(length, length, length);
1206
1207         /* set up solid drawing */
1208         if (dt > OB_WIRE) {
1209                 glEnable(GL_COLOR_MATERIAL);
1210                 glEnable(GL_LIGHTING);
1211                 UI_ThemeColor(TH_BONE_SOLID);
1212         }
1213
1214         /* colors for posemode */
1215         if (armflag & ARM_POSEMODE) {
1216                 if (dt <= OB_WIRE)
1217                         set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
1218                 else
1219                         set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, constflag);
1220         }
1221
1222
1223         draw_bone_points(dt, armflag, boneflag, id);
1224
1225         /* now draw the bone itself */
1226         if (id != -1) {
1227                 glLoadName((GLuint) id|BONESEL_BONE);
1228         }
1229
1230         /* wire? */
1231         if (dt <= OB_WIRE) {
1232                 /* colors */
1233                 if (armflag & ARM_EDITMODE) {
1234                         if (boneflag & BONE_ACTIVE) UI_ThemeColor(TH_EDGE_SELECT);
1235                         else if (boneflag & BONE_SELECTED) UI_ThemeColorShade(TH_EDGE_SELECT, -20);
1236                         else UI_ThemeColor(TH_WIRE);
1237                 }
1238                 else if (armflag & ARM_POSEMODE) {
1239                         if (constflag) {
1240                                 /* draw constraint colors */
1241                                 if (set_pchan_glColor(PCHAN_COLOR_CONSTS, armflag, boneflag, constflag)) {
1242                                         glEnable(GL_BLEND);
1243
1244                                         draw_bone_solid_octahedral();
1245
1246                                         glDisable(GL_BLEND);
1247                                 }
1248
1249                                 /* restore colors */
1250                                 set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
1251                         }
1252                 }
1253                 draw_bone_octahedral();
1254         }
1255         else {
1256                 /* solid */
1257                 if (armflag & ARM_POSEMODE)
1258                         set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, constflag);
1259                 else
1260                         UI_ThemeColor(TH_BONE_SOLID);
1261                 draw_bone_solid_octahedral();
1262         }
1263
1264         /* disable solid drawing */
1265         if (dt > OB_WIRE) {
1266                 glDisable(GL_COLOR_MATERIAL);
1267                 glDisable(GL_LIGHTING);
1268         }
1269 }
1270
1271 static void draw_custom_bone(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob, int dt, int armflag, int boneflag, unsigned int id, float length)
1272 {
1273         if(ob==NULL) return;
1274
1275         glScalef(length, length, length);
1276
1277         /* colors for posemode */
1278         if (armflag & ARM_POSEMODE) {
1279                 set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, 0);
1280         }
1281
1282         if (id != -1) {
1283                 glLoadName((GLuint) id|BONESEL_BONE);
1284         }
1285
1286         draw_object_instance(scene, v3d, rv3d, ob, dt, armflag & ARM_POSEMODE);
1287 }
1288
1289
1290 static void pchan_draw_IK_root_lines(bPoseChannel *pchan, short only_temp)
1291 {
1292         bConstraint *con;
1293         bPoseChannel *parchan;
1294
1295         for (con= pchan->constraints.first; con; con= con->next) {
1296                 if (con->type == CONSTRAINT_TYPE_KINEMATIC && (con->enforce!=0.0)) {
1297                         bKinematicConstraint *data = (bKinematicConstraint*)con->data;
1298                         int segcount= 0;
1299
1300                         /* if only_temp, only draw if it is a temporary ik-chain */
1301                         if ((only_temp) && !(data->flag & CONSTRAINT_IK_TEMP))
1302                                 continue;
1303
1304                         setlinestyle(3);
1305                         glBegin(GL_LINES);
1306
1307                         /* exclude tip from chain? */
1308                         if ((data->flag & CONSTRAINT_IK_TIP)==0)
1309                                 parchan= pchan->parent;
1310                         else
1311                                 parchan= pchan;
1312
1313                         glVertex3fv(parchan->pose_tail);
1314
1315                         /* Find the chain's root */
1316                         while (parchan->parent) {
1317                                 segcount++;
1318                                 if(segcount==data->rootbone || segcount>255) break; // 255 is weak
1319                                 parchan= parchan->parent;
1320                         }
1321                         if (parchan)
1322                                 glVertex3fv(parchan->pose_head);
1323
1324                         glEnd();
1325                         setlinestyle(0);
1326                 }
1327         }
1328 }
1329
1330 static void bgl_sphere_project(float ax, float az)
1331 {
1332         float dir[3], sine, q3;
1333
1334         sine= 1.0f - ax*ax - az*az;
1335         q3= (sine < 0.0f)? 0.0f: (float)(2.0*sqrt(sine));
1336
1337         dir[0]= -az*q3;
1338         dir[1]= 1.0f - 2.0f*sine;
1339         dir[2]= ax*q3;
1340
1341         glVertex3fv(dir);
1342 }
1343
1344 static void draw_dof_ellipse(float ax, float az)
1345 {
1346         static float staticSine[16] = {
1347                 0.0f, 0.104528463268f, 0.207911690818f, 0.309016994375f,
1348                 0.406736643076f, 0.5f, 0.587785252292f, 0.669130606359f,
1349                 0.743144825477f, 0.809016994375f, 0.866025403784f,
1350                 0.913545457643f, 0.951056516295f, 0.978147600734f,
1351                 0.994521895368f, 1.0f
1352         };
1353
1354         int i, j, n=16;
1355         float x, z, px, pz;
1356
1357         glEnable(GL_BLEND);
1358         glDepthMask(0);
1359
1360         glColor4ub(70, 70, 70, 50);
1361
1362         glBegin(GL_QUADS);
1363         pz= 0.0f;
1364         for(i=1; i<n; i++) {
1365                 z= staticSine[i];
1366
1367                 px= 0.0f;
1368                 for(j=1; j<n-i+1; j++) {
1369                         x = staticSine[j];
1370
1371                         if(j == n-i) {
1372                                 glEnd();
1373                                 glBegin(GL_TRIANGLES);
1374                                 bgl_sphere_project(ax*px, az*z);
1375                                 bgl_sphere_project(ax*px, az*pz);
1376                                 bgl_sphere_project(ax*x, az*pz);
1377                                 glEnd();
1378                                 glBegin(GL_QUADS);
1379                         }
1380                         else {
1381                                 bgl_sphere_project(ax*x, az*z);
1382                                 bgl_sphere_project(ax*x, az*pz);
1383                                 bgl_sphere_project(ax*px, az*pz);
1384                                 bgl_sphere_project(ax*px, az*z);
1385                         }
1386
1387                         px= x;
1388                 }
1389                 pz= z;
1390         }
1391         glEnd();
1392
1393         glDisable(GL_BLEND);
1394         glDepthMask(1);
1395
1396         glColor3ub(0, 0, 0);
1397
1398         glBegin(GL_LINE_STRIP);
1399         for (i=0; i<n; i++)
1400                 bgl_sphere_project(staticSine[n-i-1]*ax, staticSine[i]*az);
1401         glEnd();
1402 }
1403
1404 static void draw_pose_dofs(Object *ob)
1405 {
1406         bArmature *arm= ob->data;
1407         bPoseChannel *pchan;
1408         Bone *bone;
1409
1410         for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
1411                 bone= pchan->bone;
1412
1413                 if ( (bone) && !(bone->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG))) {
1414                         if (bone->flag & BONE_SELECTED) {
1415                                 if (bone->layer & arm->layer) {
1416                                         if (pchan->ikflag & (BONE_IK_XLIMIT|BONE_IK_ZLIMIT)) {
1417                                                 if (ED_pose_channel_in_IK_chain(ob, pchan)) {
1418                                                         float corner[4][3], posetrans[3], mat[4][4];
1419                                                         float phi=0.0f, theta=0.0f, scale;
1420                                                         int a, i;
1421
1422                                                         /* in parent-bone pose, but own restspace */
1423                                                         glPushMatrix();
1424
1425                                                         VECCOPY(posetrans, pchan->pose_mat[3]);
1426                                                         glTranslatef(posetrans[0], posetrans[1], posetrans[2]);
1427
1428                                                         if (pchan->parent) {
1429                                                                 Mat4CpyMat4(mat, pchan->parent->pose_mat);
1430                                                                 mat[3][0]= mat[3][1]= mat[3][2]= 0.0f;
1431                                                                 glMultMatrixf(mat);
1432                                                         }
1433
1434                                                         Mat4CpyMat3(mat, pchan->bone->bone_mat);
1435                                                         glMultMatrixf(mat);
1436
1437                                                         scale= bone->length*pchan->size[1];
1438                                                         glScalef(scale, scale, scale);
1439
1440                                                         if (pchan->ikflag & BONE_IK_XLIMIT) {
1441                                                                 if (pchan->ikflag & BONE_IK_ZLIMIT) {
1442                                                                         float amin[3], amax[3];
1443
1444                                                                         for (i=0; i<3; i++) {
1445                                                                                 amin[i]= (float)sin(pchan->limitmin[i]*M_PI/360.0);
1446                                                                                 amax[i]= (float)sin(pchan->limitmax[i]*M_PI/360.0);
1447                                                                         }
1448
1449                                                                         glScalef(1.0f, -1.0f, 1.0f);
1450                                                                         if ((amin[0] != 0.0f) && (amin[2] != 0.0f))
1451                                                                                 draw_dof_ellipse(amin[0], amin[2]);
1452                                                                         if ((amin[0] != 0.0f) && (amax[2] != 0.0f))
1453                                                                                 draw_dof_ellipse(amin[0], amax[2]);
1454                                                                         if ((amax[0] != 0.0f) && (amin[2] != 0.0f))
1455                                                                                 draw_dof_ellipse(amax[0], amin[2]);
1456                                                                         if ((amax[0] != 0.0f) && (amax[2] != 0.0f))
1457                                                                                 draw_dof_ellipse(amax[0], amax[2]);
1458                                                                         glScalef(1.0f, -1.0f, 1.0f);
1459                                                                 }
1460                                                         }
1461
1462                                                         /* arcs */
1463                                                         if (pchan->ikflag & BONE_IK_ZLIMIT) {
1464                                                                 theta= 0.5f*(pchan->limitmin[2]+pchan->limitmax[2]);
1465                                                                 glRotatef(theta, 0.0f, 0.0f, 1.0f);
1466
1467                                                                 glColor3ub(50, 50, 255);        // blue, Z axis limit
1468                                                                 glBegin(GL_LINE_STRIP);
1469                                                                 for (a=-16; a<=16; a++) {
1470                                                                         float fac= ((float)a)/16.0f;
1471
1472                                                                         phi= fac * (float)(M_PI/360.0f) * (pchan->limitmax[2] - pchan->limitmin[2]);
1473
1474                                                                         i= (a == -16) ? 0 : 1;
1475                                                                         corner[i][0]= (float)sin(phi);
1476                                                                         corner[i][1]= (float)cos(phi);
1477                                                                         corner[i][2]= 0.0f;
1478                                                                         glVertex3fv(corner[i]);
1479                                                                 }
1480                                                                 glEnd();
1481
1482                                                                 glRotatef(-theta, 0.0f, 0.0f, 1.0f);
1483                                                         }
1484
1485                                                         if (pchan->ikflag & BONE_IK_XLIMIT) {
1486                                                                 theta= 0.5f * (pchan->limitmin[0] + pchan->limitmax[0]);
1487                                                                 glRotatef(theta, 1.0f, 0.0f, 0.0f);
1488
1489                                                                 glColor3ub(255, 50, 50);        // Red, X axis limit
1490                                                                 glBegin(GL_LINE_STRIP);
1491                                                                 for (a=-16; a<=16; a++) {
1492                                                                         float fac= ((float)a)/16.0f;
1493                                                                         phi= (float)(0.5*M_PI) + fac * (float)(M_PI/360.0f) * (pchan->limitmax[0] - pchan->limitmin[0]);
1494
1495                                                                         i= (a == -16) ? 2 : 3;
1496                                                                         corner[i][0]= 0.0f;
1497                                                                         corner[i][1]= (float)sin(phi);
1498                                                                         corner[i][2]= (float)cos(phi);
1499                                                                         glVertex3fv(corner[i]);
1500                                                                 }
1501                                                                 glEnd();
1502
1503                                                                 glRotatef(-theta, 1.0f, 0.0f, 0.0f);
1504                                                         }
1505
1506                                                         /* out of cone, out of bone */
1507                                                         glPopMatrix();
1508                                                 }
1509                                         }
1510                                 }
1511                         }
1512                 }
1513         }
1514 }
1515
1516 /* assumes object is Armature with pose */
1517 static void draw_pose_channels(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base, int dt)
1518 {
1519         Object *ob= base->object;
1520         bArmature *arm= ob->data;
1521         bPoseChannel *pchan;
1522         Bone *bone;
1523         GLfloat tmp;
1524         float smat[4][4], imat[4][4];
1525         int index= -1;
1526         short do_dashed= 3, draw_wire= 0;
1527         short flag, constflag;
1528
1529         /* hacky... prevent outline select from drawing dashed helplines */
1530         glGetFloatv(GL_LINE_WIDTH, &tmp);
1531         if (tmp > 1.1) do_dashed &= ~1;
1532         if (v3d->flag & V3D_HIDE_HELPLINES) do_dashed &= ~2;
1533
1534         /* precalc inverse matrix for drawing screen aligned */
1535         if (arm->drawtype==ARM_ENVELOPE) {
1536                 /* precalc inverse matrix for drawing screen aligned */
1537                 wmGetMatrix(smat);
1538                 Mat4MulFloat3(smat[0], 1.0f/VecLength(ob->obmat[0]));
1539                 Mat4Invert(imat, smat);
1540
1541                 /* and draw blended distances */
1542                 if (arm->flag & ARM_POSEMODE) {
1543                         glEnable(GL_BLEND);
1544                         //glShadeModel(GL_SMOOTH);
1545
1546                         if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
1547
1548                         for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
1549                                 bone= pchan->bone;
1550                                 if (bone && !(bone->flag & (BONE_HIDDEN_P|BONE_NO_DEFORM|BONE_HIDDEN_PG))) {
1551                                         if (bone->flag & (BONE_SELECTED)) {
1552                                                 if (bone->layer & arm->layer)
1553                                                         draw_sphere_bone_dist(smat, imat, bone->flag, pchan, NULL);
1554                                         }
1555                                 }
1556                         }
1557
1558                         if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
1559                         glDisable(GL_BLEND);
1560                         //glShadeModel(GL_FLAT);
1561                 }
1562         }
1563
1564         /* little speedup, also make sure transparent only draws once */
1565         glCullFace(GL_BACK);
1566         glEnable(GL_CULL_FACE);
1567
1568         /* if solid we draw that first, with selection codes, but without names, axes etc */
1569         if (dt > OB_WIRE) {
1570                 if (arm->flag & ARM_POSEMODE)
1571                         index= base->selcol;
1572
1573                 for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
1574                         bone= pchan->bone;
1575
1576                         if ( (bone) && !(bone->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG)) ) {
1577                                 if (bone->layer & arm->layer) {
1578                                         glPushMatrix();
1579                                         glMultMatrixf(pchan->pose_mat);
1580
1581                                         /* catch exception for bone with hidden parent */
1582                                         flag= bone->flag;
1583                                         if ( (bone->parent) && (bone->parent->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG)) )
1584                                                 flag &= ~BONE_CONNECTED;
1585
1586                                         /* set color-set to use */
1587                                         set_pchan_colorset(ob, pchan);
1588
1589                                         if ((pchan->custom) && !(arm->flag & ARM_NO_CUSTOM)) {
1590                                                 /* if drawwire, don't try to draw in solid */
1591                                                 if (pchan->bone->flag & BONE_DRAWWIRE)
1592                                                         draw_wire= 1;
1593                                                 else
1594                                                         draw_custom_bone(scene, v3d, rv3d, pchan->custom, OB_SOLID, arm->flag, flag, index, bone->length);
1595                                         }
1596                                         else if (arm->drawtype==ARM_LINE)
1597                                                 ;       /* nothing in solid */
1598                                         else if (arm->drawtype==ARM_ENVELOPE)
1599                                                 draw_sphere_bone(OB_SOLID, arm->flag, flag, 0, index, pchan, NULL);
1600                                         else if (arm->drawtype==ARM_B_BONE)
1601                                                 draw_b_bone(OB_SOLID, arm->flag, flag, 0, index, pchan, NULL);
1602                                         else
1603                                                 draw_bone(OB_SOLID, arm->flag, flag, 0, index, bone->length);
1604
1605                                         glPopMatrix();
1606                                 }
1607                         }
1608
1609                         if (index!= -1)
1610                                 index+= 0x10000;        // pose bones count in higher 2 bytes only
1611                 }
1612
1613                 /* very very confusing... but in object mode, solid draw, we cannot do glLoadName yet,
1614                  * stick bones and/or wire custom-shapes are drawn in next loop
1615                  */
1616                 if ((arm->drawtype != ARM_LINE) && (draw_wire == 0)) {
1617                         /* object tag, for bordersel optim */
1618                         glLoadName(index & 0xFFFF);
1619                         index= -1;
1620                 }
1621         }
1622
1623         /* draw custom bone shapes as wireframes */
1624         if ( !(arm->flag & ARM_NO_CUSTOM) &&
1625                  ((draw_wire) || (dt <= OB_WIRE)) )
1626         {
1627                 if (arm->flag & ARM_POSEMODE)
1628                         index= base->selcol;
1629
1630                 /* only draw custom bone shapes that need to be drawn as wires */
1631                 for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
1632                         bone= pchan->bone;
1633
1634                         if ((bone) && !(bone->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG))) {
1635                                 if (bone->layer & arm->layer) {
1636                                         if (pchan->custom) {
1637                                                 if ((dt < OB_SOLID) || (bone->flag & BONE_DRAWWIRE)) {
1638                                                         glPushMatrix();
1639                                                         glMultMatrixf(pchan->pose_mat);
1640
1641                                                         /* prepare colors */
1642                                                         if (arm->flag & ARM_POSEMODE)
1643                                                                 set_pchan_colorset(ob, pchan);
1644                                                         else {
1645                                                                 if ((scene->basact)==base) {
1646                                                                         if (base->flag & (SELECT+BA_WAS_SEL)) UI_ThemeColor(TH_ACTIVE);
1647                                                                         else UI_ThemeColor(TH_WIRE);
1648                                                                 }
1649                                                                 else {
1650                                                                         if (base->flag & (SELECT+BA_WAS_SEL)) UI_ThemeColor(TH_SELECT);
1651                                                                         else UI_ThemeColor(TH_WIRE);
1652                                                                 }
1653                                                         }
1654
1655                                                         /* catch exception for bone with hidden parent */
1656                                                         flag= bone->flag;
1657                                                         if ((bone->parent) && (bone->parent->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG)))
1658                                                                 flag &= ~BONE_CONNECTED;
1659
1660                                                         draw_custom_bone(scene, v3d, rv3d, pchan->custom, OB_WIRE, arm->flag, flag, index, bone->length);
1661
1662                                                         glPopMatrix();
1663                                                 }
1664                                         }
1665                                 }
1666                         }
1667
1668                         if (index != -1)
1669                                 index+= 0x10000;        // pose bones count in higher 2 bytes only
1670                 }
1671
1672                 if (draw_wire) {
1673                         /* object tag, for bordersel optim */
1674                         glLoadName(index & 0xFFFF);
1675                         index= -1;
1676                 }
1677         }
1678
1679         /* wire draw over solid only in posemode */
1680         if ((dt <= OB_WIRE) || (arm->flag & ARM_POSEMODE) || (arm->drawtype==ARM_LINE)) {
1681                 /* draw line check first. we do selection indices */
1682                 if (arm->drawtype==ARM_LINE) {
1683                         if (arm->flag & ARM_POSEMODE)
1684                                 index= base->selcol;
1685                 }
1686                 /* if solid && posemode, we draw again with polygonoffset */
1687                 else if ((dt > OB_WIRE) && (arm->flag & ARM_POSEMODE)) {
1688                         bglPolygonOffset(rv3d->dist, 1.0);
1689                 }
1690                 else {
1691                         /* and we use selection indices if not done yet */
1692                         if (arm->flag & ARM_POSEMODE)
1693                                 index= base->selcol;
1694                 }
1695
1696                 for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
1697                         bone= pchan->bone;
1698
1699                         if ((bone) && !(bone->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG))) {
1700                                 if (bone->layer & arm->layer) {
1701                                         if ((do_dashed & 1) && (bone->parent)) {
1702                                                 /* Draw a line from our root to the parent's tip
1703                                                  *      - only if V3D_HIDE_HELPLINES is enabled...
1704                                                  */
1705                                                 if ( (do_dashed & 2) && ((bone->flag & BONE_CONNECTED)==0) ) {
1706                                                         if (arm->flag & ARM_POSEMODE) {
1707                                                                 glLoadName(index & 0xFFFF);     // object tag, for bordersel optim
1708                                                                 UI_ThemeColor(TH_WIRE);
1709                                                         }
1710                                                         setlinestyle(3);
1711                                                         glBegin(GL_LINES);
1712                                                         glVertex3fv(pchan->pose_head);
1713                                                         glVertex3fv(pchan->parent->pose_tail);
1714                                                         glEnd();
1715                                                         setlinestyle(0);
1716                                                 }
1717
1718                                                 /* Draw a line to IK root bone
1719                                                  *      - only if temporary chain (i.e. "autoik")
1720                                                  */
1721                                                 if (arm->flag & ARM_POSEMODE) {
1722                                                         if (pchan->constflag & PCHAN_HAS_IK) {
1723                                                                 if (bone->flag & BONE_SELECTED) {
1724                                                                         if (pchan->constflag & PCHAN_HAS_TARGET) glColor3ub(200, 120, 0);
1725                                                                         else glColor3ub(200, 200, 50);  // add theme!
1726
1727                                                                         glLoadName(index & 0xFFFF);
1728                                                                         pchan_draw_IK_root_lines(pchan, !(do_dashed & 2));
1729                                                                 }
1730                                                         }
1731                                                 }
1732                                         }
1733
1734                                         glPushMatrix();
1735                                         if (arm->drawtype != ARM_ENVELOPE)
1736                                                 glMultMatrixf(pchan->pose_mat);
1737
1738                                         /* catch exception for bone with hidden parent */
1739                                         flag= bone->flag;
1740                                         if ((bone->parent) && (bone->parent->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG)))
1741                                                 flag &= ~BONE_CONNECTED;
1742
1743                                         /* extra draw service for pose mode */
1744                                         constflag= pchan->constflag;
1745                                         if (pchan->flag & (POSE_ROT|POSE_LOC|POSE_SIZE))        // XXX this is useless crap
1746                                                 constflag |= PCHAN_HAS_ACTION;
1747                                         if (pchan->flag & POSE_STRIDE)
1748                                                 constflag |= PCHAN_HAS_STRIDE;
1749
1750                                         /* set color-set to use */
1751                                         set_pchan_colorset(ob, pchan);
1752
1753                                         if ((pchan->custom) && !(arm->flag & ARM_NO_CUSTOM))
1754                                                 ; // custom bone shapes should not be drawn here!
1755                                         else if (arm->drawtype==ARM_ENVELOPE) {
1756                                                 if (dt < OB_SOLID)
1757                                                         draw_sphere_bone_wire(smat, imat, arm->flag, flag, constflag, index, pchan, NULL);
1758                                         }
1759                                         else if (arm->drawtype==ARM_LINE)
1760                                                 draw_line_bone(arm->flag, flag, constflag, index, pchan, NULL);
1761                                         else if (arm->drawtype==ARM_B_BONE)
1762                                                 draw_b_bone(OB_WIRE, arm->flag, flag, constflag, index, pchan, NULL);
1763                                         else
1764                                                 draw_bone(OB_WIRE, arm->flag, flag, constflag, index, bone->length);
1765
1766                                         glPopMatrix();
1767                                 }
1768                         }
1769
1770                         /* pose bones count in higher 2 bytes only */
1771                         if (index != -1)
1772                                 index+= 0x10000;
1773                 }
1774                 /* restore things */
1775                 if ((arm->drawtype!=ARM_LINE)&& (dt>OB_WIRE) && (arm->flag & ARM_POSEMODE))
1776                         bglPolygonOffset(rv3d->dist, 0.0);
1777         }
1778
1779         /* restore */
1780         glDisable(GL_CULL_FACE);
1781
1782         /* draw DoFs */
1783         if (arm->flag & ARM_POSEMODE)
1784                 draw_pose_dofs(ob);
1785
1786         /* finally names and axes */
1787         if (arm->flag & (ARM_DRAWNAMES|ARM_DRAWAXES)) {
1788                 /* patch for several 3d cards (IBM mostly) that crash on glSelect with text drawing */
1789                 if ((G.f & G_PICKSEL) == 0) {
1790                         float vec[3];
1791
1792                         if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
1793
1794                         for (pchan=ob->pose->chanbase.first; pchan; pchan=pchan->next) {
1795                                 if ((pchan->bone->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG))==0) {
1796                                         if (pchan->bone->layer & arm->layer) {
1797                                                 if (arm->flag & (ARM_EDITMODE|ARM_POSEMODE)) {
1798                                                         bone= pchan->bone;
1799
1800                                                         if (bone->flag & BONE_SELECTED) UI_ThemeColor(TH_TEXT_HI);
1801                                                         else UI_ThemeColor(TH_TEXT);
1802                                                 }
1803                                                 else if (dt > OB_WIRE)
1804                                                         UI_ThemeColor(TH_TEXT);
1805
1806                                                 /*      Draw names of bone      */
1807                                                 if (arm->flag & ARM_DRAWNAMES) {
1808                                                         VecMidf(vec, pchan->pose_head, pchan->pose_tail);
1809                                                         glRasterPos3fv(vec);
1810                                                         BMF_DrawString(G.font, " ");
1811                                                         BMF_DrawString(G.font, pchan->name);
1812                                                 }
1813
1814                                                 /*      Draw additional axes on the bone tail  */
1815                                                 if ( (arm->flag & ARM_DRAWAXES) && (arm->flag & ARM_POSEMODE) ) {
1816                                                         glPushMatrix();
1817                                                         glMultMatrixf(pchan->pose_mat);
1818                                                         glTranslatef(0.0f, pchan->bone->length, 0.0f);
1819                                                         drawaxes(0.25f*pchan->bone->length, 0, OB_ARROWS);
1820                                                         glPopMatrix();
1821                                                 }
1822                                         }
1823                                 }
1824                         }
1825
1826                         if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
1827                 }
1828         }
1829 }
1830
1831 /* in editmode, we don't store the bone matrix... */
1832 static void set_matrix_editbone(EditBone *eBone)
1833 {
1834         float           delta[3],offset[3];
1835         float           mat[3][3], bmat[4][4];
1836
1837         /* Compose the parent transforms (i.e. their translations) */
1838         VECCOPY(offset, eBone->head);
1839
1840         glTranslatef(offset[0],offset[1],offset[2]);
1841
1842         VecSubf(delta, eBone->tail, eBone->head);
1843
1844         eBone->length = (float)sqrt(delta[0]*delta[0] + delta[1]*delta[1] +delta[2]*delta[2]);
1845
1846         vec_roll_to_mat3(delta, eBone->roll, mat);
1847         Mat4CpyMat3(bmat, mat);
1848
1849         glMultMatrixf(bmat);
1850
1851 }
1852
1853 static void draw_ebones(View3D *v3d, RegionView3D *rv3d, Object *ob, int dt)
1854 {
1855         EditBone *eBone;
1856         bArmature *arm= ob->data;
1857         float smat[4][4], imat[4][4];
1858         unsigned int index;
1859         int flag;
1860
1861         /* envelope (deform distance) */
1862         if(arm->drawtype==ARM_ENVELOPE) {
1863                 /* precalc inverse matrix for drawing screen aligned */
1864                 wmGetMatrix(smat);
1865                 Mat4MulFloat3(smat[0], 1.0f/VecLength(ob->obmat[0]));
1866                 Mat4Invert(imat, smat);
1867
1868                 /* and draw blended distances */
1869                 glEnable(GL_BLEND);
1870                 //glShadeModel(GL_SMOOTH);
1871
1872                 if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
1873
1874                 for (eBone=arm->edbo->first, index=0; eBone; eBone=eBone->next, index++) {
1875                         if (eBone->layer & arm->layer) {
1876                                 if ((eBone->flag & (BONE_HIDDEN_A|BONE_NO_DEFORM))==0) {
1877                                         if (eBone->flag & (BONE_SELECTED|BONE_TIPSEL|BONE_ROOTSEL))
1878                                                 draw_sphere_bone_dist(smat, imat, eBone->flag, NULL, eBone);
1879                                 }
1880                         }
1881                 }
1882
1883                 if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
1884                 glDisable(GL_BLEND);
1885                 //glShadeModel(GL_FLAT);
1886         }
1887
1888         /* if solid we draw it first */
1889         if ((dt > OB_WIRE) && (arm->drawtype!=ARM_LINE)) {
1890                 index= 0;
1891                 for (eBone=arm->edbo->first, index=0; eBone; eBone=eBone->next, index++) {
1892                         if (eBone->layer & arm->layer) {
1893                                 if ((eBone->flag & BONE_HIDDEN_A)==0) {
1894                                         glPushMatrix();
1895                                         set_matrix_editbone(eBone);
1896
1897                                         /* catch exception for bone with hidden parent */
1898                                         flag= eBone->flag;
1899                                         if ( (eBone->parent) && ((eBone->parent->flag & BONE_HIDDEN_A) || (eBone->parent->layer & arm->layer)==0) )
1900                                                 flag &= ~BONE_CONNECTED;
1901
1902                                         if (arm->drawtype==ARM_ENVELOPE)
1903                                                 draw_sphere_bone(OB_SOLID, arm->flag, flag, 0, index, NULL, eBone);
1904                                         else if(arm->drawtype==ARM_B_BONE)
1905                                                 draw_b_bone(OB_SOLID, arm->flag, flag, 0, index, NULL, eBone);
1906                                         else {
1907                                                 draw_bone(OB_SOLID, arm->flag, flag, 0, index, eBone->length);
1908                                         }
1909
1910                                         glPopMatrix();
1911                                 }
1912                         }
1913                 }
1914         }
1915
1916         /* if wire over solid, set offset */
1917         index= -1;
1918         glLoadName(-1);
1919         if (arm->drawtype==ARM_LINE) {
1920                 if(G.f & G_PICKSEL)
1921                         index= 0;
1922         }
1923         else if (dt > OB_WIRE)
1924                 bglPolygonOffset(rv3d->dist, 1.0f);
1925         else if (arm->flag & ARM_EDITMODE)
1926                 index= 0;       /* do selection codes */
1927
1928         for (eBone=arm->edbo->first; eBone; eBone=eBone->next) {
1929                 if (eBone->layer & arm->layer) {
1930                         if ((eBone->flag & BONE_HIDDEN_A)==0) {
1931
1932                                 /* catch exception for bone with hidden parent */
1933                                 flag= eBone->flag;
1934                                 if ( (eBone->parent) && ((eBone->parent->flag & BONE_HIDDEN_A) || (eBone->parent->layer & arm->layer)==0) )
1935                                         flag &= ~BONE_CONNECTED;
1936
1937                                 if (arm->drawtype == ARM_ENVELOPE) {
1938                                         if (dt < OB_SOLID)
1939                                                 draw_sphere_bone_wire(smat, imat, arm->flag, flag, 0, index, NULL, eBone);
1940                                 }
1941                                 else {
1942                                         glPushMatrix();
1943                                         set_matrix_editbone(eBone);
1944
1945                                         if (arm->drawtype == ARM_LINE)
1946                                                 draw_line_bone(arm->flag, flag, 0, index, NULL, eBone);
1947                                         else if (arm->drawtype == ARM_B_BONE)
1948                                                 draw_b_bone(OB_WIRE, arm->flag, flag, 0, index, NULL, eBone);
1949                                         else
1950                                                 draw_bone(OB_WIRE, arm->flag, flag, 0, index, eBone->length);
1951
1952                                         glPopMatrix();
1953                                 }
1954
1955                                 /* offset to parent */
1956                                 if (eBone->parent) {
1957                                         UI_ThemeColor(TH_WIRE);
1958                                         glLoadName (-1);                // -1 here is OK!
1959                                         setlinestyle(3);
1960
1961                                         glBegin(GL_LINES);
1962                                         glVertex3fv(eBone->parent->tail);
1963                                         glVertex3fv(eBone->head);
1964                                         glEnd();
1965
1966                                         setlinestyle(0);
1967                                 }
1968                         }
1969                 }
1970                 if(index!=-1) index++;
1971         }
1972
1973         /* restore */
1974         if (arm->drawtype==ARM_LINE);
1975         else if (dt>OB_WIRE) bglPolygonOffset(rv3d->dist, 0.0f);
1976
1977         /* finally names and axes */
1978         if (arm->flag & (ARM_DRAWNAMES|ARM_DRAWAXES)) {
1979                 // patch for several 3d cards (IBM mostly) that crash on glSelect with text drawing
1980                 if ((G.f & G_PICKSEL) == 0) {
1981                         float vec[3];
1982
1983                         if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
1984
1985                         for (eBone=arm->edbo->first, index=0; eBone; eBone=eBone->next, index++) {
1986                                 if(eBone->layer & arm->layer) {
1987                                         if ((eBone->flag & BONE_HIDDEN_A)==0) {
1988
1989                                                 if (eBone->flag & BONE_SELECTED) UI_ThemeColor(TH_TEXT_HI);
1990                                                 else UI_ThemeColor(TH_TEXT);
1991
1992                                                 /*      Draw name */
1993                                                 if (arm->flag & ARM_DRAWNAMES) {
1994                                                         VecMidf(vec, eBone->head, eBone->tail);
1995                                                         glRasterPos3fv(vec);
1996                                                         BMF_DrawString(G.font, " ");
1997                                                         BMF_DrawString(G.font, eBone->name);
1998                                                 }
1999                                                 /*      Draw additional axes */
2000                                                 if (arm->flag & ARM_DRAWAXES) {
2001                                                         glPushMatrix();
2002                                                         set_matrix_editbone(eBone);
2003                                                         glTranslatef(0.0f, eBone->length, 0.0f);
2004                                                         drawaxes(eBone->length*0.25f, 0, OB_ARROWS);
2005                                                         glPopMatrix();
2006                                                 }
2007
2008                                         }
2009                                 }
2010                         }
2011
2012                         if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
2013                 }
2014         }
2015 }
2016
2017 /* ****************************** Armature Visualisation ******************************** */
2018
2019 /* ---------- Paths --------- */
2020
2021 /* draw bone paths
2022  *      - in view space
2023  */
2024 static void draw_pose_paths(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob)
2025 {
2026         bArmature *arm= ob->data;
2027         bPoseChannel *pchan;
2028         // bAction *act; // XXX old animsys - watch it!
2029         // bActionChannel *achan;
2030         ActKeyColumn *ak;
2031         ListBase keys;
2032         float *fp, *fp_start;
2033         int a, stepsize;
2034         int sfra, efra, len;
2035
2036         if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
2037
2038         glPushMatrix();
2039         glLoadMatrixf(rv3d->viewmat);
2040
2041         /* version patch here - cannot access frame info from file reading */
2042         if (arm->pathsize == 0) arm->pathsize= 1;
2043         stepsize = arm->pathsize;
2044
2045         for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
2046                 if (pchan->bone->layer & arm->layer) {
2047                         if (pchan->path) {
2048                                 /* version patch here - cannot access frame info from file reading */
2049                                 if ((pchan->pathsf == 0) || (pchan->pathef == 0)) {
2050                                         pchan->pathsf= SFRA;
2051                                         pchan->pathef= EFRA;
2052                                 }
2053
2054                                 /* get frame ranges */
2055                                 if (arm->pathflag & ARM_PATH_ACFRA) {
2056                                         int sind;
2057
2058                                         /* With "Around Current", we only choose frames from around
2059                                          * the current frame to draw. However, this range is still
2060                                          * restricted by the limits of the original path.
2061                                          */
2062                                         sfra= CFRA - arm->pathbc;
2063                                         efra= CFRA + arm->pathac;
2064                                         if (sfra < pchan->pathsf) sfra= pchan->pathsf;
2065                                         if (efra > pchan->pathef) efra= pchan->pathef;
2066
2067                                         len= efra - sfra;
2068
2069                                         sind= sfra - pchan->pathsf;
2070                                         fp_start= (pchan->path + (3*sind));
2071                                 }
2072                                 else {
2073                                         sfra= pchan->pathsf;
2074                                         efra = sfra + pchan->pathlen;
2075                                         len = pchan->pathlen;
2076                                         fp_start = pchan->path;
2077                                 }
2078
2079                                 /* draw curve-line of path */
2080                                 glShadeModel(GL_SMOOTH);
2081
2082                                 glBegin(GL_LINE_STRIP);
2083                                 for (a=0, fp=fp_start; a<len; a++, fp+=3) {
2084                                         float intensity; /* how faint */
2085
2086                                         /* set color
2087                                          *      - more intense for active/selected bones, less intense for unselected bones
2088                                          *      - black for before current frame, green for current frame, blue for after current frame
2089                                          *      - intensity decreases as distance from current frame increases
2090                                          */
2091                                         #define SET_INTENSITY(A, B, C, min, max) (((1.0f - ((C - B) / (C - A))) * (max-min)) + min)
2092                                         if ((a+sfra) < CFRA) {
2093                                                 /* black - before cfra */
2094                                                 if (pchan->bone->flag & BONE_SELECTED) {
2095                                                         // intensity= 0.5f;
2096                                                         intensity = SET_INTENSITY(sfra, a, CFRA, 0.25f, 0.75f);
2097                                                 }
2098                                                 else {
2099                                                         //intensity= 0.8f;
2100                                                         intensity = SET_INTENSITY(sfra, a, CFRA, 0.68f, 0.92f);
2101                                                 }
2102                                                 UI_ThemeColorBlend(TH_WIRE, TH_BACK, intensity);
2103                                         }
2104                                         else if ((a+sfra) > CFRA) {
2105                                                 /* blue - after cfra */
2106                                                 if (pchan->bone->flag & BONE_SELECTED) {
2107                                                         //intensity = 0.5f;
2108                                                         intensity = SET_INTENSITY(CFRA, a, efra, 0.25f, 0.75f);
2109                                                 }
2110                                                 else {
2111                                                         //intensity = 0.8f;
2112                                                         intensity = SET_INTENSITY(CFRA, a, efra, 0.68f, 0.92f);
2113                                                 }
2114                                                 UI_ThemeColorBlend(TH_BONE_POSE, TH_BACK, intensity);
2115                                         }
2116                                         else {
2117                                                 /* green - on cfra */
2118                                                 if (pchan->bone->flag & BONE_SELECTED) {
2119                                                         intensity= 0.5f;
2120                                                 }
2121                                                 else {
2122                                                         intensity= 0.99f;
2123                                                 }
2124                                                 UI_ThemeColorBlendShade(TH_CFRAME, TH_BACK, intensity, 10);
2125                                         }
2126
2127                                         /* draw a vertex with this color */
2128                                         glVertex3fv(fp);
2129                                 }
2130
2131                                 glEnd();
2132                                 glShadeModel(GL_FLAT);
2133
2134                                 glPointSize(1.0);
2135
2136                                 /* draw little black point at each frame
2137                                  * NOTE: this is not really visible/noticable
2138                                  */
2139                                 glBegin(GL_POINTS);
2140                                 for (a=0, fp=fp_start; a<len; a++, fp+=3)
2141                                         glVertex3fv(fp);
2142                                 glEnd();
2143
2144                                 /* Draw little white dots at each framestep value */
2145                                 UI_ThemeColor(TH_TEXT_HI);
2146                                 glBegin(GL_POINTS);
2147                                 for (a=0, fp=fp_start; a<len; a+=stepsize, fp+=(stepsize*3))
2148                                         glVertex3fv(fp);
2149                                 glEnd();
2150
2151                                 /* Draw frame numbers at each framestep value */
2152                                 if (arm->pathflag & ARM_PATH_FNUMS) {
2153                                         for (a=0, fp=fp_start; a<len; a+=stepsize, fp+=(stepsize*3)) {
2154                                                 char str[32];
2155
2156                                                 /* only draw framenum if several consecutive highlighted points don't occur on same point */
2157                                                 if (a == 0) {
2158                                                         glRasterPos3fv(fp);
2159                                                         sprintf(str, "  %d\n", (a+sfra));
2160                                                         BMF_DrawString(G.font, str);
2161                                                 }
2162                                                 else if ((a > stepsize) && (a < len-stepsize)) {
2163                                                         if ((VecEqual(fp, fp-(stepsize*3))==0) || (VecEqual(fp, fp+(stepsize*3))==0)) {
2164                                                                 glRasterPos3fv(fp);
2165                                                                 sprintf(str, "  %d\n", (a+sfra));
2166                                                                 BMF_DrawString(G.font, str);
2167                                                         }
2168                                                 }
2169                                         }
2170                                 }
2171
2172                                 /* Keyframes - dots and numbers */
2173                                 if (arm->pathflag & ARM_PATH_KFRAS) {
2174                                         /* build list of all keyframes in active action for pchan */
2175                                         keys.first = keys.last = NULL;
2176
2177                                         #if 0 // XXX old animation system
2178                                         act= ob->action;
2179                                         if (act) {
2180                                                 achan= get_action_channel(act, pchan->name);
2181                                                 if (achan)
2182                                                         ipo_to_keylist(achan->ipo, &keys, NULL, NULL);
2183                                         }
2184                                         #endif // XXX old animation system
2185
2186                                         /* Draw slightly-larger yellow dots at each keyframe */
2187                                         UI_ThemeColor(TH_VERTEX_SELECT);
2188                                         glPointSize(5.0f);
2189
2190                                         glBegin(GL_POINTS);
2191                                         for (a=0, fp=fp_start; a<len; a++, fp+=3) {
2192                                                 for (ak= keys.first; ak; ak= ak->next) {
2193                                                         if (ak->cfra == (a+sfra))
2194                                                                 glVertex3fv(fp);
2195                                                 }
2196                                         }
2197                                         glEnd();
2198
2199                                         glPointSize(1.0f);
2200
2201                                         /* Draw frame numbers of keyframes  */
2202                                         if ((arm->pathflag & ARM_PATH_FNUMS) || (arm->pathflag & ARM_PATH_KFNOS)) {
2203                                                 for(a=0, fp=fp_start; a<len; a++, fp+=3) {
2204                                                         for (ak= keys.first; ak; ak= ak->next) {
2205                                                                 if (ak->cfra == (a+sfra)) {
2206                                                                         char str[32];
2207
2208                                                                         glRasterPos3fv(fp);
2209                                                                         sprintf(str, "  %d\n", (a+sfra));
2210                                                                         BMF_DrawString(G.font, str);
2211                                                                 }
2212                                                         }
2213                                                 }
2214                                         }
2215
2216                                         BLI_freelistN(&keys);
2217                                 }
2218                         }
2219                 }
2220         }
2221
2222         if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
2223         glPopMatrix();
2224 }
2225
2226
2227 /* ---------- Ghosts --------- */
2228
2229 /* helper function for ghost drawing - sets/removes flags for temporarily
2230  * hiding unselected bones while drawing ghosts
2231  */
2232 static void ghost_poses_tag_unselected(Object *ob, short unset)
2233 {
2234         bArmature *arm= ob->data;
2235         bPose *pose= ob->pose;
2236         bPoseChannel *pchan;
2237
2238         /* don't do anything if no hiding any bones */
2239         if ((arm->flag & ARM_GHOST_ONLYSEL)==0)
2240                 return;
2241
2242         /* loop over all pchans, adding/removing tags as appropriate */
2243         for (pchan= pose->chanbase.first; pchan; pchan= pchan->next) {
2244                 if ((pchan->bone) && (arm->layer & pchan->bone->layer)) {
2245                         if (unset) {
2246                                 /* remove tags from all pchans if cleaning up */
2247                                 pchan->bone->flag &= ~BONE_HIDDEN_PG;
2248                         }
2249                         else {
2250                                 /* set tags on unselected pchans only */
2251                                 if ((pchan->bone->flag & BONE_SELECTED)==0)
2252                                         pchan->bone->flag |= BONE_HIDDEN_PG;
2253                         }
2254                 }
2255         }
2256 }
2257
2258 /* draw ghosts that occur within a frame range
2259  *      note: object should be in posemode
2260  */
2261 static void draw_ghost_poses_range(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base)
2262 {
2263         Object *ob= base->object;
2264         bArmature *arm= ob->data;
2265         bPose *posen, *poseo;
2266         float start, end, stepsize, range, colfac;
2267         int cfrao, flago, ipoflago;
2268
2269         start = (float)arm->ghostsf;
2270         end = (float)arm->ghostef;
2271         if (end <= start)
2272                 return;
2273
2274         stepsize= (float)(arm->ghostsize);
2275         range= (float)(end - start);
2276
2277         /* store values */
2278         ob->flag &= ~OB_POSEMODE;
2279         cfrao= CFRA;
2280         flago= arm->flag;
2281         arm->flag &= ~(ARM_DRAWNAMES|ARM_DRAWAXES);
2282         ipoflago= ob->ipoflag;
2283         ob->ipoflag |= OB_DISABLE_PATH;
2284
2285         /* copy the pose */
2286         poseo= ob->pose;
2287         copy_pose(&posen, ob->pose, 1);
2288         ob->pose= posen;
2289         armature_rebuild_pose(ob, ob->data);    /* child pointers for IK */
2290         ghost_poses_tag_unselected(ob, 0);              /* hide unselected bones if need be */
2291
2292         glEnable(GL_BLEND);
2293         if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
2294
2295         /* draw from first frame of range to last */
2296         for (CFRA= (int)start; CFRA < end; CFRA += (int)stepsize) {
2297                 colfac = (end - (float)CFRA) / range;
2298                 UI_ThemeColorShadeAlpha(TH_WIRE, 0, -128-(int)(120.0*sqrt(colfac)));
2299
2300                 //do_all_pose_actions(scene, ob);  // XXX old animation system
2301                 where_is_pose(scene, ob);
2302                 draw_pose_channels(scene, v3d, rv3d, base, OB_WIRE);
2303         }
2304         glDisable(GL_BLEND);
2305         if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
2306
2307         ghost_poses_tag_unselected(ob, 1);              /* unhide unselected bones if need be */
2308         free_pose(posen);
2309
2310         /* restore */
2311         CFRA= cfrao;
2312         ob->pose= poseo;
2313         arm->flag= flago;
2314         armature_rebuild_pose(ob, ob->data);
2315         ob->flag |= OB_POSEMODE;
2316         ob->ipoflag= ipoflago;
2317 }
2318
2319 /* draw ghosts on keyframes in action within range
2320  *      - object should be in posemode
2321  */
2322 static void draw_ghost_poses_keys(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base)
2323 {
2324         Object *ob= base->object;
2325         bAction *act= ob->action; // XXX old animsys stuff... watch it!
2326         bArmature *arm= ob->data;
2327         bPose *posen, *poseo;
2328         ListBase keys= {NULL, NULL};
2329         ActKeysInc aki = {0, 0, 0};
2330         ActKeyColumn *ak, *akn;
2331         float start, end, range, colfac, i;
2332         int cfrao, flago;
2333
2334         aki.start= start = (float)arm->ghostsf;
2335         aki.end= end = (float)arm->ghostef;
2336         if (end <= start)
2337                 return;
2338
2339         /* get keyframes - then clip to only within range */
2340         action_to_keylist(act, &keys, NULL, &aki);
2341         range= 0;
2342         for (ak= keys.first; ak; ak= akn) {
2343                 akn= ak->next;
2344
2345                 if ((ak->cfra < start) || (ak->cfra > end))
2346                         BLI_freelinkN(&keys, ak);
2347                 else
2348                         range++;
2349         }
2350         if (range == 0) return;
2351
2352         /* store values */
2353         ob->flag &= ~OB_POSEMODE;
2354         cfrao= CFRA;
2355         flago= arm->flag;
2356         arm->flag &= ~(ARM_DRAWNAMES|ARM_DRAWAXES);
2357         ob->ipoflag |= OB_DISABLE_PATH;
2358
2359         /* copy the pose */
2360         poseo= ob->pose;
2361         copy_pose(&posen, ob->pose, 1);
2362         ob->pose= posen;
2363         armature_rebuild_pose(ob, ob->data);    /* child pointers for IK */
2364         ghost_poses_tag_unselected(ob, 0);              /* hide unselected bones if need be */
2365
2366         glEnable(GL_BLEND);
2367         if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
2368
2369         /* draw from first frame of range to last */
2370         for (ak=keys.first, i=0; ak; ak=ak->next, i++) {
2371                 colfac = i/range;
2372                 UI_ThemeColorShadeAlpha(TH_WIRE, 0, -128-(int)(120.0*sqrt(colfac)));
2373
2374                 CFRA= (int)ak->cfra;
2375
2376                 //do_all_pose_actions(scene, ob);       // XXX old animation system
2377                 where_is_pose(scene, ob);
2378                 draw_pose_channels(scene, v3d, rv3d, base, OB_WIRE);
2379         }
2380         glDisable(GL_BLEND);
2381         if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
2382
2383         ghost_poses_tag_unselected(ob, 1);              /* unhide unselected bones if need be */
2384         BLI_freelistN(&keys);
2385         free_pose(posen);
2386
2387         /* restore */
2388         CFRA= cfrao;
2389         ob->pose= poseo;
2390         arm->flag= flago;
2391         armature_rebuild_pose(ob, ob->data);
2392         ob->flag |= OB_POSEMODE;
2393 }
2394
2395 /* draw ghosts around current frame
2396  *      - object is supposed to be armature in posemode
2397  */
2398 static void draw_ghost_poses(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base)
2399 {
2400         Object *ob= base->object;
2401         bArmature *arm= ob->data;
2402         bPose *posen, *poseo;
2403         //bActionStrip *strip;
2404         float cur, start, end, stepsize, range, colfac, actframe, ctime;
2405         int cfrao, maptime, flago;
2406
2407         /* pre conditions, get an action with sufficient frames */
2408         //if (ob->action==NULL)
2409         //      return;
2410
2411         calc_action_range(ob->action, &start, &end, 0);
2412         if (start == end)
2413                 return;
2414
2415         stepsize= (float)(arm->ghostsize);
2416         range= (float)(arm->ghostep)*stepsize + 0.5f;   /* plus half to make the for loop end correct */
2417
2418 #if 0 // XXX old animation system
2419         /* we only map time for armature when an active strip exists */
2420         for (strip=ob->nlastrips.first; strip; strip=strip->next)
2421                 if (strip->flag & ACTSTRIP_ACTIVE)
2422                         break;
2423 #endif // XXX old animsys
2424
2425         //maptime= (strip!=NULL);
2426         maptime= 0;
2427
2428         /* store values */
2429         ob->flag &= ~OB_POSEMODE;
2430         cfrao= CFRA;
2431         if (maptime) actframe= get_action_frame(ob, (float)CFRA);
2432         else actframe= (float)CFRA;
2433         flago= arm->flag;
2434         arm->flag &= ~(ARM_DRAWNAMES|ARM_DRAWAXES);
2435
2436         /* copy the pose */
2437         poseo= ob->pose;
2438         copy_pose(&posen, ob->pose, 1);
2439         ob->pose= posen;
2440         armature_rebuild_pose(ob, ob->data);    /* child pointers for IK */
2441         ghost_poses_tag_unselected(ob, 0);              /* hide unselected bones if need be */
2442
2443         glEnable(GL_BLEND);
2444         if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
2445
2446         /* draw from darkest blend to lowest */
2447         for(cur= stepsize; cur<range; cur+=stepsize) {
2448                 ctime= cur - (float)fmod(cfrao, stepsize);      /* ensures consistant stepping */
2449                 colfac= ctime/range;
2450                 UI_ThemeColorShadeAlpha(TH_WIRE, 0, -128-(int)(120.0*sqrt(colfac)));
2451
2452                 /* only within action range */
2453                 if (actframe+ctime >= start && actframe+ctime <= end) {
2454                         if (maptime) CFRA= (int)get_action_frame_inv(ob, actframe+ctime);
2455                         else CFRA= (int)floor(actframe+ctime);
2456
2457                         if (CFRA != cfrao) {
2458                                 //do_all_pose_actions(scene, ob); // xxx old animation system crap
2459                                 where_is_pose(scene, ob);
2460                                 draw_pose_channels(scene, v3d, rv3d, base, OB_WIRE);
2461                         }
2462                 }
2463
2464                 ctime= cur + (float)fmod((float)cfrao, stepsize) - stepsize+1.0f;       /* ensures consistant stepping */
2465                 colfac= ctime/range;
2466                 UI_ThemeColorShadeAlpha(TH_WIRE, 0, -128-(int)(120.0*sqrt(colfac)));
2467
2468                 /* only within action range */
2469                 if ((actframe-ctime >= start) && (actframe-ctime <= end)) {
2470                         if (maptime) CFRA= (int)get_action_frame_inv(ob, actframe-ctime);
2471                         else CFRA= (int)floor(actframe-ctime);
2472
2473                         if (CFRA != cfrao) {
2474                                 //do_all_pose_actions(scene, ob); // XXX old animation system crap...
2475                                 where_is_pose(scene, ob);
2476                                 draw_pose_channels(scene, v3d, rv3d, base, OB_WIRE);
2477                         }
2478                 }
2479         }
2480         glDisable(GL_BLEND);
2481         if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
2482
2483         ghost_poses_tag_unselected(ob, 1);              /* unhide unselected bones if need be */
2484         free_pose(posen);
2485
2486         /* restore */
2487         CFRA= cfrao;
2488         ob->pose= poseo;
2489         arm->flag= flago;
2490         armature_rebuild_pose(ob, ob->data);
2491         ob->flag |= OB_POSEMODE;
2492 }
2493
2494 /* ********************************** Armature Drawing - Main ************************* */
2495
2496 /* called from drawobject.c, return 1 if nothing was drawn */
2497 int draw_armature(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base, int dt, int flag)
2498 {
2499         Object *ob= base->object;
2500         bArmature *arm= ob->data;
2501         int retval= 0;
2502
2503         if(G.f & G_RENDER_SHADOW)
2504                 return 1;
2505
2506         if(dt>OB_WIRE && arm->drawtype!=ARM_LINE) {
2507                 /* we use color for solid lighting */
2508                 glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR);
2509                 glEnable(GL_COLOR_MATERIAL);
2510                 glColor3ub(0,0,0);      // clear spec
2511                 glDisable(GL_COLOR_MATERIAL);
2512
2513                 glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
2514                 glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW); // only for lighting...
2515         }
2516
2517         /* arm->flag is being used to detect mode... */
2518         /* editmode? */
2519         if(arm->edbo) {
2520                 arm->flag |= ARM_EDITMODE;
2521                 draw_ebones(v3d, rv3d, ob, dt);
2522                 arm->flag &= ~ARM_EDITMODE;
2523         }
2524         else{
2525                 /*      Draw Pose */
2526                 if(ob->pose && ob->pose->chanbase.first) {
2527                         /* drawing posemode selection indices or colors only in these cases */
2528                         if(!(base->flag & OB_FROMDUPLI)) {
2529                                 if(G.f & G_PICKSEL) {
2530                                         if(ob->flag & OB_POSEMODE)
2531                                                 arm->flag |= ARM_POSEMODE;
2532                                 }
2533                                 else if(ob->flag & OB_POSEMODE) {
2534                                         if (arm->ghosttype == ARM_GHOST_RANGE) {
2535                                                 draw_ghost_poses_range(scene, v3d, rv3d, base);
2536                                         }
2537                                         else if (arm->ghosttype == ARM_GHOST_KEYS) {
2538                                                 draw_ghost_poses_keys(scene, v3d, rv3d, base);
2539                                         }
2540                                         else if (arm->ghosttype == ARM_GHOST_CUR) {
2541                                                 if (arm->ghostep)
2542                                                         draw_ghost_poses(scene, v3d, rv3d, base);
2543                                         }
2544                                         if ((flag & DRAW_SCENESET)==0) {
2545                                                 if(ob==OBACT)
2546                                                         arm->flag |= ARM_POSEMODE;
2547                                                 else if(G.f & G_WEIGHTPAINT) {
2548                                                         if(OBACT && ob==modifiers_isDeformedByArmature(OBACT))
2549                                                                 arm->flag |= ARM_POSEMODE;
2550                                                 }
2551                                                 draw_pose_paths(scene, v3d, rv3d, ob);
2552                                         }
2553                                 }
2554                         }
2555                         draw_pose_channels(scene, v3d, rv3d, base, dt);
2556                         arm->flag &= ~ARM_POSEMODE;
2557
2558                         if(ob->flag & OB_POSEMODE)
2559                                 UI_ThemeColor(TH_WIRE); /* restore, for extra draw stuff */
2560                 }
2561                 else retval= 1;
2562         }
2563         /* restore */
2564         glFrontFace(GL_CCW);
2565
2566         return retval;
2567 }
2568
2569 /* *************** END Armature drawing ******************* */
2570
2571