2.5
authorTon Roosendaal <ton@blender.org>
Sat, 20 Dec 2008 13:29:35 +0000 (13:29 +0000)
committerTon Roosendaal <ton@blender.org>
Sat, 20 Dec 2008 13:29:35 +0000 (13:29 +0000)
Put back armature drawing code.
The BIF_editarmature.h is a placeholder... need it to get it work.

source/blender/editors/include/BIF_editarmature.h [new file with mode: 0644]
source/blender/editors/space_view3d/drawarmature.c [new file with mode: 0644]
source/blender/editors/space_view3d/drawobject.c
source/blender/editors/space_view3d/view3d_intern.h

diff --git a/source/blender/editors/include/BIF_editarmature.h b/source/blender/editors/include/BIF_editarmature.h
new file mode 100644 (file)
index 0000000..3d940f3
--- /dev/null
@@ -0,0 +1,178 @@
+/**
+ * $Id: BIF_editarmature.h 17446 2008-11-13 22:35:40Z theeth $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef BIF_EDITARMATURE_H
+#define BIF_EDITARMATURE_H
+
+struct Object;
+struct Base;
+struct Bone;
+struct bArmature;
+struct ListBase;
+
+typedef struct EditBone
+{
+       struct EditBone *next, *prev;
+       struct EditBone *parent;/*      Editbones have a one-way link  (i.e. children refer
+                                                                       to parents.  This is converted to a two-way link for
+                                                                       normal bones when leaving editmode.     */
+       void    *temp;                  /*      Used to store temporary data */
+
+       char    name[32];
+       float   roll;                   /*      Roll along axis.  We'll ultimately use the axis/angle method
+                                                               for determining the transformation matrix of the bone.  The axis
+                                                               is tail-head while roll provides the angle. Refer to Graphics
+                                                               Gems 1 p. 466 (section IX.6) if it's not already in here somewhere*/
+
+       float   head[3];                        /*      Orientation and length is implicit during editing */
+       float   tail[3];        
+                                                       /*      All joints are considered to have zero rotation with respect to
+                                                       their parents.  Therefore any rotations specified during the
+                                                       animation are automatically relative to the bones' rest positions*/
+       int             flag;
+
+       int             parNr;          /* Used for retrieving values from the menu system */
+       
+       float dist, weight;
+       float xwidth, length, zwidth;   /* put them in order! transform uses this as scale */
+       float ease1, ease2;
+       float rad_head, rad_tail;
+       short layer, segments;
+       
+       float oldlength;                                /* for envelope scaling */
+
+} EditBone;
+
+#define        BONESEL_ROOT    0x10000000
+#define        BONESEL_TIP             0x20000000
+#define        BONESEL_BONE    0x40000000
+#define BONESEL_ANY            (BONESEL_TIP|BONESEL_ROOT|BONESEL_BONE)
+
+#define BONESEL_NOSEL  0x80000000      /* Indicates a negative number */
+
+/* useful macros */
+#define EBONE_VISIBLE(arm, ebone) ((arm->layer & ebone->layer) && !(ebone->flag & BONE_HIDDEN_A))
+#define EBONE_EDITABLE(ebone) ((ebone->flag & BONE_SELECTED) && !(ebone->flag & BONE_EDITMODE_LOCKED)) 
+
+/* used in bone_select_hierachy() */
+#define BONE_SELECT_PARENT     0
+#define BONE_SELECT_CHILD      1
+
+/* XXX */
+#if 0
+float  rollBoneToVector(EditBone *bone, float new_up_axis[3]);
+
+void   make_boneList(struct ListBase *list, struct ListBase *bones, EditBone *parent);
+void   editbones_to_armature (struct ListBase *list, struct Object *ob);
+
+void   adduplicate_armature(void);
+void   addvert_armature(void);
+void   add_primitiveArmature(int type);
+void   apply_rot_armature (struct Object *ob, float mat[3][3]);
+void   docenter_armature (struct Object *ob, int centermode);
+
+void   clear_armature(struct Object *ob, char mode);
+
+void   delete_armature(void);
+void   deselectall_armature(int toggle, int doundo);
+void   deselectall_posearmature (struct Object *ob, int test, int doundo);
+
+
+void   extrude_armature(int forked);
+void   subdivide_armature(int numcuts);
+void   fill_bones_armature(void);
+void   merge_armature(void);
+
+void   free_editArmature(void);
+
+int            join_armature(void);
+void   separate_armature(void);
+void   apply_armature_pose2bones(void);
+void   load_editArmature(void);
+
+void   make_bone_parent(void);
+void    clear_bone_parent(void);
+struct Bone    *get_indexed_bone (struct Object *ob, int index);
+
+void   make_editArmature(void);
+void   make_trans_bones (char mode);
+void   remake_editArmature(void);
+void   editbones_to_armature(struct ListBase *list, struct Object *ob);
+
+int            do_pose_selectbuffer(struct Base *base, unsigned int *buffer, short hits);
+
+void generateSkeleton(void);
+
+void   mouse_armature(void);
+void   selectconnected_armature(void);
+void   selectconnected_posearmature(void);
+void   armature_select_hierarchy(short direction, short add_to_sel);
+
+void   setflag_armature(short mode);
+void    unique_editbone_name (struct ListBase *ebones, char *name);
+
+void   auto_align_armature(short mode);
+void   switch_direction_armature(void);
+
+void   create_vgroups_from_armature(struct Object *ob, struct Object *par);
+void   add_verts_to_dgroups(struct Object *ob, struct Object *par, int heat, int mirror);
+
+void   hide_selected_pose_bones(void);
+void   hide_unselected_pose_bones(void);
+void   show_all_pose_bones(void);
+
+int            bone_looper(struct Object *ob, struct Bone *bone, void *data,
+                               int (*bone_func)(struct Object *, struct Bone *, void *));
+
+void   undo_push_armature(char *name);
+void   armature_bone_rename(struct bArmature *arm, char *oldname, char *newname);
+void   armature_flip_names(void);
+void   armature_autoside_names(short axis);
+EditBone *armature_bone_get_mirrored(EditBone *ebo);
+void   transform_armature_mirror_update(void);
+
+void   hide_selected_armature_bones(void);
+void   hide_unselected_armature_bones(void);
+void   show_all_armature_bones(void);
+
+void   align_selected_bones(void);
+
+/* from autoarmature */
+void BIF_retargetArmature();
+void BIF_adjustRetarget();
+void BIF_freeRetarget();
+
+struct ReebArc;
+float calcVariance(struct ReebArc *arc, int start, int end, float v0[3], float n[3]);
+float calcDistance(struct ReebArc *arc, int start, int end, float head[3], float tail[3]);
+#endif
+
+#endif
+
+
+
diff --git a/source/blender/editors/space_view3d/drawarmature.c b/source/blender/editors/space_view3d/drawarmature.c
new file mode 100644 (file)
index 0000000..c10ceb7
--- /dev/null
@@ -0,0 +1,2588 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2005 by the Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "MEM_guardedalloc.h"
+
+#include "BMF_Api.h"
+
+#include "DNA_action_types.h"
+#include "DNA_armature_types.h"
+#include "DNA_constraint_types.h"
+#include "DNA_ID.h"
+#include "DNA_nla_types.h"
+#include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_space_types.h"
+#include "DNA_view3d_types.h"
+#include "DNA_userdef_types.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+
+#include "BKE_action.h"
+#include "BKE_armature.h"
+#include "BKE_constraint.h"
+#include "BKE_context.h"
+#include "BKE_depsgraph.h"
+#include "BKE_DerivedMesh.h"
+#include "BKE_global.h"
+#include "BKE_main.h"
+#include "BKE_object.h"
+#include "BKE_ipo.h"
+#include "BKE_utildefines.h"
+
+#include "BIF_editarmature.h"
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "UI_resources.h"
+
+#include "view3d_intern.h"
+
+/* XXX ***************** */
+int pose_channel_in_IK_chain() {return 0;}
+void ipo_to_keylist() {}
+void *ob_get_action() {return NULL;}
+void action_to_keylist() {}
+
+typedef struct ActKeyColumn {
+       struct ActKeyColumn *next, *prev;
+       short sel, handle_type;
+       float cfra;
+       
+       /* only while drawing - used to determine if long-keyframe needs to be drawn */
+       short modified;
+       short totcurve;
+} ActKeyColumn;
+typedef struct ActKeysInc {
+       struct Object *ob;                              /* if present, used to find action-scaled time */
+       float start, end;                               /* frames (global-time) to only consider keys between */
+} ActKeysInc;
+
+/* ******************** */
+
+
+/* *************** Armature Drawing - Coloring API ***************************** */
+
+/* global here is reset before drawing each bone */
+static ThemeWireColor *bcolor= NULL;
+
+/* values of colCode for set_pchan_glcolor */
+enum {
+       PCHAN_COLOR_NORMAL      = 0,            /* normal drawing */
+       PCHAN_COLOR_SOLID,                              /* specific case where "solid" color is needed */
+       PCHAN_COLOR_CONSTS,                             /* "constraint" colors (which may/may-not be suppressed) */
+       
+       PCHAN_COLOR_SPHEREBONE_BASE,    /* for the 'stick' of sphere (envelope) bones */
+       PCHAN_COLOR_SPHEREBONE_END,             /* for the ends of sphere (envelope) bones */
+       PCHAN_COLOR_LINEBONE                    /* for the middle of line-bones */
+};     
+
+/* This function sets the color-set for coloring a certain bone */
+static void set_pchan_colorset (Object *ob, bPoseChannel *pchan)
+{
+       bPose *pose= (ob) ? ob->pose : NULL;
+       bArmature *arm= (ob) ? ob->data : NULL;
+       bActionGroup *grp= NULL;
+       short color_index= 0;
+       
+       /* sanity check */
+       if (ELEM4(NULL, ob, arm, pose, pchan)) {
+               bcolor= NULL;
+               return;
+       }
+       
+       /* only try to set custom color if enabled for armature */
+       if (arm->flag & ARM_COL_CUSTOM) {       
+               /* currently, a bone can only use a custom color set if it's group (if it has one),
+                * has been set to use one
+                */
+               if (pchan->agrp_index) {
+                       grp= (bActionGroup *)BLI_findlink(&pose->agroups, (pchan->agrp_index - 1));
+                       if (grp)
+                               color_index= grp->customCol;
+               }
+       }
+       
+       /* bcolor is a pointer to the color set to use. If NULL, then the default
+        * color set (based on the theme colors for 3d-view) is used. 
+        */
+       if (color_index > 0) {
+               bTheme *btheme= U.themes.first;
+               bcolor= &btheme->tarm[(color_index - 1)];
+       }
+       else if (color_index == -1) {
+               /* use the group's own custom color set */
+               bcolor= (grp)? &grp->cs : NULL;
+       }
+       else 
+               bcolor= NULL;
+}
+
+/* This function is for brightening/darkening a given color (like UI_ThemeColorShade()) */
+static void cp_shade_color3ub (char cp[], int offset)
+{
+       int r, g, b;
+       
+       r= offset + (int) cp[0];
+       CLAMP(r, 0, 255);
+       g= offset + (int) cp[1];
+       CLAMP(g, 0, 255);
+       b= offset + (int) cp[2];
+       CLAMP(b, 0, 255);
+       
+       cp[0]= r;
+       cp[1]= g;
+       cp[2]= b;
+}
+
+/* This function sets the gl-color for coloring a certain bone (based on bcolor) */
+static short set_pchan_glColor (short colCode, int armflag, int boneflag, int constflag)
+{
+       switch (colCode) {
+       case PCHAN_COLOR_NORMAL:
+       {
+               if (bcolor) {
+                       char cp[3];
+                       
+                       if (boneflag & BONE_ACTIVE) {
+                               VECCOPY(cp, bcolor->active);
+                       }
+                       else if (boneflag & BONE_SELECTED) {
+                               VECCOPY(cp, bcolor->select);
+                       }
+                       else {
+                               /* a bit darker than solid */
+                               VECCOPY(cp, bcolor->solid);
+                               cp_shade_color3ub(cp, -50);
+                       }
+                       
+                       glColor3ub(cp[0], cp[1], cp[2]);
+               }
+               else {
+                       if (boneflag & BONE_ACTIVE) UI_ThemeColorShade(TH_BONE_POSE, 40);
+                       else if (boneflag & BONE_SELECTED) UI_ThemeColor(TH_BONE_POSE);
+                       else UI_ThemeColor(TH_WIRE);
+               }
+               
+               return 1;
+       }
+               break;
+       
+       case PCHAN_COLOR_SOLID:
+       {
+               if (bcolor) {
+                       char *cp= bcolor->solid;
+                       glColor3ub(cp[0], cp[1], cp[2]);
+               }
+               else 
+                       UI_ThemeColor(TH_BONE_SOLID);
+                       
+               return 1;
+       }
+               break;
+               
+       case PCHAN_COLOR_CONSTS:
+       {
+               if ( (bcolor == NULL) || (bcolor->flag & TH_WIRECOLOR_CONSTCOLS) ) {
+                       if (constflag & PCHAN_HAS_STRIDE) glColor4ub(0, 0, 200, 80);
+                       else if (constflag & PCHAN_HAS_TARGET) glColor4ub(255, 150, 0, 80);
+                       else if (constflag & PCHAN_HAS_IK) glColor4ub(255, 255, 0, 80);
+                       else if (constflag & PCHAN_HAS_CONST) glColor4ub(0, 255, 120, 80);
+                       else if (constflag) UI_ThemeColor4(TH_BONE_POSE);       // PCHAN_HAS_ACTION 
+                       
+                       return 1;
+               }
+               else 
+                       return 0;
+       }
+               break;
+               
+       case PCHAN_COLOR_SPHEREBONE_BASE:
+       {
+               if (bcolor) {
+                       char cp[3];
+                       
+                       if (boneflag & BONE_ACTIVE) {
+                               VECCOPY(cp, bcolor->active);
+                       }
+                       else if (boneflag & BONE_SELECTED) {
+                               VECCOPY(cp, bcolor->select);
+                       }
+                       else {
+                               VECCOPY(cp, bcolor->solid);
+                       }
+                       
+                       glColor3ub(cp[0], cp[1], cp[2]);
+               }
+               else {
+                       if (boneflag & BONE_ACTIVE) UI_ThemeColorShade(TH_BONE_POSE, 40);
+                       else if (boneflag & BONE_SELECTED) UI_ThemeColor(TH_BONE_POSE);
+                       else UI_ThemeColor(TH_BONE_SOLID);
+               }
+               
+               return 1;
+       }
+               break;
+       case PCHAN_COLOR_SPHEREBONE_END:
+       {
+               if (bcolor) {
+                       char cp[3];
+                       
+                       if (boneflag & BONE_ACTIVE) {
+                               VECCOPY(cp, bcolor->active);
+                               cp_shade_color3ub(cp, 10);
+                       }
+                       else if (boneflag & BONE_SELECTED) {
+                               VECCOPY(cp, bcolor->select);
+                               cp_shade_color3ub(cp, -30);
+                       }
+                       else {
+                               VECCOPY(cp, bcolor->solid);
+                               cp_shade_color3ub(cp, -30);
+                       }
+                       
+                       glColor3ub(cp[0], cp[1], cp[2]);
+               }
+               else {
+                       if (boneflag & BONE_ACTIVE) UI_ThemeColorShade(TH_BONE_POSE, 10);
+                       else if (boneflag & BONE_SELECTED) UI_ThemeColorShade(TH_BONE_POSE, -30);
+                       else UI_ThemeColorShade(TH_BONE_SOLID, -30);
+               }
+       }
+               break;
+               
+       case PCHAN_COLOR_LINEBONE:
+       {
+               /* inner part in background color or constraint */
+               if ( (constflag) && ((bcolor==NULL) || (bcolor->flag & TH_WIRECOLOR_CONSTCOLS)) ) {
+                       if (constflag & PCHAN_HAS_STRIDE) glColor3ub(0, 0, 200);
+                       else if (constflag & PCHAN_HAS_TARGET) glColor3ub(255, 150, 0);
+                       else if (constflag & PCHAN_HAS_IK) glColor3ub(255, 255, 0);
+                       else if (constflag & PCHAN_HAS_CONST) glColor3ub(0, 255, 120);
+                       else if (constflag) UI_ThemeColor(TH_BONE_POSE);        /* PCHAN_HAS_ACTION */ 
+               }
+               else {
+                       if (bcolor) {
+                               char *cp= bcolor->solid;
+                               glColor4ub(cp[0], cp[1], cp[2], 0.8);   
+                       }
+                       else
+                               UI_ThemeColorShade(TH_BACK, -30);
+               }
+               
+               return 1;
+       }
+               break;
+       }
+       
+       return 0;
+}
+
+
+/* *************** Armature drawing, helper calls for parts ******************* */
+
+/* half the cube, in Y */
+static float cube[8][3] = {
+{-1.0,  0.0, -1.0},
+{-1.0,  0.0,  1.0},
+{-1.0,  1.0,  1.0},
+{-1.0,  1.0, -1.0},
+{ 1.0,  0.0, -1.0},
+{ 1.0,  0.0,  1.0},
+{ 1.0,  1.0,  1.0},
+{ 1.0,  1.0, -1.0},
+};
+
+static void drawsolidcube_size(float xsize, float ysize, float zsize)
+{
+       static GLuint displist=0;
+       float n[3];
+       
+       glScalef(xsize, ysize, zsize);
+       
+       n[0]=0; n[1]=0; n[2]=0;
+
+       if(displist==0) {
+               displist= glGenLists(1);
+               glNewList(displist, GL_COMPILE_AND_EXECUTE);
+
+               glBegin(GL_QUADS);
+               n[0]= -1.0;
+               glNormal3fv(n); 
+               glVertex3fv(cube[0]); glVertex3fv(cube[1]); glVertex3fv(cube[2]); glVertex3fv(cube[3]);
+               n[0]=0;
+               n[1]= -1.0;
+               glNormal3fv(n); 
+               glVertex3fv(cube[0]); glVertex3fv(cube[4]); glVertex3fv(cube[5]); glVertex3fv(cube[1]);
+               n[1]=0;
+               n[0]= 1.0;
+               glNormal3fv(n); 
+               glVertex3fv(cube[4]); glVertex3fv(cube[7]); glVertex3fv(cube[6]); glVertex3fv(cube[5]);
+               n[0]=0;
+               n[1]= 1.0;
+               glNormal3fv(n); 
+               glVertex3fv(cube[7]); glVertex3fv(cube[3]); glVertex3fv(cube[2]); glVertex3fv(cube[6]);
+               n[1]=0;
+               n[2]= 1.0;
+               glNormal3fv(n); 
+               glVertex3fv(cube[1]); glVertex3fv(cube[5]); glVertex3fv(cube[6]); glVertex3fv(cube[2]);
+               n[2]=0;
+               n[2]= -1.0;
+               glNormal3fv(n); 
+               glVertex3fv(cube[7]); glVertex3fv(cube[4]); glVertex3fv(cube[0]); glVertex3fv(cube[3]);
+               glEnd();
+
+               glEndList();
+       }
+       else glCallList(displist);
+       
+}
+
+static void drawcube_size(float xsize, float ysize, float zsize)
+{
+       static GLuint displist=0;
+       
+       glScalef(xsize, ysize, zsize);
+       
+       if(displist == 0) {
+               displist= glGenLists(1);
+               glNewList(displist, GL_COMPILE_AND_EXECUTE);
+               
+               glBegin(GL_LINE_STRIP);
+               glVertex3fv(cube[0]); glVertex3fv(cube[1]);glVertex3fv(cube[2]); glVertex3fv(cube[3]);
+               glVertex3fv(cube[0]); glVertex3fv(cube[4]);glVertex3fv(cube[5]); glVertex3fv(cube[6]);
+               glVertex3fv(cube[7]); glVertex3fv(cube[4]);
+               glEnd();
+               
+               glBegin(GL_LINES);
+               glVertex3fv(cube[1]); glVertex3fv(cube[5]);
+               glVertex3fv(cube[2]); glVertex3fv(cube[6]);
+               glVertex3fv(cube[3]); glVertex3fv(cube[7]);
+               glEnd();
+               
+               glEndList();
+       }
+       else glCallList(displist);
+       
+}
+
+
+static void draw_bonevert(void)
+{
+       static GLuint displist=0;
+       
+       if (displist == 0) {
+               GLUquadricObj   *qobj;
+               
+               displist= glGenLists(1);
+               glNewList(displist, GL_COMPILE_AND_EXECUTE);
+                       
+               glPushMatrix();
+               
+               qobj    = gluNewQuadric(); 
+               gluQuadricDrawStyle(qobj, GLU_SILHOUETTE); 
+               gluDisk(qobj, 0.0,  0.05, 16, 1);
+               
+               glRotatef(90, 0, 1, 0);
+               gluDisk(qobj, 0.0,  0.05, 16, 1);
+               
+               glRotatef(90, 1, 0, 0);
+               gluDisk(qobj, 0.0,  0.05, 16, 1);
+               
+               gluDeleteQuadric(qobj);  
+               
+               glPopMatrix();
+               glEndList();
+       }
+       else 
+               glCallList(displist);
+}
+
+static void draw_bonevert_solid(void)
+{
+       static GLuint displist=0;
+       
+       if (displist == 0) {
+               GLUquadricObj   *qobj;
+               
+               displist= glGenLists(1);
+               glNewList(displist, GL_COMPILE_AND_EXECUTE);
+               
+               qobj    = gluNewQuadric();
+               gluQuadricDrawStyle(qobj, GLU_FILL); 
+               glShadeModel(GL_SMOOTH);
+               gluSphere( qobj, 0.05, 8, 5);
+               glShadeModel(GL_FLAT);
+               gluDeleteQuadric(qobj);  
+               
+               glEndList();
+       }
+       else 
+               glCallList(displist);
+}
+
+static void draw_bone_octahedral()
+{
+       static GLuint displist=0;
+       
+       if (displist == 0) {
+               float vec[6][3];        
+               
+               displist= glGenLists(1);
+               glNewList(displist, GL_COMPILE_AND_EXECUTE);
+               
+               vec[0][0]= vec[0][1]= vec[0][2]= 0.0;
+               vec[5][0]= vec[5][2]= 0.0; vec[5][1]= 1.0;
+               
+               vec[1][0]= 0.1; vec[1][2]= 0.1; vec[1][1]= 0.1;
+               vec[2][0]= 0.1; vec[2][2]= -0.1; vec[2][1]= 0.1;
+               vec[3][0]= -0.1; vec[3][2]= -0.1; vec[3][1]= 0.1;
+               vec[4][0]= -0.1; vec[4][2]= 0.1; vec[4][1]= 0.1;
+               
+               /*      Section 1, sides */
+               glBegin(GL_LINE_LOOP);
+               glVertex3fv(vec[0]);
+               glVertex3fv(vec[1]);
+               glVertex3fv(vec[5]);
+               glVertex3fv(vec[3]);
+               glVertex3fv(vec[0]);
+               glVertex3fv(vec[4]);
+               glVertex3fv(vec[5]);
+               glVertex3fv(vec[2]);
+               glEnd();
+               
+               /*      Section 1, square */
+               glBegin(GL_LINE_LOOP);
+               glVertex3fv(vec[1]);
+               glVertex3fv(vec[2]);
+               glVertex3fv(vec[3]);
+               glVertex3fv(vec[4]);
+               glEnd();
+               
+               glEndList();
+       }
+       else 
+               glCallList(displist);
+}      
+
+static void draw_bone_solid_octahedral(void)
+{
+       static GLuint displist=0;
+       
+       if (displist == 0) {
+               float vec[6][3], nor[3];        
+               
+               displist= glGenLists(1);
+               glNewList(displist, GL_COMPILE_AND_EXECUTE);
+               
+               vec[0][0]= vec[0][1]= vec[0][2]= 0.0;
+               vec[5][0]= vec[5][2]= 0.0; vec[5][1]= 1.0;
+               
+               vec[1][0]= 0.1; vec[1][2]= 0.1; vec[1][1]= 0.1;
+               vec[2][0]= 0.1; vec[2][2]= -0.1; vec[2][1]= 0.1;
+               vec[3][0]= -0.1; vec[3][2]= -0.1; vec[3][1]= 0.1;
+               vec[4][0]= -0.1; vec[4][2]= 0.1; vec[4][1]= 0.1;
+               
+               
+               glBegin(GL_TRIANGLES);
+               /* bottom */
+               CalcNormFloat(vec[2], vec[1], vec[0], nor);
+               glNormal3fv(nor);
+               glVertex3fv(vec[2]);glVertex3fv(vec[1]);glVertex3fv(vec[0]);
+               
+               CalcNormFloat(vec[3], vec[2], vec[0], nor);
+               glNormal3fv(nor);
+               glVertex3fv(vec[3]);glVertex3fv(vec[2]);glVertex3fv(vec[0]);
+               
+               CalcNormFloat(vec[4], vec[3], vec[0], nor);
+               glNormal3fv(nor);
+               glVertex3fv(vec[4]);glVertex3fv(vec[3]);glVertex3fv(vec[0]);
+
+               CalcNormFloat(vec[1], vec[4], vec[0], nor);
+               glNormal3fv(nor);
+               glVertex3fv(vec[1]);glVertex3fv(vec[4]);glVertex3fv(vec[0]);
+
+               /* top */
+               CalcNormFloat(vec[5], vec[1], vec[2], nor);
+               glNormal3fv(nor);
+               glVertex3fv(vec[5]);glVertex3fv(vec[1]);glVertex3fv(vec[2]);
+               
+               CalcNormFloat(vec[5], vec[2], vec[3], nor);
+               glNormal3fv(nor);
+               glVertex3fv(vec[5]);glVertex3fv(vec[2]);glVertex3fv(vec[3]);
+               
+               CalcNormFloat(vec[5], vec[3], vec[4], nor);
+               glNormal3fv(nor);
+               glVertex3fv(vec[5]);glVertex3fv(vec[3]);glVertex3fv(vec[4]);
+               
+               CalcNormFloat(vec[5], vec[4], vec[1], nor);
+               glNormal3fv(nor);
+               glVertex3fv(vec[5]);glVertex3fv(vec[4]);glVertex3fv(vec[1]);
+               
+               glEnd();
+               
+               glEndList();
+       }
+       else 
+               glCallList(displist);
+}      
+
+/* *************** Armature drawing, bones ******************* */
+
+
+static void draw_bone_points(int dt, int armflag, unsigned int boneflag, int id)
+{
+       /*      Draw root point if we are not connected */
+       if ((boneflag & BONE_CONNECTED)==0) {
+               if (id != -1)
+                       glLoadName(id | BONESEL_ROOT);
+               
+               if(dt <= OB_WIRE) {
+                       if (armflag & ARM_EDITMODE) {
+                               if (boneflag & BONE_ROOTSEL) UI_ThemeColor(TH_VERTEX_SELECT);
+                               else UI_ThemeColor(TH_VERTEX);
+                       }
+               }
+               else {
+                       if (armflag & ARM_POSEMODE) 
+                               set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, 0);
+                       else
+                               UI_ThemeColor(TH_BONE_SOLID);
+               }
+               
+               if (dt > OB_WIRE) 
+                       draw_bonevert_solid();
+               else 
+                       draw_bonevert();
+       }
+       
+       /*      Draw tip point */
+       if (id != -1)
+               glLoadName(id | BONESEL_TIP);
+       
+       if (dt <= OB_WIRE) {
+               if (armflag & ARM_EDITMODE) {
+                       if (boneflag & BONE_TIPSEL) UI_ThemeColor(TH_VERTEX_SELECT);
+                       else UI_ThemeColor(TH_VERTEX);
+               }
+       }
+       else {
+               if (armflag & ARM_POSEMODE) 
+                       set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, 0);
+               else
+                       UI_ThemeColor(TH_BONE_SOLID);
+       }
+       
+       glTranslatef(0.0, 1.0, 0.0);
+       if (dt > OB_WIRE) 
+               draw_bonevert_solid();
+       else 
+               draw_bonevert();
+       glTranslatef(0.0, -1.0, 0.0);
+       
+}
+
+/* 16 values of sin function (still same result!) */
+static float si[16] = {
+       0.00000000,
+       0.20129852, 0.39435585,
+       0.57126821, 0.72479278,
+       0.84864425, 0.93775213,
+       0.98846832, 0.99871650,
+       0.96807711, 0.89780453,
+       0.79077573, 0.65137248,
+       0.48530196, 0.29936312,
+       0.10116832
+};
+/* 16 values of cos function (still same result!) */
+static float co[16] ={
+       1.00000000,
+       0.97952994, 0.91895781,
+       0.82076344, 0.68896691,
+       0.52896401, 0.34730525,
+       0.15142777, -0.05064916,
+       -0.25065253, -0.44039415,
+       -0.61210598, -0.75875812,
+       -0.87434661, -0.95413925,
+       -0.99486932
+};
+
+
+
+/* smat, imat = mat & imat to draw screenaligned */
+static void draw_sphere_bone_dist(float smat[][4], float imat[][4], int boneflag, bPoseChannel *pchan, EditBone *ebone)
+{
+       float head, tail, length, dist;
+       float *headvec, *tailvec, dirvec[3];
+       
+       /* figure out the sizes of spheres */
+       if (ebone) {
+               /* this routine doesn't call set_matrix_editbone() that calculates it */
+               ebone->length = VecLenf(ebone->head, ebone->tail);
+               
+               length= ebone->length;
+               tail= ebone->rad_tail;
+               dist= ebone->dist;
+               if (ebone->parent && (ebone->flag & BONE_CONNECTED))
+                       head= ebone->parent->rad_tail;
+               else
+                       head= ebone->rad_head;
+               headvec= ebone->head;
+               tailvec= ebone->tail;
+       }
+       else {
+               length= pchan->bone->length;
+               tail= pchan->bone->rad_tail;
+               dist= pchan->bone->dist;
+               if (pchan->parent && (pchan->bone->flag & BONE_CONNECTED))
+                       head= pchan->parent->bone->rad_tail;
+               else
+                       head= pchan->bone->rad_head;
+               headvec= pchan->pose_head;
+               tailvec= pchan->pose_tail;
+       }
+       
+       /* ***** draw it ***** */
+       
+       /* move vector to viewspace */
+       VecSubf(dirvec, tailvec, headvec);
+       Mat4Mul3Vecfl(smat, dirvec);
+       /* clear zcomp */
+       dirvec[2]= 0.0;
+       /* move vector back */
+       Mat4Mul3Vecfl(imat, dirvec);
+       
+       if (0.0f != Normalize(dirvec)) {
+               float norvec[3], vec1[3], vec2[3], vec[3];
+               int a;
+               
+               //VecMulf(dirvec, head);
+               Crossf(norvec, dirvec, imat[2]);
+               
+               glBegin(GL_QUAD_STRIP);
+               
+               for (a=0; a<16; a++) {
+                       vec[0]= - *(si+a) * dirvec[0] + *(co+a) * norvec[0];
+                       vec[1]= - *(si+a) * dirvec[1] + *(co+a) * norvec[1];
+                       vec[2]= - *(si+a) * dirvec[2] + *(co+a) * norvec[2];
+                       
+                       vec1[0]= headvec[0] + head*vec[0];
+                       vec1[1]= headvec[1] + head*vec[1];
+                       vec1[2]= headvec[2] + head*vec[2];
+                       vec2[0]= headvec[0] + (head+dist)*vec[0];
+                       vec2[1]= headvec[1] + (head+dist)*vec[1];
+                       vec2[2]= headvec[2] + (head+dist)*vec[2];
+                       
+                       glColor4ub(255, 255, 255, 50);
+                       glVertex3fv(vec1);
+                       //glColor4ub(255, 255, 255, 0);
+                       glVertex3fv(vec2);
+               }
+               
+               for (a=15; a>=0; a--) {
+                       vec[0]= *(si+a) * dirvec[0] + *(co+a) * norvec[0];
+                       vec[1]= *(si+a) * dirvec[1] + *(co+a) * norvec[1];
+                       vec[2]= *(si+a) * dirvec[2] + *(co+a) * norvec[2];
+                       
+                       vec1[0]= tailvec[0] + tail*vec[0];
+                       vec1[1]= tailvec[1] + tail*vec[1];
+                       vec1[2]= tailvec[2] + tail*vec[2];
+                       vec2[0]= tailvec[0] + (tail+dist)*vec[0];
+                       vec2[1]= tailvec[1] + (tail+dist)*vec[1];
+                       vec2[2]= tailvec[2] + (tail+dist)*vec[2];
+                       
+                       //glColor4ub(255, 255, 255, 50);
+                       glVertex3fv(vec1);
+                       //glColor4ub(255, 255, 255, 0);
+                       glVertex3fv(vec2);
+               }
+               /* make it cyclic... */
+               
+               vec[0]= - *(si) * dirvec[0] + *(co) * norvec[0];
+               vec[1]= - *(si) * dirvec[1] + *(co) * norvec[1];
+               vec[2]= - *(si) * dirvec[2] + *(co) * norvec[2];
+               
+               vec1[0]= headvec[0] + head*vec[0];
+               vec1[1]= headvec[1] + head*vec[1];
+               vec1[2]= headvec[2] + head*vec[2];
+               vec2[0]= headvec[0] + (head+dist)*vec[0];
+               vec2[1]= headvec[1] + (head+dist)*vec[1];
+               vec2[2]= headvec[2] + (head+dist)*vec[2];
+               
+               //glColor4ub(255, 255, 255, 50);
+               glVertex3fv(vec1);
+               //glColor4ub(255, 255, 255, 0);
+               glVertex3fv(vec2);
+               
+               glEnd();
+       }
+}
+
+
+/* smat, imat = mat & imat to draw screenaligned */
+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)
+{
+       float head, tail, length;
+       float *headvec, *tailvec, dirvec[3];
+       
+       /* figure out the sizes of spheres */
+       if (ebone) {
+               /* this routine doesn't call set_matrix_editbone() that calculates it */
+               ebone->length = VecLenf(ebone->head, ebone->tail);
+               
+               length= ebone->length;
+               tail= ebone->rad_tail;
+               if (ebone->parent && (boneflag & BONE_CONNECTED))
+                       head= ebone->parent->rad_tail;
+               else
+                       head= ebone->rad_head;
+               headvec= ebone->head;
+               tailvec= ebone->tail;
+       }
+       else {
+               length= pchan->bone->length;
+               tail= pchan->bone->rad_tail;
+               if ((pchan->parent) && (boneflag & BONE_CONNECTED))
+                       head= pchan->parent->bone->rad_tail;
+               else
+                       head= pchan->bone->rad_head;
+               headvec= pchan->pose_head;
+               tailvec= pchan->pose_tail;
+       }
+       
+       /* sphere root color */
+       if (armflag & ARM_EDITMODE) {
+               if (boneflag & BONE_ROOTSEL) UI_ThemeColor(TH_VERTEX_SELECT);
+               else UI_ThemeColor(TH_VERTEX);
+       }
+       else if (armflag & ARM_POSEMODE)
+               set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
+       
+       /*      Draw root point if we are not connected */
+       if ((boneflag & BONE_CONNECTED)==0) {
+               if (id != -1)
+                       glLoadName(id | BONESEL_ROOT);
+               
+               drawcircball(GL_LINE_LOOP, headvec, head, imat);
+       }
+       
+       /*      Draw tip point */
+       if (armflag & ARM_EDITMODE) {
+               if (boneflag & BONE_TIPSEL) UI_ThemeColor(TH_VERTEX_SELECT);
+               else UI_ThemeColor(TH_VERTEX);
+       }
+       
+       if (id != -1)
+               glLoadName(id | BONESEL_TIP);
+       
+       drawcircball(GL_LINE_LOOP, tailvec, tail, imat);
+       
+       /* base */
+       if (armflag & ARM_EDITMODE) {
+               if (boneflag & BONE_SELECTED) UI_ThemeColor(TH_SELECT);
+               else UI_ThemeColor(TH_WIRE);
+       }
+       
+       VecSubf(dirvec, tailvec, headvec);
+       
+       /* move vector to viewspace */
+       Mat4Mul3Vecfl(smat, dirvec);
+       /* clear zcomp */
+       dirvec[2]= 0.0;
+       /* move vector back */
+       Mat4Mul3Vecfl(imat, dirvec);
+       
+       if (0.0f != Normalize(dirvec)) {
+               float norvech[3], norvect[3], vec[3];
+               
+               VECCOPY(vec, dirvec);
+               
+               VecMulf(dirvec, head);
+               Crossf(norvech, dirvec, imat[2]);
+               
+               VecMulf(vec, tail);
+               Crossf(norvect, vec, imat[2]);
+               
+               if (id != -1)
+                       glLoadName(id | BONESEL_BONE);
+               
+               glBegin(GL_LINES);
+               vec[0]= headvec[0] + norvech[0];
+               vec[1]= headvec[1] + norvech[1];
+               vec[2]= headvec[2] + norvech[2];
+               glVertex3fv(vec);
+               vec[0]= tailvec[0] + norvect[0];
+               vec[1]= tailvec[1] + norvect[1];
+               vec[2]= tailvec[2] + norvect[2];
+               glVertex3fv(vec);
+               vec[0]= headvec[0] - norvech[0];
+               vec[1]= headvec[1] - norvech[1];
+               vec[2]= headvec[2] - norvech[2];
+               glVertex3fv(vec);
+               vec[0]= tailvec[0] - norvect[0];
+               vec[1]= tailvec[1] - norvect[1];
+               vec[2]= tailvec[2] - norvect[2];
+               glVertex3fv(vec);
+               
+               glEnd();
+       }
+}
+
+/* does wire only for outline selecting */
+static void draw_sphere_bone(int dt, int armflag, int boneflag, int constflag, unsigned int id, bPoseChannel *pchan, EditBone *ebone)
+{
+       GLUquadricObj   *qobj;
+       float head, tail, length;
+       float fac1, fac2;
+       
+       glPushMatrix();
+       qobj    = gluNewQuadric();
+
+       /* figure out the sizes of spheres */
+       if (ebone) {
+               length= ebone->length;
+               tail= ebone->rad_tail;
+               if (ebone->parent && (boneflag & BONE_CONNECTED))
+                       head= ebone->parent->rad_tail;
+               else
+                       head= ebone->rad_head;
+       }
+       else {
+               length= pchan->bone->length;
+               tail= pchan->bone->rad_tail;
+               if (pchan->parent && (boneflag & BONE_CONNECTED))
+                       head= pchan->parent->bone->rad_tail;
+               else
+                       head= pchan->bone->rad_head;
+       }
+       
+       /* move to z-axis space */
+       glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);
+
+       if (dt==OB_SOLID) {
+               /* set up solid drawing */
+               glEnable(GL_COLOR_MATERIAL);
+               glEnable(GL_LIGHTING);
+               
+               gluQuadricDrawStyle(qobj, GLU_FILL); 
+               glShadeModel(GL_SMOOTH);
+       }
+       else {
+               gluQuadricDrawStyle(qobj, GLU_SILHOUETTE); 
+       }
+       
+       /* sphere root color */
+       if (armflag & ARM_EDITMODE) {
+               if (boneflag & BONE_ROOTSEL) UI_ThemeColor(TH_VERTEX_SELECT);
+               else UI_ThemeColorShade(TH_BONE_SOLID, -30);
+       }
+       else if (armflag & ARM_POSEMODE)
+               set_pchan_glColor(PCHAN_COLOR_SPHEREBONE_END, armflag, boneflag, constflag);
+       else if (dt==OB_SOLID) 
+               UI_ThemeColorShade(TH_BONE_SOLID, -30);
+       
+       /*      Draw root point if we are not connected */
+       if ((boneflag & BONE_CONNECTED)==0) {
+               if (id != -1)
+                       glLoadName(id | BONESEL_ROOT);
+               gluSphere(qobj, head, 16, 10);
+       }
+       
+       /*      Draw tip point */
+       if (armflag & ARM_EDITMODE) {
+               if (boneflag & BONE_TIPSEL) UI_ThemeColor(TH_VERTEX_SELECT);
+               else UI_ThemeColorShade(TH_BONE_SOLID, -30);
+       }
+
+       if (id != -1)
+               glLoadName(id | BONESEL_TIP);
+       
+       glTranslatef(0.0, 0.0, length);
+       gluSphere(qobj, tail, 16, 10);
+       glTranslatef(0.0, 0.0, -length);
+       
+       /* base */
+       if (armflag & ARM_EDITMODE) {
+               if (boneflag & BONE_SELECTED) UI_ThemeColor(TH_SELECT);
+               else UI_ThemeColor(TH_BONE_SOLID);
+       }
+       else if (armflag & ARM_POSEMODE)
+               set_pchan_glColor(PCHAN_COLOR_SPHEREBONE_BASE, armflag, boneflag, constflag);
+       else if (dt == OB_SOLID)
+               UI_ThemeColor(TH_BONE_SOLID);
+       
+       fac1= (length-head)/length;
+       fac2= (length-tail)/length;
+       
+       if (length > (head+tail)) {
+               if (id != -1)
+                       glLoadName (id | BONESEL_BONE);
+               
+               glEnable(GL_POLYGON_OFFSET_FILL);
+               glPolygonOffset(-1.0, -1.0);
+               
+               glTranslatef(0.0f, 0.0f, head);
+               gluCylinder(qobj, fac1*head + (1.0f-fac1)*tail, fac2*tail + (1.0f-fac2)*head, length-head-tail, 16, 1);
+               glTranslatef(0.0f, 0.0f, -head);
+               
+               glDisable(GL_POLYGON_OFFSET_FILL);
+               
+               /* draw sphere on extrema */
+               glTranslatef(0.0f, 0.0f, length-tail);
+               gluSphere(qobj, fac2*tail + (1.0f-fac2)*head, 16, 10);
+               glTranslatef(0.0f, 0.0f, -length+tail);
+               
+               glTranslatef(0.0f, 0.0f, head);
+               gluSphere(qobj, fac1*head + (1.0f-fac1)*tail, 16, 10);
+       }
+       else {          
+               /* 1 sphere in center */
+               glTranslatef(0.0f, 0.0f, (head + length-tail)/2.0);
+               gluSphere(qobj, fac1*head + (1.0f-fac1)*tail, 16, 10);
+       }
+       
+       /* restore */
+       if (dt==OB_SOLID) {
+               glShadeModel(GL_FLAT);
+               glDisable(GL_LIGHTING);
+               glDisable(GL_COLOR_MATERIAL);
+       }
+       
+       glPopMatrix();
+       gluDeleteQuadric(qobj);  
+}
+
+static GLubyte bm_dot6[]= {0x0, 0x18, 0x3C, 0x7E, 0x7E, 0x3C, 0x18, 0x0}; 
+static GLubyte bm_dot8[]= {0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C}; 
+
+static GLubyte bm_dot5[]= {0x0, 0x0, 0x10, 0x38, 0x7c, 0x38, 0x10, 0x0}; 
+static GLubyte bm_dot7[]= {0x0, 0x38, 0x7C, 0xFE, 0xFE, 0xFE, 0x7C, 0x38}; 
+
+
+static void draw_line_bone(int armflag, int boneflag, int constflag, unsigned int id, bPoseChannel *pchan, EditBone *ebone)
+{
+       float length;
+       
+       glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+       
+       if (pchan) 
+               length= pchan->bone->length;
+       else 
+               length= ebone->length;
+       
+       glPushMatrix();
+       glScalef(length, length, length);
+       
+       /* this chunk not in object mode */
+       if (armflag & (ARM_EDITMODE|ARM_POSEMODE)) {
+               glLineWidth(4.0);
+               if (armflag & ARM_POSEMODE)
+                       set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
+               else if (armflag & ARM_EDITMODE) {
+                       UI_ThemeColor(TH_WIRE);
+               }
+               
+               /*      Draw root point if we are not connected */
+               if ((boneflag & BONE_CONNECTED)==0) {
+                       if (G.f & G_PICKSEL) {  // no bitmap in selection mode, crashes 3d cards...
+                               glLoadName (id | BONESEL_ROOT);
+                               glBegin(GL_POINTS);
+                               glVertex3f(0.0f, 0.0f, 0.0f);
+                               glEnd();
+                       }
+                       else {
+                               glRasterPos3f(0.0f, 0.0f, 0.0f);
+                               glBitmap(8, 8, 4, 4, 0, 0, bm_dot8);
+                       }
+               }
+               
+               if (id != -1)
+                       glLoadName((GLuint) id|BONESEL_BONE);
+               
+               glBegin(GL_LINES);
+               glVertex3f(0.0f, 0.0f, 0.0f);
+               glVertex3f(0.0f, 1.0f, 0.0f);
+               glEnd();
+               
+               /* tip */
+               if (G.f & G_PICKSEL) {  
+                       /* no bitmap in selection mode, crashes 3d cards... */
+                       glLoadName(id | BONESEL_TIP);
+                       glBegin(GL_POINTS);
+                       glVertex3f(0.0f, 1.0f, 0.0f);
+                       glEnd();
+               }
+               else {
+                       glRasterPos3f(0.0f, 1.0f, 0.0f);
+                       glBitmap(8, 8, 4, 4, 0, 0, bm_dot7);
+               }
+               
+               /* further we send no names */
+               if (id != -1)
+                       glLoadName(id & 0xFFFF);        /* object tag, for bordersel optim */
+               
+               if (armflag & ARM_POSEMODE)
+                       set_pchan_glColor(PCHAN_COLOR_LINEBONE, armflag, boneflag, constflag);
+       }
+       
+       glLineWidth(2.0);
+       
+       /*Draw root point if we are not connected */
+       if ((boneflag & BONE_CONNECTED)==0) {
+               if ((G.f & G_PICKSEL)==0) {     
+                       /* no bitmap in selection mode, crashes 3d cards... */
+                       if (armflag & ARM_EDITMODE) {
+                               if (boneflag & BONE_ROOTSEL) UI_ThemeColor(TH_VERTEX_SELECT);
+                               else UI_ThemeColor(TH_VERTEX);
+                       }
+                       glRasterPos3f(0.0f, 0.0f, 0.0f);
+                       glBitmap(8, 8, 4, 4, 0, 0, bm_dot6);
+               }
+       }
+       
+       if (armflag & ARM_EDITMODE) {
+               if (boneflag & BONE_SELECTED) UI_ThemeColor(TH_EDGE_SELECT);
+               else UI_ThemeColorShade(TH_BACK, -30);
+       }
+       glBegin(GL_LINES);
+       glVertex3f(0.0f, 0.0f, 0.0f);
+       glVertex3f(0.0f, 1.0f, 0.0f);
+       glEnd();
+       
+       /* tip */
+       if ((G.f & G_PICKSEL)==0) {     
+               /* no bitmap in selection mode, crashes 3d cards... */
+               if (armflag & ARM_EDITMODE) {
+                       if (boneflag & BONE_TIPSEL) UI_ThemeColor(TH_VERTEX_SELECT);
+                       else UI_ThemeColor(TH_VERTEX);
+               }
+               glRasterPos3f(0.0f, 1.0f, 0.0f);
+               glBitmap(8, 8, 4, 4, 0, 0, bm_dot5);
+       }
+       
+       glLineWidth(1.0);
+       
+       glPopMatrix();
+}
+
+static void draw_b_bone_boxes(int dt, bPoseChannel *pchan, float xwidth, float length, float zwidth)
+{
+       int segments= 0;
+       
+       if (pchan) 
+               segments= pchan->bone->segments;
+       
+       if ((segments > 1) && (pchan)) {
+               float dlen= length/(float)segments;
+               Mat4 *bbone= b_bone_spline_setup(pchan, 0);
+               int a;
+               
+               for (a=0; a<segments; a++, bbone++) {
+                       glPushMatrix();
+                       glMultMatrixf(bbone->mat);
+                       if (dt==OB_SOLID) drawsolidcube_size(xwidth, dlen, zwidth);
+                       else drawcube_size(xwidth, dlen, zwidth);
+                       glPopMatrix();
+               }
+       }
+       else {
+               glPushMatrix();
+               if (dt==OB_SOLID) drawsolidcube_size(xwidth, length, zwidth);
+               else drawcube_size(xwidth, length, zwidth);
+               glPopMatrix();
+       }
+}
+
+static void draw_b_bone(int dt, int armflag, int boneflag, int constflag, unsigned int id, bPoseChannel *pchan, EditBone *ebone)
+{
+       float xwidth, length, zwidth;
+       
+       if (pchan) {
+               xwidth= pchan->bone->xwidth;
+               length= pchan->bone->length;
+               zwidth= pchan->bone->zwidth;
+       }
+       else {
+               xwidth= ebone->xwidth;
+               length= ebone->length;
+               zwidth= ebone->zwidth;
+       }
+       
+       /* draw points only if... */
+       if (armflag & ARM_EDITMODE) {
+               /* move to unitspace */
+               glPushMatrix();
+               glScalef(length, length, length);
+               draw_bone_points(dt, armflag, boneflag, id);
+               glPopMatrix();
+               length*= 0.95f; // make vertices visible
+       }
+
+       /* colors for modes */
+       if (armflag & ARM_POSEMODE) {
+               if (dt <= OB_WIRE)
+                       set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
+               else 
+                       set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, constflag);
+       }
+       else if (armflag & ARM_EDITMODE) {
+               if (dt==OB_WIRE) {
+                       if (boneflag & BONE_ACTIVE) UI_ThemeColor(TH_EDGE_SELECT);
+                       else if (boneflag & BONE_SELECTED) UI_ThemeColorShade(TH_EDGE_SELECT, -20);
+                       else UI_ThemeColor(TH_WIRE);
+               }
+               else 
+                       UI_ThemeColor(TH_BONE_SOLID);
+       }
+       
+       if (id != -1) {
+               glLoadName ((GLuint) id|BONESEL_BONE);
+       }
+       
+       /* set up solid drawing */
+       if (dt > OB_WIRE) {
+               glEnable(GL_COLOR_MATERIAL);
+               glEnable(GL_LIGHTING);
+               
+               if (armflag & ARM_POSEMODE)
+                       set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, constflag);
+               else
+                       UI_ThemeColor(TH_BONE_SOLID);
+               
+               draw_b_bone_boxes(OB_SOLID, pchan, xwidth, length, zwidth);
+               
+               /* disable solid drawing */
+               glDisable(GL_COLOR_MATERIAL);
+               glDisable(GL_LIGHTING);
+       }
+       else {  
+               /* wire */
+               if (armflag & ARM_POSEMODE) {
+                       if (constflag) {
+                               /* set constraint colors */
+                               if (set_pchan_glColor(PCHAN_COLOR_CONSTS, armflag, boneflag, constflag)) {
+                                       glEnable(GL_BLEND);
+                                       
+                                       draw_b_bone_boxes(OB_SOLID, pchan, xwidth, length, zwidth);
+                                       
+                                       glDisable(GL_BLEND);
+                               }
+                               
+                               /* restore colors */
+                               set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
+                       }
+               }               
+               
+               draw_b_bone_boxes(OB_WIRE, pchan, xwidth, length, zwidth);              
+       }
+}
+
+static void draw_bone(int dt, int armflag, int boneflag, int constflag, unsigned int id, float length)
+{
+       
+       /*      Draw a 3d octahedral bone, we use normalized space based on length,
+           for glDisplayLists */
+       
+       glScalef(length, length, length);
+
+       /* set up solid drawing */
+       if (dt > OB_WIRE) {
+               glEnable(GL_COLOR_MATERIAL);
+               glEnable(GL_LIGHTING);
+               UI_ThemeColor(TH_BONE_SOLID);
+       }
+       
+       /* colors for posemode */
+       if (armflag & ARM_POSEMODE) {
+               if (dt <= OB_WIRE)
+                       set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
+               else 
+                       set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, constflag);
+       }
+       
+       
+       draw_bone_points(dt, armflag, boneflag, id);
+       
+       /* now draw the bone itself */
+       if (id != -1) {
+               glLoadName((GLuint) id|BONESEL_BONE);
+       }
+       
+       /* wire? */
+       if (dt <= OB_WIRE) {
+               /* colors */
+               if (armflag & ARM_EDITMODE) {
+                       if (boneflag & BONE_ACTIVE) UI_ThemeColor(TH_EDGE_SELECT);
+                       else if (boneflag & BONE_SELECTED) UI_ThemeColorShade(TH_EDGE_SELECT, -20);
+                       else UI_ThemeColor(TH_WIRE);
+               }
+               else if (armflag & ARM_POSEMODE) {
+                       if (constflag) {
+                               /* draw constraint colors */
+                               if (set_pchan_glColor(PCHAN_COLOR_CONSTS, armflag, boneflag, constflag)) {      
+                                       glEnable(GL_BLEND);
+                                       
+                                       draw_bone_solid_octahedral();
+                                       
+                                       glDisable(GL_BLEND);
+                               }
+                               
+                               /* restore colors */
+                               set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, constflag);
+                       }
+               }               
+               draw_bone_octahedral();
+       }
+       else {  
+               /* solid */
+               if (armflag & ARM_POSEMODE)
+                       set_pchan_glColor(PCHAN_COLOR_SOLID, armflag, boneflag, constflag);
+               else
+                       UI_ThemeColor(TH_BONE_SOLID);
+               draw_bone_solid_octahedral();
+       }
+
+       /* disable solid drawing */
+       if (dt > OB_WIRE) {
+               glDisable(GL_COLOR_MATERIAL);
+               glDisable(GL_LIGHTING);
+       }
+}
+
+static void draw_custom_bone(Scene *scene, View3D *v3d, Object *ob, int dt, int armflag, int boneflag, unsigned int id, float length)
+{
+       if(ob==NULL) return;
+       
+       glScalef(length, length, length);
+       
+       /* colors for posemode */
+       if (armflag & ARM_POSEMODE) {
+               set_pchan_glColor(PCHAN_COLOR_NORMAL, armflag, boneflag, 0);
+       }
+       
+       if (id != -1) {
+               glLoadName((GLuint) id|BONESEL_BONE);
+       }
+       
+       draw_object_instance(scene, v3d, ob, dt, armflag & ARM_POSEMODE);
+}
+
+
+static void pchan_draw_IK_root_lines(bPoseChannel *pchan, short only_temp)
+{
+       bConstraint *con;
+       bPoseChannel *parchan;
+       
+       for (con= pchan->constraints.first; con; con= con->next) {
+               if (con->type == CONSTRAINT_TYPE_KINEMATIC && (con->enforce!=0.0)) {
+                       bKinematicConstraint *data = (bKinematicConstraint*)con->data;
+                       int segcount= 0;
+                       
+                       /* if only_temp, only draw if it is a temporary ik-chain */
+                       if ((only_temp) && !(data->flag & CONSTRAINT_IK_TEMP))
+                               continue;
+                       
+                       setlinestyle(3);
+                       glBegin(GL_LINES);
+                       
+                       /* exclude tip from chain? */
+                       if ((data->flag & CONSTRAINT_IK_TIP)==0)
+                               parchan= pchan->parent;
+                       else
+                               parchan= pchan;
+                       
+                       glVertex3fv(parchan->pose_tail);
+                       
+                       /* Find the chain's root */
+                       while (parchan->parent) {
+                               segcount++;
+                               if(segcount==data->rootbone || segcount>255) break; // 255 is weak
+                               parchan= parchan->parent;
+                       }
+                       if (parchan)
+                               glVertex3fv(parchan->pose_head);
+                       
+                       glEnd();
+                       setlinestyle(0);
+               }
+       }
+}
+
+static void bgl_sphere_project(float ax, float az)
+{
+       float dir[3], sine, q3;
+
+       sine= 1.0f-ax*ax-az*az;
+       q3= (sine < 0.0f)? 0.0f: 2.0f*sqrt(sine);
+
+       dir[0]= -az*q3;
+       dir[1]= 1.0f-2.0f*sine;
+       dir[2]= ax*q3;
+
+       glVertex3fv(dir);
+}
+
+static void draw_dof_ellipse(float ax, float az)
+{
+       static float staticSine[16] = {
+               0.0, 0.104528463268, 0.207911690818, 0.309016994375,
+               0.406736643076, 0.5, 0.587785252292, 0.669130606359,
+               0.743144825477, 0.809016994375, 0.866025403784,
+               0.913545457643, 0.951056516295, 0.978147600734,
+               0.994521895368, 1.0
+       };
+
+       int i, j, n=16;
+       float x, z, px, pz;
+
+       glEnable(GL_BLEND);
+       glDepthMask(0);
+
+       glColor4ub(70, 70, 70, 50);
+
+       glBegin(GL_QUADS);
+       pz= 0.0f;
+       for(i=1; i<n; i++) {
+               z= staticSine[i];
+
+               px= 0.0f;
+               for(j=1; j<n-i+1; j++) {
+                       x = staticSine[j];
+
+                       if(j == n-i) {
+                               glEnd();
+                               glBegin(GL_TRIANGLES);
+                               bgl_sphere_project(ax*px, az*z);
+                               bgl_sphere_project(ax*px, az*pz);
+                               bgl_sphere_project(ax*x, az*pz);
+                               glEnd();
+                               glBegin(GL_QUADS);
+                       }
+                       else {
+                               bgl_sphere_project(ax*x, az*z);
+                               bgl_sphere_project(ax*x, az*pz);
+                               bgl_sphere_project(ax*px, az*pz);
+                               bgl_sphere_project(ax*px, az*z);
+                       }
+
+                       px= x;
+               }
+               pz= z;
+       }
+       glEnd();
+
+       glDisable(GL_BLEND);
+       glDepthMask(1);
+
+       glColor3ub(0, 0, 0);
+
+       glBegin(GL_LINE_STRIP);
+       for (i=0; i<n; i++)
+               bgl_sphere_project(staticSine[n-i-1]*ax, staticSine[i]*az);
+       glEnd();
+}
+
+static void draw_pose_dofs(Object *ob)
+{
+       bArmature *arm= ob->data;
+       bPoseChannel *pchan;
+       Bone *bone;
+       
+       for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+               bone= pchan->bone;
+               
+               if ( (bone) && !(bone->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG))) {
+                       if (bone->flag & BONE_SELECTED) {
+                               if (bone->layer & arm->layer) {
+                                       if (pchan->ikflag & (BONE_IK_XLIMIT|BONE_IK_ZLIMIT)) {
+                                               if (pose_channel_in_IK_chain(ob, pchan)) {
+                                                       float corner[4][3], posetrans[3], mat[4][4];
+                                                       float phi=0.0f, theta=0.0f, scale;
+                                                       int a, i;
+                                                       
+                                                       /* in parent-bone pose, but own restspace */
+                                                       glPushMatrix();
+                                                       
+                                                       VECCOPY(posetrans, pchan->pose_mat[3]);
+                                                       glTranslatef(posetrans[0], posetrans[1], posetrans[2]);
+                                                       
+                                                       if (pchan->parent) {
+                                                               Mat4CpyMat4(mat, pchan->parent->pose_mat);
+                                                               mat[3][0]= mat[3][1]= mat[3][2]= 0.0f;
+                                                               glMultMatrixf(mat);
+                                                       }
+                                                       
+                                                       Mat4CpyMat3(mat, pchan->bone->bone_mat);
+                                                       glMultMatrixf(mat);
+                                                       
+                                                       scale= bone->length*pchan->size[1];
+                                                       glScalef(scale, scale, scale);
+                                                       
+                                                       if (pchan->ikflag & BONE_IK_XLIMIT) {
+                                                               if (pchan->ikflag & BONE_IK_ZLIMIT) {
+                                                                       float amin[3], amax[3];
+                                                                       
+                                                                       for (i=0; i<3; i++) {
+                                                                               amin[i]= sin(pchan->limitmin[i]*M_PI/360.0);
+                                                                               amax[i]= sin(pchan->limitmax[i]*M_PI/360.0);
+                                                                       }
+                                                                       
+                                                                       glScalef(1.0, -1.0, 1.0);
+                                                                       if (amin[0] != 0.0 && amin[2] != 0.0)
+                                                                               draw_dof_ellipse(amin[0], amin[2]);
+                                                                       if (amin[0] != 0.0 && amax[2] != 0.0)
+                                                                               draw_dof_ellipse(amin[0], amax[2]);
+                                                                       if (amax[0] != 0.0 && amin[2] != 0.0)
+                                                                               draw_dof_ellipse(amax[0], amin[2]);
+                                                                       if (amax[0] != 0.0 && amax[2] != 0.0)
+                                                                               draw_dof_ellipse(amax[0], amax[2]);
+                                                                       glScalef(1.0, -1.0, 1.0);
+                                                               }
+                                                       }
+                                                       
+                                                       /* arcs */
+                                                       if (pchan->ikflag & BONE_IK_ZLIMIT) {
+                                                               theta= 0.5*(pchan->limitmin[2]+pchan->limitmax[2]);
+                                                               glRotatef(theta, 0.0f, 0.0f, 1.0f);
+                                                               
+                                                               glColor3ub(50, 50, 255);        // blue, Z axis limit
+                                                               glBegin(GL_LINE_STRIP);
+                                                               for (a=-16; a<=16; a++) {
+                                                                       float fac= ((float)a)/16.0f;
+                                                                       phi= fac*(M_PI/360.0f)*(pchan->limitmax[2]-pchan->limitmin[2]);
+                                                                       
+                                                                       i= (a == -16) ? 0 : 1;
+                                                                       corner[i][0]= sin(phi);
+                                                                       corner[i][1]= cos(phi);
+                                                                       corner[i][2]= 0.0f;
+                                                                       glVertex3fv(corner[i]);
+                                                               }
+                                                               glEnd();
+                                                               
+                                                               glRotatef(-theta, 0.0f, 0.0f, 1.0f);
+                                                       }                                       
+                                                       
+                                                       if (pchan->ikflag & BONE_IK_XLIMIT) {
+                                                               theta=  0.5*(pchan->limitmin[0]+pchan->limitmax[0]);
+                                                               glRotatef(theta, 1.0f, 0.0f, 0.0f);
+                                                               
+                                                               glColor3ub(255, 50, 50);        // Red, X axis limit
+                                                               glBegin(GL_LINE_STRIP);
+                                                               for (a=-16; a<=16; a++) {
+                                                                       float fac= ((float)a)/16.0f;
+                                                                       phi= 0.5f*M_PI + fac*(M_PI/360.0f)*(pchan->limitmax[0]-pchan->limitmin[0]);
+                                                                       
+                                                                       i= (a == -16) ? 2 : 3;
+                                                                       corner[i][0]= 0.0f;
+                                                                       corner[i][1]= sin(phi);
+                                                                       corner[i][2]= cos(phi);
+                                                                       glVertex3fv(corner[i]);
+                                                               }
+                                                               glEnd();
+                                                               
+                                                               glRotatef(-theta, 1.0f, 0.0f, 0.0f);
+                                                       }
+                                                       
+                                                       /* out of cone, out of bone */
+                                                       glPopMatrix(); 
+                                               }
+                                       }
+                               }
+                       }
+               }
+       }
+}
+
+/* assumes object is Armature with pose */
+static void draw_pose_channels(Scene *scene, View3D *v3d, Base *base, int dt)
+{
+       Object *ob= base->object;
+       bArmature *arm= ob->data;
+       bPoseChannel *pchan;
+       Bone *bone;
+       GLfloat tmp;
+       float smat[4][4], imat[4][4];
+       int index= -1;
+       short do_dashed= 3, draw_wire= 0;
+       short flag, constflag;
+       
+       /* hacky... prevent outline select from drawing dashed helplines */
+       glGetFloatv(GL_LINE_WIDTH, &tmp);
+       if (tmp > 1.1) do_dashed &= ~1;
+       if (v3d->flag & V3D_HIDE_HELPLINES) do_dashed &= ~2;
+       
+       /* precalc inverse matrix for drawing screen aligned */
+       if (arm->drawtype==ARM_ENVELOPE) {
+               /* precalc inverse matrix for drawing screen aligned */
+               wmGetMatrix(smat);
+               Mat4MulFloat3(smat[0], 1.0f/VecLength(ob->obmat[0]));
+               Mat4Invert(imat, smat);
+               
+               /* and draw blended distances */
+               if (arm->flag & ARM_POSEMODE) {
+                       glEnable(GL_BLEND);
+                       //glShadeModel(GL_SMOOTH);
+                       
+                       if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
+                       
+                       for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+                               bone= pchan->bone;
+                               if (bone && !(bone->flag & (BONE_HIDDEN_P|BONE_NO_DEFORM|BONE_HIDDEN_PG))) {
+                                       if (bone->flag & (BONE_SELECTED)) {
+                                               if (bone->layer & arm->layer)
+                                                       draw_sphere_bone_dist(smat, imat, bone->flag, pchan, NULL);
+                                       }
+                               }
+                       }
+                       
+                       if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
+                       glDisable(GL_BLEND);
+                       //glShadeModel(GL_FLAT);
+               }
+       }
+       
+       /* little speedup, also make sure transparent only draws once */
+       glCullFace(GL_BACK); 
+       glEnable(GL_CULL_FACE);
+       
+       /* if solid we draw that first, with selection codes, but without names, axes etc */
+       if (dt > OB_WIRE) {
+               if (arm->flag & ARM_POSEMODE) 
+                       index= base->selcol;
+               
+               for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+                       bone= pchan->bone;
+                       
+                       if ( (bone) && !(bone->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG)) ) {
+                               if (bone->layer & arm->layer) {
+                                       glPushMatrix();
+                                       glMultMatrixf(pchan->pose_mat);
+                                       
+                                       /* catch exception for bone with hidden parent */
+                                       flag= bone->flag;
+                                       if ( (bone->parent) && (bone->parent->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG)) )
+                                               flag &= ~BONE_CONNECTED;
+                                               
+                                       /* set color-set to use */
+                                       set_pchan_colorset(ob, pchan);
+                                       
+                                       if ((pchan->custom) && !(arm->flag & ARM_NO_CUSTOM)) {
+                                               /* if drawwire, don't try to draw in solid */
+                                               if (pchan->bone->flag & BONE_DRAWWIRE) 
+                                                       draw_wire= 1;
+                                               else
+                                                       draw_custom_bone(scene, v3d, pchan->custom, OB_SOLID, arm->flag, flag, index, bone->length);
+                                       }
+                                       else if (arm->drawtype==ARM_LINE)
+                                               ;       /* nothing in solid */
+                                       else if (arm->drawtype==ARM_ENVELOPE)
+                                               draw_sphere_bone(OB_SOLID, arm->flag, flag, 0, index, pchan, NULL);
+                                       else if (arm->drawtype==ARM_B_BONE)
+                                               draw_b_bone(OB_SOLID, arm->flag, flag, 0, index, pchan, NULL);
+                                       else
+                                               draw_bone(OB_SOLID, arm->flag, flag, 0, index, bone->length);
+                                               
+                                       glPopMatrix();
+                               }
+                       }
+                       
+                       if (index!= -1) 
+                               index+= 0x10000;        // pose bones count in higher 2 bytes only
+               }
+               
+               /* very very confusing... but in object mode, solid draw, we cannot do glLoadName yet,
+                * stick bones and/or wire custom-shapes are drawn in next loop 
+                */
+               if ((arm->drawtype != ARM_LINE) && (draw_wire == 0)) {
+                       /* object tag, for bordersel optim */
+                       glLoadName(index & 0xFFFF);     
+                       index= -1;
+               }
+       }
+       
+       /* draw custom bone shapes as wireframes */
+       if ( !(arm->flag & ARM_NO_CUSTOM) &&
+                ((draw_wire) || (dt <= OB_WIRE)) ) 
+       {
+               if (arm->flag & ARM_POSEMODE)
+                       index= base->selcol;
+                       
+               /* only draw custom bone shapes that need to be drawn as wires */
+               for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+                       bone= pchan->bone;
+                       
+                       if ((bone) && !(bone->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG))) {
+                               if (bone->layer & arm->layer) {
+                                       if (pchan->custom) {
+                                               if ((dt < OB_SOLID) || (bone->flag & BONE_DRAWWIRE)) {
+                                                       glPushMatrix();
+                                                       glMultMatrixf(pchan->pose_mat);
+                                                       
+                                                       /* prepare colors */
+                                                       if (arm->flag & ARM_POSEMODE)   
+                                                               set_pchan_colorset(ob, pchan);
+                                                       else {
+                                                               if ((scene->basact)==base) {
+                                                                       if (base->flag & (SELECT+BA_WAS_SEL)) UI_ThemeColor(TH_ACTIVE);
+                                                                       else UI_ThemeColor(TH_WIRE);
+                                                               }
+                                                               else {
+                                                                       if (base->flag & (SELECT+BA_WAS_SEL)) UI_ThemeColor(TH_SELECT);
+                                                                       else UI_ThemeColor(TH_WIRE);
+                                                               }
+                                                       }
+                                                               
+                                                       /* catch exception for bone with hidden parent */
+                                                       flag= bone->flag;
+                                                       if ((bone->parent) && (bone->parent->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG)))
+                                                               flag &= ~BONE_CONNECTED;
+                                                       
+                                                       draw_custom_bone(scene, v3d, pchan->custom, OB_WIRE, arm->flag, flag, index, bone->length);
+                                                       
+                                                       glPopMatrix();
+                                               }
+                                       }
+                               }
+                       }
+                       
+                       if (index != -1) 
+                               index+= 0x10000;        // pose bones count in higher 2 bytes only
+               }
+               
+               if (draw_wire) {
+                       /* object tag, for bordersel optim */
+                       glLoadName(index & 0xFFFF);     
+                       index= -1;
+               }
+       }
+       
+       /* wire draw over solid only in posemode */
+       if ((dt <= OB_WIRE) || (arm->flag & ARM_POSEMODE) || (arm->drawtype==ARM_LINE)) {
+               /* draw line check first. we do selection indices */
+               if (arm->drawtype==ARM_LINE) {
+                       if (arm->flag & ARM_POSEMODE) 
+                               index= base->selcol;
+               }
+               /* if solid && posemode, we draw again with polygonoffset */
+               else if ((dt > OB_WIRE) && (arm->flag & ARM_POSEMODE)) {
+                       bglPolygonOffset(v3d->dist, 1.0);
+               }
+               else {
+                       /* and we use selection indices if not done yet */
+                       if (arm->flag & ARM_POSEMODE) 
+                               index= base->selcol;
+               }
+               
+               for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+                       bone= pchan->bone;
+                       
+                       if ((bone) && !(bone->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG))) {
+                               if (bone->layer & arm->layer) {
+                                       if ((do_dashed & 1) && (bone->parent)) {
+                                               /* Draw a line from our root to the parent's tip 
+                                                *      - only if V3D_HIDE_HELPLINES is enabled...
+                                                */
+                                               if ( (do_dashed & 2) && ((bone->flag & BONE_CONNECTED)==0) ) {
+                                                       if (arm->flag & ARM_POSEMODE) {
+                                                               glLoadName(index & 0xFFFF);     // object tag, for bordersel optim
+                                                               UI_ThemeColor(TH_WIRE);
+                                                       }
+                                                       setlinestyle(3);
+                                                       glBegin(GL_LINES);
+                                                       glVertex3fv(pchan->pose_head);
+                                                       glVertex3fv(pchan->parent->pose_tail);
+                                                       glEnd();
+                                                       setlinestyle(0);
+                                               }
+                                               
+                                               /* Draw a line to IK root bone 
+                                                *      - only if temporary chain (i.e. "autoik")
+                                                */
+                                               if (arm->flag & ARM_POSEMODE) {
+                                                       if (pchan->constflag & PCHAN_HAS_IK) {
+                                                               if (bone->flag & BONE_SELECTED) {
+                                                                       if (pchan->constflag & PCHAN_HAS_TARGET) glColor3ub(200, 120, 0);
+                                                                       else glColor3ub(200, 200, 50);  // add theme!
+                                                                       
+                                                                       glLoadName(index & 0xFFFF);
+                                                                       pchan_draw_IK_root_lines(pchan, !(do_dashed & 2));
+                                                               }
+                                                       }
+                                               }
+                                       }
+                                       
+                                       glPushMatrix();
+                                       if (arm->drawtype != ARM_ENVELOPE)
+                                               glMultMatrixf(pchan->pose_mat);
+                                       
+                                       /* catch exception for bone with hidden parent */
+                                       flag= bone->flag;
+                                       if ((bone->parent) && (bone->parent->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG)))
+                                               flag &= ~BONE_CONNECTED;
+                                       
+                                       /* extra draw service for pose mode */
+                                       constflag= pchan->constflag;
+                                       if (pchan->flag & (POSE_ROT|POSE_LOC|POSE_SIZE))
+                                               constflag |= PCHAN_HAS_ACTION;
+                                       if (pchan->flag & POSE_STRIDE)
+                                               constflag |= PCHAN_HAS_STRIDE;
+                                               
+                                       /* set color-set to use */
+                                       set_pchan_colorset(ob, pchan);
+                                       
+                                       if ((pchan->custom) && !(arm->flag & ARM_NO_CUSTOM))
+                                               ; // custom bone shapes should not be drawn here!
+                                       else if (arm->drawtype==ARM_ENVELOPE) {
+                                               if (dt < OB_SOLID)
+                                                       draw_sphere_bone_wire(smat, imat, arm->flag, flag, constflag, index, pchan, NULL);
+                                       }
+                                       else if (arm->drawtype==ARM_LINE)
+                                               draw_line_bone(arm->flag, flag, constflag, index, pchan, NULL);
+                                       else if (arm->drawtype==ARM_B_BONE)
+                                               draw_b_bone(OB_WIRE, arm->flag, flag, constflag, index, pchan, NULL);
+                                       else
+                                               draw_bone(OB_WIRE, arm->flag, flag, constflag, index, bone->length);
+                                       
+                                       glPopMatrix();
+                               }
+                       }
+                       
+                       /* pose bones count in higher 2 bytes only */
+                       if (index != -1) 
+                               index+= 0x10000;        
+               }
+               /* restore things */
+               if ((arm->drawtype!=ARM_LINE)&& (dt>OB_WIRE) && (arm->flag & ARM_POSEMODE))
+                       bglPolygonOffset(v3d->dist, 0.0);
+       }       
+       
+       /* restore */
+       glDisable(GL_CULL_FACE);
+       
+       /* draw DoFs */
+       if (arm->flag & ARM_POSEMODE)
+               draw_pose_dofs(ob);
+
+       /* finally names and axes */
+       if (arm->flag & (ARM_DRAWNAMES|ARM_DRAWAXES)) {
+               /* patch for several 3d cards (IBM mostly) that crash on glSelect with text drawing */
+               if ((G.f & G_PICKSEL) == 0) {
+                       float vec[3];
+                       
+                       if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
+                       
+                       for (pchan=ob->pose->chanbase.first; pchan; pchan=pchan->next) {
+                               if ((pchan->bone->flag & (BONE_HIDDEN_P|BONE_HIDDEN_PG))==0) {
+                                       if (pchan->bone->layer & arm->layer) {
+                                               if (arm->flag & (ARM_EDITMODE|ARM_POSEMODE)) {
+                                                       bone= pchan->bone;
+                                                       
+                                                       if (bone->flag & BONE_SELECTED) UI_ThemeColor(TH_TEXT_HI);
+                                                       else UI_ThemeColor(TH_TEXT);
+                                               }
+                                               else if (dt > OB_WIRE)
+                                                       UI_ThemeColor(TH_TEXT);
+                                               
+                                               /*      Draw names of bone      */
+                                               if (arm->flag & ARM_DRAWNAMES) {
+                                                       VecMidf(vec, pchan->pose_head, pchan->pose_tail);
+                                                       glRasterPos3fv(vec);
+                                                       BMF_DrawString(G.font, " ");
+                                                       BMF_DrawString(G.font, pchan->name);
+                                               }       
+                                               
+                                               /*      Draw additional axes on the bone tail  */
+                                               if ( (arm->flag & ARM_DRAWAXES) && (arm->flag & ARM_POSEMODE) ) {
+                                                       glPushMatrix();
+                                                       glMultMatrixf(pchan->pose_mat);
+                                                       glTranslatef(0.0f, pchan->bone->length, 0.0f);
+                                                       drawaxes(0.25f*pchan->bone->length, 0, OB_ARROWS);
+                                                       glPopMatrix();
+                                               }
+                                       }
+                               }
+                       }
+                       
+                       if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
+               }
+       }
+}
+
+/* in editmode, we don't store the bone matrix... */
+static void set_matrix_editbone(EditBone *eBone)
+{
+       float           delta[3],offset[3];
+       float           mat[3][3], bmat[4][4];
+       
+       /* Compose the parent transforms (i.e. their translations) */
+       VECCOPY(offset, eBone->head);
+       
+       glTranslatef(offset[0],offset[1],offset[2]);
+       
+       VecSubf(delta, eBone->tail, eBone->head);       
+       
+       eBone->length = sqrt (delta[0]*delta[0] + delta[1]*delta[1] +delta[2]*delta[2]);
+       
+       vec_roll_to_mat3(delta, eBone->roll, mat);
+       Mat4CpyMat3(bmat, mat);
+               
+       glMultMatrixf(bmat);
+       
+}
+
+static void draw_ebones(View3D *v3d, Object *ob, int dt)
+{
+       EditBone *eBone;
+       bArmature *arm= ob->data;
+       float smat[4][4], imat[4][4];
+       unsigned int index;
+       int flag;
+       
+       /* envelope (deform distance) */
+       if(arm->drawtype==ARM_ENVELOPE) {
+               /* precalc inverse matrix for drawing screen aligned */
+               wmGetMatrix(smat);
+               Mat4MulFloat3(smat[0], 1.0f/VecLength(ob->obmat[0]));
+               Mat4Invert(imat, smat);
+               
+               /* and draw blended distances */
+               glEnable(GL_BLEND);
+               //glShadeModel(GL_SMOOTH);
+               
+               if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
+
+               for (eBone=G.edbo.first, index=0; eBone; eBone=eBone->next, index++) {
+                       if (eBone->layer & arm->layer) {
+                               if ((eBone->flag & (BONE_HIDDEN_A|BONE_NO_DEFORM))==0) {
+                                       if (eBone->flag & (BONE_SELECTED|BONE_TIPSEL|BONE_ROOTSEL))
+                                               draw_sphere_bone_dist(smat, imat, eBone->flag, NULL, eBone);
+                               }
+                       }
+               }
+               
+               if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
+               glDisable(GL_BLEND);
+               //glShadeModel(GL_FLAT);
+       }
+       
+       /* if solid we draw it first */
+       if ((dt > OB_WIRE) && (arm->drawtype!=ARM_LINE)) {
+               index= 0;
+               for (eBone=G.edbo.first, index=0; eBone; eBone=eBone->next, index++) {
+                       if (eBone->layer & arm->layer) {
+                               if ((eBone->flag & BONE_HIDDEN_A)==0) {
+                                       glPushMatrix();
+                                       set_matrix_editbone(eBone);
+                                       
+                                       /* catch exception for bone with hidden parent */
+                                       flag= eBone->flag;
+                                       if ( (eBone->parent) && ((eBone->parent->flag & BONE_HIDDEN_A) || (eBone->parent->layer & arm->layer)==0) )
+                                               flag &= ~BONE_CONNECTED;
+                                       
+                                       if (arm->drawtype==ARM_ENVELOPE)
+                                               draw_sphere_bone(OB_SOLID, arm->flag, flag, 0, index, NULL, eBone);
+                                       else if(arm->drawtype==ARM_B_BONE)
+                                               draw_b_bone(OB_SOLID, arm->flag, flag, 0, index, NULL, eBone);
+                                       else {
+                                               draw_bone(OB_SOLID, arm->flag, flag, 0, index, eBone->length);
+                                       }
+                                       
+                                       glPopMatrix();
+                               }
+                       }
+               }
+       }
+       
+       /* if wire over solid, set offset */
+       index= -1;
+       glLoadName(-1);
+       if (arm->drawtype==ARM_LINE) {
+               if(G.f & G_PICKSEL)
+                       index= 0;
+       }
+       else if (dt > OB_WIRE) 
+               bglPolygonOffset(v3d->dist, 1.0);
+       else if (arm->flag & ARM_EDITMODE) 
+               index= 0;       /* do selection codes */
+       
+       for (eBone=G.edbo.first; eBone; eBone=eBone->next) {
+               if (eBone->layer & arm->layer) {
+                       if ((eBone->flag & BONE_HIDDEN_A)==0) {
+                               
+                               /* catch exception for bone with hidden parent */
+                               flag= eBone->flag;
+                               if ( (eBone->parent) && ((eBone->parent->flag & BONE_HIDDEN_A) || (eBone->parent->layer & arm->layer)==0) )
+                                       flag &= ~BONE_CONNECTED;
+                               
+                               if (arm->drawtype == ARM_ENVELOPE) {
+                                       if (dt < OB_SOLID)
+                                               draw_sphere_bone_wire(smat, imat, arm->flag, flag, 0, index, NULL, eBone);
+                               }
+                               else {
+                                       glPushMatrix();
+                                       set_matrix_editbone(eBone);
+                                       
+                                       if (arm->drawtype == ARM_LINE) 
+                                               draw_line_bone(arm->flag, flag, 0, index, NULL, eBone);
+                                       else if (arm->drawtype == ARM_B_BONE)
+                                               draw_b_bone(OB_WIRE, arm->flag, flag, 0, index, NULL, eBone);
+                                       else
+                                               draw_bone(OB_WIRE, arm->flag, flag, 0, index, eBone->length);
+                                       
+                                       glPopMatrix();
+                               }
+                               
+                               /* offset to parent */
+                               if (eBone->parent) {
+                                       UI_ThemeColor(TH_WIRE);
+                                       glLoadName (-1);                // -1 here is OK!
+                                       setlinestyle(3);
+                                       
+                                       glBegin(GL_LINES);
+                                       glVertex3fv(eBone->parent->tail);
+                                       glVertex3fv(eBone->head);
+                                       glEnd();
+                                       
+                                       setlinestyle(0);
+                               }
+                       }
+               }
+               if(index!=-1) index++;
+       }
+       
+       /* restore */
+       if (arm->drawtype==ARM_LINE);
+       else if (dt>OB_WIRE) bglPolygonOffset(v3d->dist, 0.0);
+       
+       /* finally names and axes */
+       if (arm->flag & (ARM_DRAWNAMES|ARM_DRAWAXES)) {
+               // patch for several 3d cards (IBM mostly) that crash on glSelect with text drawing
+               if ((G.f & G_PICKSEL) == 0) {
+                       float vec[3];
+                       
+                       if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
+                       
+                       for (eBone=G.edbo.first, index=0; eBone; eBone=eBone->next, index++) {
+                               if(eBone->layer & arm->layer) {
+                                       if ((eBone->flag & BONE_HIDDEN_A)==0) {
+                                               
+                                               if (eBone->flag & BONE_SELECTED) UI_ThemeColor(TH_TEXT_HI);
+                                               else UI_ThemeColor(TH_TEXT);
+                                               
+                                               /*      Draw name */
+                                               if (arm->flag & ARM_DRAWNAMES) {
+                                                       VecMidf(vec, eBone->head, eBone->tail);
+                                                       glRasterPos3fv(vec);
+                                                       BMF_DrawString(G.font, " ");
+                                                       BMF_DrawString(G.font, eBone->name);
+                                               }                                       
+                                               /*      Draw additional axes */
+                                               if (arm->flag & ARM_DRAWAXES) {
+                                                       glPushMatrix();
+                                                       set_matrix_editbone(eBone);
+                                                       glTranslatef(0.0f, eBone->length, 0.0f);
+                                                       drawaxes(eBone->length*0.25f, 0, OB_ARROWS);
+                                                       glPopMatrix();
+                                               }
+                                               
+                                       }
+                               }
+                       }
+                       
+                       if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
+               }
+       }
+}
+
+/* ****************************** Armature Visualisation ******************************** */
+
+/* ---------- Paths --------- */
+
+/* draw bone paths
+ *     - in view space 
+ */
+static void draw_pose_paths(View3D *v3d, Object *ob)
+{
+       bArmature *arm= ob->data;
+       bPoseChannel *pchan;
+       bAction *act;
+       bActionChannel *achan;
+       ActKeyColumn *ak;
+       ListBase keys;
+       float *fp, *fp_start;
+       int a, stepsize;
+       int sfra, efra, len;
+       
+       if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
+       
+       glPushMatrix();
+       glLoadMatrixf(v3d->viewmat);
+       
+       /* version patch here - cannot access frame info from file reading */
+       if (arm->pathsize == 0) arm->pathsize= 1;
+       stepsize = arm->pathsize;
+       
+       for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+               if (pchan->bone->layer & arm->layer) {
+                       if (pchan->path) {
+                               /* version patch here - cannot access frame info from file reading */
+                               if ((pchan->pathsf == 0) || (pchan->pathef == 0)) {
+                                       pchan->pathsf= SFRA;
+                                       pchan->pathef= EFRA;
+                               }
+                               
+                               /* get frame ranges */
+                               if (arm->pathflag & ARM_PATH_ACFRA) {
+                                       int sind;
+                                       
+                                       /* With "Around Current", we only choose frames from around 
+                                        * the current frame to draw. However, this range is still 
+                                        * restricted by the limits of the original path.
+                                        */
+                                       sfra= CFRA - arm->pathbc;
+                                       efra= CFRA + arm->pathac;
+                                       if (sfra < pchan->pathsf) sfra= pchan->pathsf;
+                                       if (efra > pchan->pathef) efra= pchan->pathef;
+                                       
+                                       len= efra - sfra;
+                                       
+                                       sind= sfra - pchan->pathsf;
+                                       fp_start= (pchan->path + (3*sind));
+                               }
+                               else {
+                                       sfra= pchan->pathsf;
+                                       efra = sfra + pchan->pathlen;
+                                       len = pchan->pathlen;
+                                       fp_start = pchan->path;
+                               }
+                               
+                               /* draw curve-line of path */
+                               glShadeModel(GL_SMOOTH);
+                               
+                               glBegin(GL_LINE_STRIP);                                 
+                               for (a=0, fp=fp_start; a<len; a++, fp+=3) {
+                                       float intensity; /* how faint */
+                                       
+                                       /* set color
+                                        *      - more intense for active/selected bones, less intense for unselected bones
+                                        *      - black for before current frame, green for current frame, blue for after current frame
+                                        *      - intensity decreases as distance from current frame increases
+                                        */
+                                       #define SET_INTENSITY(A, B, C, min, max) (((1.0f - ((C - B) / (C - A))) * (max-min)) + min) 
+                                       if ((a+sfra) < CFRA) {
+                                               /* black - before cfra */
+                                               if (pchan->bone->flag & BONE_SELECTED) {
+                                                       // intensity= 0.5;
+                                                       intensity = SET_INTENSITY(sfra, a, CFRA, 0.25f, 0.75f);
+                                               }
+                                               else {
+                                                       //intensity= 0.8;
+                                                       intensity = SET_INTENSITY(sfra, a, CFRA, 0.68f, 0.92f);
+                                               }
+                                               UI_ThemeColorBlend(TH_WIRE, TH_BACK, intensity);
+                                       }
+                                       else if ((a+sfra) > CFRA) {
+                                               /* blue - after cfra */
+                                               if (pchan->bone->flag & BONE_SELECTED) {
+                                                       //intensity = 0.5;
+                                                       intensity = SET_INTENSITY(CFRA, a, efra, 0.25f, 0.75f);
+                                               }
+                                               else {
+                                                       //intensity = 0.8;
+                                                       intensity = SET_INTENSITY(CFRA, a, efra, 0.68f, 0.92f);
+                                               }
+                                               UI_ThemeColorBlend(TH_BONE_POSE, TH_BACK, intensity);
+                                       }
+                                       else {
+                                               /* green - on cfra */
+                                               if (pchan->bone->flag & BONE_SELECTED) {
+                                                       intensity= 0.5;
+                                               }
+                                               else {
+                                                       intensity= 0.99;
+                                               }
+                                               UI_ThemeColorBlendShade(TH_CFRAME, TH_BACK, intensity, 10);
+                                       }       
+                                       
+                                       /* draw a vertex with this color */ 
+                                       glVertex3fv(fp);
+                               }
+                               
+                               glEnd();
+                               glShadeModel(GL_FLAT);
+                               
+                               glPointSize(1.0);
+                               
+                               /* draw little black point at each frame
+                                * NOTE: this is not really visible/noticable
+                                */
+                               glBegin(GL_POINTS);
+                               for (a=0, fp=fp_start; a<len; a++, fp+=3) 
+                                       glVertex3fv(fp);
+                               glEnd();
+                               
+                               /* Draw little white dots at each framestep value */
+                               UI_ThemeColor(TH_TEXT_HI);
+                               glBegin(GL_POINTS);
+                               for (a=0, fp=fp_start; a<len; a+=stepsize, fp+=(stepsize*3)) 
+                                       glVertex3fv(fp);
+                               glEnd();
+                               
+                               /* Draw frame numbers at each framestep value */
+                               if (arm->pathflag & ARM_PATH_FNUMS) {
+                                       for (a=0, fp=fp_start; a<len; a+=stepsize, fp+=(stepsize*3)) {
+                                               char str[32];
+                                               
+                                               /* only draw framenum if several consecutive highlighted points don't occur on same point */
+                                               if (a == 0) {
+                                                       glRasterPos3fv(fp);
+                                                       sprintf(str, "  %d\n", (a+sfra));
+                                                       BMF_DrawString(G.font, str);
+                                               }
+                                               else if ((a > stepsize) && (a < len-stepsize)) { 
+                                                       if ((VecEqual(fp, fp-(stepsize*3))==0) || (VecEqual(fp, fp+(stepsize*3))==0)) {
+                                                               glRasterPos3fv(fp);
+                                                               sprintf(str, "  %d\n", (a+sfra));
+                                                               BMF_DrawString(G.font, str);
+                                                       }
+                                               }
+                                       }
+                               }
+                               
+                               /* Keyframes - dots and numbers */
+                               if (arm->pathflag & ARM_PATH_KFRAS) {
+                                       /* build list of all keyframes in active action for pchan */
+                                       keys.first = keys.last = NULL;  
+                                       act= ob_get_action(ob);
+                                       if (act) {
+                                               achan= get_action_channel(act, pchan->name);
+                                               if (achan) 
+                                                       ipo_to_keylist(achan->ipo, &keys, NULL, NULL);
+                                       }
+                                       
+                                       /* Draw slightly-larger yellow dots at each keyframe */
+                                       UI_ThemeColor(TH_VERTEX_SELECT);
+                                       glPointSize(5.0);
+                                       
+                                       glBegin(GL_POINTS);
+                                       for (a=0, fp=fp_start; a<len; a++, fp+=3) {
+                                               for (ak= keys.first; ak; ak= ak->next) {
+                                                       if (ak->cfra == (a+sfra))
+                                                               glVertex3fv(fp);
+                                               }
+                                       }
+                                       glEnd();
+                                       
+                                       glPointSize(1.0);
+                                       
+                                       /* Draw frame numbers of keyframes  */
+                                       if ((arm->pathflag & ARM_PATH_FNUMS) || (arm->pathflag & ARM_PATH_KFNOS)) {
+                                               for(a=0, fp=fp_start; a<len; a++, fp+=3) {
+                                                       for (ak= keys.first; ak; ak= ak->next) {
+                                                               if (ak->cfra == (a+sfra)) {
+                                                                       char str[32];
+                                                                       
+                                                                       glRasterPos3fv(fp);
+                                                                       sprintf(str, "  %d\n", (a+sfra));
+                                                                       BMF_DrawString(G.font, str);
+                                                               }
+                                                       }
+                                               }
+                                       }
+                                       
+                                       BLI_freelistN(&keys);
+                               }
+                       }
+               }
+       }
+       
+       if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
+       glPopMatrix();
+}
+
+
+/* ---------- Ghosts --------- */
+
+/* helper function for ghost drawing - sets/removes flags for temporarily 
+ * hiding unselected bones while drawing ghosts
+ */
+static void ghost_poses_tag_unselected(Object *ob, short unset)
+{
+       bArmature *arm= ob->data;
+       bPose *pose= ob->pose;
+       bPoseChannel *pchan;
+       
+       /* don't do anything if no hiding any bones */
+       if ((arm->flag & ARM_GHOST_ONLYSEL)==0)
+               return;
+               
+       /* loop over all pchans, adding/removing tags as appropriate */
+       for (pchan= pose->chanbase.first; pchan; pchan= pchan->next) {
+               if ((pchan->bone) && (arm->layer & pchan->bone->layer)) {
+                       if (unset) {
+                               /* remove tags from all pchans if cleaning up */
+                               pchan->bone->flag &= ~BONE_HIDDEN_PG;
+                       }
+                       else {
+                               /* set tags on unselected pchans only */
+                               if ((pchan->bone->flag & BONE_SELECTED)==0)
+                                       pchan->bone->flag |= BONE_HIDDEN_PG;
+                       }
+               }
+       }
+}
+
+/* draw ghosts that occur within a frame range 
+ *     note: object should be in posemode 
+ */
+static void draw_ghost_poses_range(Scene *scene, View3D *v3d, Base *base)
+{
+       Object *ob= base->object;
+       bArmature *arm= ob->data;
+       bPose *posen, *poseo;
+       float start, end, stepsize, range, colfac;
+       int cfrao, flago, ipoflago;
+       
+       start = arm->ghostsf;
+       end = arm->ghostef;
+       if (end <= start)
+               return;
+       
+       stepsize= (float)(arm->ghostsize);
+       range= (float)(end - start);
+       
+       /* store values */
+       ob->flag &= ~OB_POSEMODE;
+       cfrao= CFRA;
+       flago= arm->flag;
+       arm->flag &= ~(ARM_DRAWNAMES|ARM_DRAWAXES);
+       ipoflago= ob->ipoflag; 
+       ob->ipoflag |= OB_DISABLE_PATH;
+       
+       /* copy the pose */
+       poseo= ob->pose;
+       copy_pose(&posen, ob->pose, 1);
+       ob->pose= posen;
+       armature_rebuild_pose(ob, ob->data);    /* child pointers for IK */
+       ghost_poses_tag_unselected(ob, 0);              /* hide unselected bones if need be */
+       
+       glEnable(GL_BLEND);
+       if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
+       
+       /* draw from first frame of range to last */
+       for (CFRA= start; CFRA<end; CFRA+=stepsize) {
+               colfac = (end-CFRA)/range;
+               UI_ThemeColorShadeAlpha(TH_WIRE, 0, -128-(int)(120.0f*sqrt(colfac)));
+               
+               do_all_pose_actions(ob);
+               where_is_pose(ob);
+               draw_pose_channels(scene, v3d, base, OB_WIRE);
+       }
+       glDisable(GL_BLEND);
+       if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
+
+       ghost_poses_tag_unselected(ob, 1);              /* unhide unselected bones if need be */
+       free_pose(posen);
+       
+       /* restore */
+       CFRA= cfrao;
+       ob->pose= poseo;
+       arm->flag= flago;
+       armature_rebuild_pose(ob, ob->data);
+       ob->flag |= OB_POSEMODE;
+       ob->ipoflag= ipoflago; 
+}
+
+/* draw ghosts on keyframes in action within range 
+ *     - object should be in posemode 
+ */
+static void draw_ghost_poses_keys(Scene *scene, View3D *v3d, Base *base)
+{
+       Object *ob= base->object;
+       bAction *act= ob_get_action(ob);
+       bArmature *arm= ob->data;
+       bPose *posen, *poseo;
+       ListBase keys= {NULL, NULL};
+       ActKeysInc aki = {0, 0, 0};
+       ActKeyColumn *ak, *akn;
+       float start, end, range, colfac, i;
+       int cfrao, flago, ipoflago;
+       
+       aki.start= start = arm->ghostsf;
+       aki.end= end = arm->ghostef;
+       if (end <= start)
+               return;
+       
+       /* get keyframes - then clip to only within range */
+       action_to_keylist(act, &keys, NULL, &aki);
+       range= 0;
+       for (ak= keys.first; ak; ak= akn) {
+               akn= ak->next;
+               
+               if ((ak->cfra < start) || (ak->cfra > end))
+                       BLI_freelinkN(&keys, ak);
+               else
+                       range++;
+       }
+       if (range == 0) return;
+       
+       /* store values */
+       ob->flag &= ~OB_POSEMODE;
+       cfrao= CFRA;
+       flago= arm->flag;
+       arm->flag &= ~(ARM_DRAWNAMES|ARM_DRAWAXES);
+       ipoflago= ob->ipoflag; 
+       ob->ipoflag |= OB_DISABLE_PATH;
+       
+       /* copy the pose */
+       poseo= ob->pose;
+       copy_pose(&posen, ob->pose, 1);
+       ob->pose= posen;
+       armature_rebuild_pose(ob, ob->data);    /* child pointers for IK */
+       ghost_poses_tag_unselected(ob, 0);              /* hide unselected bones if need be */
+       
+       glEnable(GL_BLEND);
+       if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
+       
+       /* draw from first frame of range to last */
+       for (ak=keys.first, i=0; ak; ak=ak->next, i++) {
+               colfac = i/range;
+               UI_ThemeColorShadeAlpha(TH_WIRE, 0, -128-(int)(120.0f*sqrt(colfac)));
+               
+               CFRA= (int)ak->cfra;
+               
+               do_all_pose_actions(ob);
+               where_is_pose(ob);
+               draw_pose_channels(scene, v3d, base, OB_WIRE);
+       }
+       glDisable(GL_BLEND);
+       if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
+
+       ghost_poses_tag_unselected(ob, 1);              /* unhide unselected bones if need be */
+       BLI_freelistN(&keys);
+       free_pose(posen);
+       
+       /* restore */
+       CFRA= cfrao;
+       ob->pose= poseo;
+       arm->flag= flago;
+       armature_rebuild_pose(ob, ob->data);
+       ob->flag |= OB_POSEMODE;
+       ob->ipoflag= ipoflago; 
+}
+
+/* draw ghosts around current frame
+ *     - object is supposed to be armature in posemode 
+ */
+static void draw_ghost_poses(Scene *scene, View3D *v3d, Base *base)
+{
+       Object *ob= base->object;
+       bArmature *arm= ob->data;
+       bPose *posen, *poseo;
+       bActionStrip *strip;
+       float cur, start, end, stepsize, range, colfac, actframe, ctime;
+       int cfrao, maptime, flago, ipoflago;
+       
+       /* pre conditions, get an action with sufficient frames */
+       if (ob->action==NULL)
+               return;
+
+       calc_action_range(ob->action, &start, &end, 0);
+       if (start == end)
+               return;
+
+       stepsize= (float)(arm->ghostsize);
+       range= (float)(arm->ghostep)*stepsize + 0.5f;   /* plus half to make the for loop end correct */
+       
+       /* we only map time for armature when an active strip exists */
+       for (strip=ob->nlastrips.first; strip; strip=strip->next)
+               if (strip->flag & ACTSTRIP_ACTIVE)
+                       break;
+       
+       maptime= (strip!=NULL);
+       
+       /* store values */
+       ob->flag &= ~OB_POSEMODE;
+       cfrao= CFRA;
+       if (maptime) actframe= get_action_frame(ob, (float)CFRA);
+       else actframe= CFRA;
+       flago= arm->flag;
+       arm->flag &= ~(ARM_DRAWNAMES|ARM_DRAWAXES);
+       ipoflago= ob->ipoflag; 
+       ob->ipoflag |= OB_DISABLE_PATH;
+       
+       /* copy the pose */
+       poseo= ob->pose;
+       copy_pose(&posen, ob->pose, 1);
+       ob->pose= posen;
+       armature_rebuild_pose(ob, ob->data);    /* child pointers for IK */
+       ghost_poses_tag_unselected(ob, 0);              /* hide unselected bones if need be */
+       
+       glEnable(GL_BLEND);
+       if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
+       
+       /* draw from darkest blend to lowest */
+       for(cur= stepsize; cur<range; cur+=stepsize) {
+               ctime= cur - fmod((float)cfrao, stepsize);      /* ensures consistant stepping */
+               colfac= ctime/range;
+               UI_ThemeColorShadeAlpha(TH_WIRE, 0, -128-(int)(120.0f*sqrt(colfac)));
+               
+               /* only within action range */
+               if (actframe+ctime >= start && actframe+ctime <= end) {
+                       if (maptime) CFRA= (int)get_action_frame_inv(ob, actframe+ctime);
+                       else CFRA= (int)floor(actframe+ctime);
+                       
+                       if (CFRA!=cfrao) {
+                               do_all_pose_actions(ob);
+                               where_is_pose(ob);
+                               draw_pose_channels(scene, v3d, base, OB_WIRE);
+                       }
+               }
+               
+               ctime= cur + fmod((float)cfrao, stepsize) - stepsize+1.0f;      /* ensures consistant stepping */
+               colfac= ctime/range;
+               UI_ThemeColorShadeAlpha(TH_WIRE, 0, -128-(int)(120.0f*sqrt(colfac)));
+               
+               /* only within action range */
+               if ((actframe-ctime >= start) && (actframe-ctime <= end)) {
+                       if (maptime) CFRA= (int)get_action_frame_inv(ob, actframe-ctime);
+                       else CFRA= (int)floor(actframe-ctime);
+                       
+                       if (CFRA != cfrao) {
+                               do_all_pose_actions(ob);
+                               where_is_pose(ob);
+                               draw_pose_channels(scene, v3d, base, OB_WIRE);
+                       }
+               }
+       }
+       glDisable(GL_BLEND);
+       if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
+
+       ghost_poses_tag_unselected(ob, 1);              /* unhide unselected bones if need be */
+       free_pose(posen);
+       
+       /* restore */
+       CFRA= cfrao;
+       ob->pose= poseo;
+       arm->flag= flago;
+       armature_rebuild_pose(ob, ob->data);
+       ob->flag |= OB_POSEMODE;
+       ob->ipoflag= ipoflago; 
+}
+
+/* ********************************** Armature Drawing - Main ************************* */
+
+/* called from drawobject.c, return 1 if nothing was drawn */
+int draw_armature(Scene *scene, View3D *v3d, Base *base, int dt, int flag)
+{
+       Object *ob= base->object;
+       bArmature *arm= ob->data;
+       int retval= 0;
+
+       if(G.f & G_RENDER_SHADOW)
+               return 1;
+       
+       if(dt>OB_WIRE && arm->drawtype!=ARM_LINE) {
+               /* we use color for solid lighting */
+               glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR);
+               glEnable(GL_COLOR_MATERIAL);
+               glColor3ub(0,0,0);      // clear spec
+               glDisable(GL_COLOR_MATERIAL);
+               
+               glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
+               glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW); // only for lighting...
+       }
+       
+       /* arm->flag is being used to detect mode... */
+       /* editmode? */
+       if(ob==G.obedit || (G.obedit && ob->data==G.obedit->data)) {
+               if(ob==G.obedit) arm->flag |= ARM_EDITMODE;
+               draw_ebones(v3d, ob, dt);
+               arm->flag &= ~ARM_EDITMODE;
+       }
+       else{
+               /*      Draw Pose */
+               if(ob->pose && ob->pose->chanbase.first) {
+                       /* drawing posemode selection indices or colors only in these cases */
+                       if(!(base->flag & OB_FROMDUPLI)) {
+                               if(G.f & G_PICKSEL) {
+                                       if(ob->flag & OB_POSEMODE) 
+                                               arm->flag |= ARM_POSEMODE;
+                               }
+                               else if(ob->flag & OB_POSEMODE) {
+                                       if (arm->ghosttype == ARM_GHOST_RANGE) {
+                                               draw_ghost_poses_range(scene, v3d, base);
+                                       }
+                                       else if (arm->ghosttype == ARM_GHOST_KEYS) {
+                                               draw_ghost_poses_keys(scene, v3d, base);
+                                       }
+                                       else if (arm->ghosttype == ARM_GHOST_CUR) {
+                                               if (arm->ghostep)
+                                                       draw_ghost_poses(scene, v3d, base);
+                                       }
+                                       if ((flag & DRAW_SCENESET)==0) {
+                                               if(ob==OBACT) 
+                                                       arm->flag |= ARM_POSEMODE;
+                                               else if(G.f & G_WEIGHTPAINT)
+                                                       arm->flag |= ARM_POSEMODE;
+                                       
+                                               draw_pose_paths(v3d, ob);
+                                       }
+                               }       
+                       }
+                       draw_pose_channels(scene, v3d, base, dt);
+                       arm->flag &= ~ARM_POSEMODE; 
+                       
+                       if(ob->flag & OB_POSEMODE)
+                               UI_ThemeColor(TH_WIRE); /* restore, for extra draw stuff */
+               }
+               else retval= 1;
+       }
+       /* restore */
+       glFrontFace(GL_CCW);
+
+       return retval;
+}
+
+/* *************** END Armature drawing ******************* */
+
+
index ca813e919fc6c7f30c7f9afa32dd146946888aa2..99adea5467e19d4d0831889040a44eafefeeb79b 100644 (file)
@@ -133,7 +133,6 @@ void EM_init_index_arrays(int x, int y, int z) {} // XXX
 void EM_free_index_arrays(void) {}             // XXX
 #define EM_FGON        0
 EditFace *EM_get_actFace(int x) {return NULL;} // XXX
-int draw_armature(Base *base, int x, int y) {return 0;}        // XXX
 int em_solidoffs;      // XXX
 int em_wireoffs;
 int em_vertoffs;
@@ -4542,7 +4541,7 @@ static void drawtexspace(Object *ob)
 }
 
 /* draws wire outline */
-static void drawSolidSelect(View3D *v3d, Base *base) 
+static void drawSolidSelect(Scene *scene, View3D *v3d, Base *base) 
 {
        Object *ob= base->object;
        
@@ -4562,7 +4561,7 @@ static void drawSolidSelect(View3D *v3d, Base *base)
        }
        else if(ob->type==OB_ARMATURE) {
                if(!(ob->flag & OB_POSEMODE))
-                       draw_armature(base, OB_WIRE, 0);
+                       draw_armature(scene, v3d, base, OB_WIRE, 0);
        }
 
        glLineWidth(1.0);
@@ -4888,7 +4887,7 @@ void draw_object(Scene *scene, ARegion *ar, View3D *v3d, Base *base, int flag)
        if((v3d->flag & V3D_SELECT_OUTLINE) && ob->type!=OB_MESH) {
                if(dt>OB_WIRE && dt<OB_TEXTURE && ob!=G.obedit && (flag && DRAW_SCENESET)==0) {
                        if (!(ob->dtx&OB_DRAWWIRE) && (ob->flag&SELECT) && !(flag&DRAW_PICKING)) {
-                               drawSolidSelect(v3d, base);
+                               drawSolidSelect(scene, v3d, base);
                        }
                }
        }
@@ -5033,7 +5032,7 @@ void draw_object(Scene *scene, ARegion *ar, View3D *v3d, Base *base, int flag)
                        break;
                case OB_ARMATURE:
                        if(dt>OB_WIRE) GPU_enable_material(0, NULL); // we use default material
-                       empty_object= draw_armature(base, dt, flag);
+                       empty_object= draw_armature(scene, v3d, base, dt, flag);
                        if(dt>OB_WIRE) GPU_disable_material();
                        break;
                default:
index f017af9aef173e921d7cab22dc3aa8075d9b17c0..27a07165770ad7b4013c1fd4bfecef26de8b3476 100644 (file)
@@ -71,6 +71,12 @@ void ED_VIEW3D_OT_viewcenter(struct wmOperatorType *ot);
 /* drawobject.c */
 void draw_object(Scene *scene, ARegion *ar, View3D *v3d, Base *base, int flag);
 int draw_glsl_material(Scene *scene, Object *ob, View3D *v3d, int dt);
+void drawcircball(int mode, float *cent, float rad, float tmat[][4]);
+void draw_object_instance(Scene *scene, View3D *v3d, Object *ob, int dt, int outline);
+void drawaxes(float size, int flag, char drawtype);
+
+/* drawarmature.c */
+int draw_armature(Scene *scene, View3D *v3d, Base *base, int dt, int flag);
 
 /* drawmesh.c */
 void draw_mesh_textured(Scene *scene, View3D *v3d, Object *ob, struct DerivedMesh *dm, int faceselect);