svn merge -r 14721:14810 https://svn.blender.org/svnroot/bf-blender/trunk/blender
authorDaniel Genrich <daniel.genrich@gmx.net>
Mon, 12 May 2008 12:24:52 +0000 (12:24 +0000)
committerDaniel Genrich <daniel.genrich@gmx.net>
Mon, 12 May 2008 12:24:52 +0000 (12:24 +0000)
45 files changed:
CMakeLists.txt
extern/bullet2/CMakeLists.txt
extern/bullet2/Makefile
extern/bullet2/src/Makefile
intern/elbeem/intern/isosurface.cpp
intern/elbeem/intern/loop_tools.h
intern/elbeem/intern/paraloopend.h
intern/elbeem/intern/solver_init.cpp
intern/elbeem/intern/solver_main.cpp
intern/sph/SConscript [new file with mode: 0644]
intern/sph/extern/sph_extern.h [new file with mode: 0644]
intern/sph/intern/sph.cpp [new file with mode: 0644]
release/datafiles/splash.jpg
release/scripts/flt_defaultp.py [deleted file]
release/scripts/flt_palettemanager.py [deleted file]
release/scripts/flt_properties.py [deleted file]
release/scripts/flt_toolbar.py [deleted file]
release/scripts/weightpaint_invert.py [deleted file]
release/scripts/wizard_curve2tree.py [deleted file]
source/Makefile
source/blender/blenkernel/BKE_cloth.h
source/blender/blenkernel/BKE_collision.h
source/blender/blenkernel/BKE_collisions.h [new file with mode: 0644]
source/blender/blenkernel/BKE_effect.h
source/blender/blenkernel/BKE_sph.h [new file with mode: 0644]
source/blender/blenkernel/CCGSubSurf.h [new file with mode: 0644]
source/blender/blenkernel/SConscript
source/blender/blenkernel/bmesh_private.h [new file with mode: 0644]
source/blender/blenkernel/intern/cloth.c
source/blender/blenkernel/intern/collision.c
source/blender/blenkernel/intern/kdop.c [deleted file]
source/blender/blenkernel/intern/modifier.c
source/blender/blenkernel/intern/particle_system.c
source/blender/blenkernel/intern/sph.c [new file with mode: 0644]
source/blender/blenlib/BLI_kdopbvh.h [new file with mode: 0644]
source/blender/blenlib/intern/BLI_kdopbvh.c [new file with mode: 0644]
source/blender/blenloader/intern/readfile.c
source/blender/include/butspace.h
source/blender/makesdna/DNA_modifier_types.h
source/blender/makesdna/DNA_sph_types.h [new file with mode: 0644]
source/blender/src/buttons_editing.c
source/blender/src/buttons_object.c
source/blender/src/drawobject.c
source/gameengine/Converter/KX_BlenderSceneConverter.cpp
source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h

index b58fe9456639abdd060aa9f9f6812e3083a54bbb..19a03c35bfc8d9c47df1e74c2ac907108acbd065 100644 (file)
@@ -1,4 +1,4 @@
-# $Id$
+# $Id: CMakeLists.txt 12480 2007-11-05 16:46:48Z sirdude $
 # ***** BEGIN GPL LICENSE BLOCK *****
 #
 # This program is free software; you can redistribute it and/or
index c5495fdf92b5bacddecd072f7f0705bbbbeab8ca..b5ae20253cc0f795111fcbf7a321acae2845bd49 100644 (file)
@@ -1,4 +1,4 @@
-# $Id$
+# $Id: CMakeLists.txt 14444 2008-04-16 22:40:48Z hos $
 # ***** BEGIN GPL LICENSE BLOCK *****
 #
 # This program is free software; you can redistribute it and/or
index e05d441a6be12cce5baa003cd132158a7219f058..2da1a5bcf854db80a531304fcc143b962cf93b8d 100644 (file)
@@ -1,5 +1,5 @@
 #
-# $Id$
+# $Id: Makefile 14444 2008-04-16 22:40:48Z hos $
 #
 # ***** BEGIN GPL LICENSE BLOCK *****
 #
index 24f3ca9767d2d928c4961de36de2c18ba39f2046..d7bb6a5e427617a22dc1ef11ddba58581525abb4 100644 (file)
@@ -1,5 +1,5 @@
 #
-# $Id$
+# $Id: Makefile 14444 2008-04-16 22:40:48Z hos $
 #
 # ***** BEGIN GPL LICENSE BLOCK *****
 #
index 1b0ba13c70710b55d4874bbb61de44ed0d542ba4..f90621f3b73cc6871a7c929e4f6522dead052a3b 100644 (file)
 #define round(x) (x)
 #endif
 
+#if PARALLEL==1        
+#include <omp.h>
+#endif
+
 /******************************************************************************
  * Constructor
  *****************************************************************************/
@@ -160,13 +164,6 @@ void IsoSurface::triangulate( void )
                mpEdgeVerticesZ[i] = -1;
        }
 
-       ntlVec3Gfx pos[8];
-       float value[8];
-       int cubeIndex;      // index entry of the cube 
-       int triIndices[12]; // vertex indices 
-       int *eVert[12];
-       IsoLevelVertex ilv;
-
        // edges between which points?
        const int mcEdges[24] = { 
                0,1,  1,2,  2,3,  3,0,
@@ -193,7 +190,12 @@ void IsoSurface::triangulate( void )
                                px = mStart[0]-gsx*0.5;
                                for(int i=1;i<(mSizex-2);i++) {
                                        px += gsx;
-
+                                       int cubeIndex;      // index entry of the cube 
+                                       float value[8];
+                                       int triIndices[12]; // vertex indices 
+                                       int *eVert[12];
+                                       IsoLevelVertex ilv;
+                                       
                                        value[0] = *getData(i  ,j  ,k  );
                                        value[1] = *getData(i+1,j  ,k  );
                                        value[2] = *getData(i+1,j+1,k  );
@@ -239,6 +241,7 @@ void IsoSurface::triangulate( void )
                                        eVert[11] = &mpEdgeVerticesZ[ ISOLEVEL_INDEX( i+0, j+1, edgek+0) ];
 
                                        // grid positions
+                                       ntlVec3Gfx pos[8];
                                        pos[0] = ntlVec3Gfx(px    ,py    ,pz);
                                        pos[1] = ntlVec3Gfx(px+gsx,py    ,pz);
                                        pos[2] = ntlVec3Gfx(px+gsx,py+gsy,pz);
@@ -344,10 +347,7 @@ void IsoSurface::triangulate( void )
                if(mUseFullEdgeArrays) {
                        errMsg("IsoSurface::triangulate","Disabling mUseFullEdgeArrays!");
                }
-
-               // subdiv local arrays
-               gfxReal orgval[8];
-               gfxReal subdAr[2][11][11]; // max 10 subdivs!
+               
                ParticleObject* *arppnt = new ParticleObject*[mSizez*mSizey*mSizex];
 
                // construct pointers
@@ -408,13 +408,25 @@ void IsoSurface::triangulate( void )
 
                debMsgStd("IsoSurface::triangulate",DM_MSG,"Starting. Parts in use:"<<pInUse<<", Subdivs:"<<mSubdivs, 9);
                pz = mStart[2]-(double)(0.*gsz)-0.5*orgGsz;
+       
                for(int ok=1;ok<(mSizez-2)*mSubdivs;ok++) {
                        pz += gsz;
                        const int k = ok/mSubdivs;
                        if(k<=0) continue; // skip zero plane
+#if PARALLEL==1        
+#pragma omp parallel for
+#endif 
                        for(int j=1;j<(mSizey-2);j++) {
                                for(int i=1;i<(mSizex-2);i++) {
-
+                                       float value[8];
+                                       ntlVec3Gfx pos[8];
+                                       int cubeIndex;      // index entry of the cube 
+                                       int triIndices[12]; // vertex indices 
+                                       int *eVert[12];
+                                       IsoLevelVertex ilv;
+                                       gfxReal orgval[8];
+                                       gfxReal subdAr[2][11][11]; // max 10 subdivs!
+                                       
                                        orgval[0] = *getData(i  ,j  ,k  );
                                        orgval[1] = *getData(i+1,j  ,k  );
                                        orgval[2] = *getData(i+1,j+1,k  ); // with subdivs
@@ -426,6 +438,7 @@ void IsoSurface::triangulate( void )
 
                                        // prebuild subsampled array slice
                                        const int sdkOffset = ok-k*mSubdivs; 
+
                                        for(int sdk=0; sdk<2; sdk++) 
                                                for(int sdj=0; sdj<mSubdivs+1; sdj++) 
                                                        for(int sdi=0; sdi<mSubdivs+1; sdi++) {
@@ -580,8 +593,13 @@ void IsoSurface::triangulate( void )
 
                                                                                // init isolevel vertex
                                                                                ilv.v = p1 + (p2-p1)*mu; // with subdivs
+#if PARALLEL==1        
+#pragma omp critical
+#endif
+                                                                               {
                                                                                mPoints.push_back( ilv );
                                                                                triIndices[e] = (mPoints.size()-1);
+                                                                               }
                                                                                // store vertex 
                                                                                *eVert[ e ] = triIndices[e]; 
                                                                        }       else {
@@ -591,23 +609,27 @@ void IsoSurface::triangulate( void )
                                                                } // along all edges 
                                                        }
                                                        // removed cutoff treatment...
-
+                                                       
                                                        // Create the triangles... 
+#if PARALLEL==1        
+#pragma omp critical
+#endif
+                                                       {
                                                        for(int e=0; mcTriTable[cubeIndex][e]!=-1; e+=3) {
                                                                mIndices.push_back( triIndices[ mcTriTable[cubeIndex][e+0] ] );
                                                                mIndices.push_back( triIndices[ mcTriTable[cubeIndex][e+1] ] ); // with subdivs
                                                                mIndices.push_back( triIndices[ mcTriTable[cubeIndex][e+2] ] );
                                                                //errMsg("TTT"," i1"<<mIndices[mIndices.size()-3]<<" "<< " i2"<<mIndices[mIndices.size()-2]<<" "<< " i3"<<mIndices[mIndices.size()-1]<<" "<< mIndices.size() );
-                                                       }
-
                                                        } // triangles in edge table?
+                                                       }
+                                                       }
                                                        
                                                }//si
                                        }// sj
 
                                }//i
                        }// j
-
+                       
                        // copy edge arrays
                        for(int j=0;j<(mSizey-0)*mSubdivs;j++) 
                                for(int i=0;i<(mSizex-0)*mSubdivs;i++) {
index 70ecb9ce3e080cec9fc77b4f042b607d050e6c7e..163965901e8f61efcac92ee73123e3bc923b9004 100644 (file)
@@ -34,7 +34,7 @@
 
 // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 #define  GRID_REGION_START()  \
-       { /* main_region */ \
+{ /* main_region */ \
        int kstart=getForZMinBnd(), kend=getForZMaxBnd(mMaxRefine); \
        if(gridLoopBound>0){ kstart=getForZMin1(), kend=getForZMax1(mMaxRefine); } \
        int kdir = 1; \
@@ -49,7 +49,7 @@
        kend = kstart-1; \
        kstart = temp-1; \
        temp = id; /* dummy remove warning */ \
-       } \
+} \
 
 
 
 
 // loop start
 #define  GRID_REGION_START()  \
-       { \
+{ \
         \
         \
        if(mSizez<2) { \
        mPanic = 1; \
        errFatal("ParaLoop::2D","Not valid...!", SIMWORLD_GENERICERROR); \
-       } \
+} \
         \
         \
        vector<LbmPoint> calcListFull; \
        int temp = kend; \
        kend = kstart-1; \
        kstart = temp-1; \
-       } \
+} \
         \
        const int Nj = mLevel[mMaxRefine].lSizey; \
        int jstart = 0+( id * (Nj / Nthrds) ); \
        int jend   = 0+( (id+1) * (Nj / Nthrds) ); \
        if( ((Nj/Nthrds) *Nthrds) != Nj) { \
        errMsg("LbmFsgrSolver","Invalid domain size Nj="<<Nj<<" Nthrds="<<Nthrds); \
-       } \
+} \
         \
        if(jstart<gridLoopBound) jstart = gridLoopBound; \
        if(jend>mLevel[mMaxRefine].lSizey-gridLoopBound) jend = mLevel[mMaxRefine].lSizey-gridLoopBound; \
 // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 #define  GRID_LOOPREG_END()  \
         \
-       } /* i */ \
+} /* i */ \
        int i=0; \
        ADVANCE_POINTERS(2*gridLoopBound); \
-       } /* j */ \
+} /* j */ \
        /* COMPRESSGRIDS!=1 */ \
        /* int i=0;  */ \
        /* ADVANCE_POINTERS(mLevel[lev].lSizex*2);  */ \
-       } /* all cell loop k,j,i */ \
+} /* all cell loop k,j,i */ \
        if(doReduce) { } /* dummy remove warning */ \
-       } /* main_region */ \
+} /* main_region */ \
         \
 
 
index 6bb224b625ac352d968b81e49e88682fe152f032..de315c5a6e1af089c544992a617e82dc086134ce 100644 (file)
@@ -1,4 +1,3 @@
-
 // same as grid loop_end + barrier
 
                        } // i
@@ -22,9 +21,9 @@
 {
        if(doReduce) {
                // synchronize global vars
-               for(int j=0; j<calcListFull.size() ; j++) mListFull.push_back( calcListFull[j] ); 
-               for(int j=0; j<calcListEmpty.size(); j++) mListEmpty.push_back( calcListEmpty[j] ); 
-               for(int j=0; j<calcListParts.size(); j++) mpParticles->addFullParticle( calcListParts[j] );
+               for(unsigned int j=0; j<calcListFull.size() ; j++) mListFull.push_back( calcListFull[j] ); 
+               for(unsigned int j=0; j<calcListEmpty.size(); j++) mListEmpty.push_back( calcListEmpty[j] ); 
+               for(unsigned int j=0; j<calcListParts.size(); j++) mpParticles->addFullParticle( calcListParts[j] );
                if(calcMaxVlen>mMaxVlen) {  
                        mMxvx = calcMxvx;  
                        mMxvy = calcMxvy;  
index c953d2f47da66979878b645e62bfc1f28aec0679..105c8ff309439beb9080af17fdd4d9b941d3f0a6 100644 (file)
@@ -706,8 +706,9 @@ bool LbmFsgrSolver::initializeSolverMemory()
                if(sizeof(void *)==4 && memEstFine>maxDefaultMemChunk) {
                        // max memory chunk for 32bit systems 2gig
                        memBlockAllocProblem = true;
+                       
                }
-
+               
                if(memEstFromFunc>memLimit || memBlockAllocProblem) {
                        sizeReduction *= 0.9;
                        mSizex = (int)(orgSx * sizeReduction);
index 13ebf91b6961b4483d7fd5dcf66d5e0b609cd532..7b91724a6402a63e16a53ee5b957d594804581f0 100644 (file)
@@ -368,8 +368,7 @@ LbmFsgrSolver::mainLoop(int lev)
 
        const int cutMin  = 1;
        const int cutConst = mCutoff+2;
-
-
+       
 #      if LBM_INCLUDE_TESTSOLVERS==1
        // 3d region off... quit
        if((mUseTestdata)&&(mpTest->mFarfMode>0)) { return; }
diff --git a/intern/sph/SConscript b/intern/sph/SConscript
new file mode 100644 (file)
index 0000000..52243f7
--- /dev/null
@@ -0,0 +1,11 @@
+#!/usr/bin/python
+import sys
+import os
+Import('env')
+
+sources = env.Glob('intern/*.cpp')
+
+incs = ' . extern intern' 
+defs = ''
+
+env.BlenderLib ('bf_sph', sources, Split(incs), Split(defs), libtype='blender', priority=0 )
diff --git a/intern/sph/extern/sph_extern.h b/intern/sph/extern/sph_extern.h
new file mode 100644 (file)
index 0000000..b496473
--- /dev/null
@@ -0,0 +1,51 @@
+/**
+ * ***** BEGIN GPL/BL DUAL 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. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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) Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Daniel Genrich.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#ifndef PW_EXTERN_H
+#define PW_EXTERN_H
+
+
+
+#ifdef __cplusplus
+extern "C" { 
+#endif
+/*
+void sph_init_cpp(struct SphModifierData *sphmd);
+void sph_free_cpp(struct SphModifierData *sphmd);
+int sph_simulate_cpp(struct Object *ob, struct SphModifierData *sphmd, float frame, struct ListBase *effectors);
+*/
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif //PW_EXTERN_H   
+
+
diff --git a/intern/sph/intern/sph.cpp b/intern/sph/intern/sph.cpp
new file mode 100644 (file)
index 0000000..f7afa3c
--- /dev/null
@@ -0,0 +1,51 @@
+/*  pw.c
+*
+*
+* ***** BEGIN GPL/BL DUAL 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. The Blender
+* Foundation also sells licenses for use in proprietary software under
+* the Blender License.  See http://www.blender.org/BL/ for information
+* about this.
+*
+* 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) Blender Foundation
+* All rights reserved.
+*
+* Contributor(s): Daniel Genrich
+*
+* ***** END GPL/BL DUAL LICENSE BLOCK *****
+*/
+
+#include <iostream>
+
+#include "sph_extern.h"
+/*
+extern "C" void sph_init_cpp(struct SphModifierData *sphmd)
+{
+
+}
+/*
+extern "C" void sph_free_cpp(struct SphModifierData *sphmd)
+{
+
+       
+}
+
+extern "C" int sph_simulate_cpp(struct Object *ob, struct SphModifierData *sphmd, float frame, struct ListBase *effectors)
+{
+       
+       return 1;
+}
+*/
index da88c0b8eaa25949fcb6fb74401fb7fc7b67ff19..182686a8cead52ccbcd153add4e1b02badf37a77 100644 (file)
Binary files a/release/datafiles/splash.jpg and b/release/datafiles/splash.jpg differ
diff --git a/release/scripts/flt_defaultp.py b/release/scripts/flt_defaultp.py
deleted file mode 100644 (file)
index 5c44fe2..0000000
+++ /dev/null
@@ -1 +0,0 @@
-pal = [-1,255,16711935,-16776961,-19529729,-19726337,-19922945,-20119553,-20316161,-20578305,-20840449,-21102593,-21364737,-21692417,-22020097,-22413313,-22806529,-23199745,-23658497,-24117249,-24641537,-25165825,-25755649,-26411009,-27066369,-27787265,-28573697,-29425665,-30343169,-31326209,-32374785,-33488897,-354549761,-371458049,-388366337,-405274625,-422182913,-439156737,-456130561,-473104385,-506855425,-540672001,-574488577,-608305153,-642121729,-676003841,-709885953,-760610817,-811335681,-862060545,-912850945,-980418561,-1048051713,-1115684865,-1183383553,-1267924993,-1352466433,-1453850625,-1555300353,-1656815617,-1775173633,-1893597185,-2028863489,2130771967,-1010376193,-1043996161,-1077681665,-1111367169,-1145052673,-1178738177,-1229200897,-1279663617,-1330126337,-1380654593,-1431182849,-1498488321,-1565793793,-1633164801,-1700535809,-1784684033,-1868832257,-1969823233,-2070814209,2123096575,2005262847,1887429119,1752752639,1601298943,1449779711,1281417727,1096278527,911073791,709026303,490201599,254534143,2023935,-1380857601,-1397700353,-1431320321,-1464940289,-1498560257,-1532180225,-1565865729,-1599551233,-1650013953,-1700476673,-1750939393,-1801402113,-1851864833,-1919170305,-1986475777,-2053781249,-2121086721,2089797887,2005649663,1904724223,1803798783,1686030591,1568262399,1450494207,1315883263,1164495103,1013041407,844810495,659736831,457885951,239192319,3655935,-1767919617,-1784762369,-1801605121,-1818447873,-1852067841,-1885687809,-1919307777,-1952927745,-1986547713,-2020167681,-2070564865,-2120962049,2123542527,2073079807,2022617087,1955377151,1888137215,1820897279,1736880127,1652797439,1568714751,1467854847,1366994943,1249357823,1131655167,997175295,862695423,711372799,560050175,391950335,207007743,5287935,2139657983,2122880767,2106103551,2089326335,2072549119,2055771903,2022217471,1988663039,1955108607,1921554175,1887934207,1854314239,1803917055,1753519871,1703122687,1652725503,1602328319,1535153919,1467979519,1400805119,1316853503,1232901887,1148950271,1048221439,947427071,846632703,729061119,611489535,477140735,326014719,174888703,6919935,1837268479,1820491263,1803714047,1786936831,1770159615,1753382399,1736605183,1719827967,1686273535,1652719103,1619164671,1585610239,1552055807,1518501375,1468169727,1417838079,1367506431,1317174783,1266843135,1199734271,1132625407,1065516543,998407679,914521599,830635519,729972223,629308927,528645631,411205119,293764607,159546879,8551935,-2086957569,-2103734785,-2120512001,-2137289217,2140900863,2107346431,2073791999,2040237311,2006682623,1973127935,1939573247,1906018559,1855686655,1805354751,1755022847,1704690943,1654359039,1587249919,1520140799,1453031679,1369145343,1285258751,1201372159,1100708351,1000044543,882603519,765162495,630943999,496725503,345729791,177956863,10183935,-1699437825,-1716215297,-1732992769,-1766547457,-1800102145,-1833656833,-1867211521,-1900766209,-1934320897,-1967875585,-2018207489,-2068539649,-2118871809,2125763327,2058653951,1991544575,1924435199,1857325823,1773438975,1689552127,1588888063,1488223999,1387559679,1270118143,1152676607,1018457855,884238847,733242623,565468927,397695231,213144319,11815935,-1311918593,-1345473281,-1379027969,-1412582657,-1446137345,-1479692289,-1513247233,-1546802177,-1597134337,-1647466497,-1697798657,-1748130817,-1798463233,-1865572865,-1932682497,-1999792129,-2083678977,2127401215,2043514111,1942849791,1842185215,1724743423,1607301631,1473082367,1338863103,1187866367,1020092415,852318207,667766783,466437887,248331519,13447935,-924398849,-957953793,-991508737,-1025063681,-1058618625,-1092173569,-1142505729,-1192837889,-1243170305,-1293502721,-1343835137,-1410944769,-1478054401,-1545164289,-1629051393,-1712938497,-1796825857,-1897490433,-1998155009,-2098819841,2078705407,1961263103,1827043583,1676046591,1525049599,1357275135,1172723199,971394047,753287423,518403327,283518975,15079935,-570434049,-603988993,-637543937,-671098881,-704653825,-754986241,-805318657,-855651073,-905983489,-973093377,-1040203265,-1107313153,-1174423041,-1258310401,-1342197761,-1442862593,-1543527425,-1644192257,-1761634561,-1879076865,-2013296641,2147450879,1996453631,1828678911,1660904191,1476351999,1275022335,1056915199,822030591,570368511,301928959,16711935,-503325185,-536880129,-570435073,-603990017,-637544961,-671100161,-721432577,-771764993,-822097409,-872430081,-922762753,-989872641,-1056982529,-1124092673,-1191202817,-1275090433,-1358978049,-1459642881,-1560307969,-1660973057,-1778415617,-1895858177,-2030078209,2113891583,1962894079,1795119103,1610566655,1426013951,1224683775,1006576127,771691007,520028415,-452993537,-469771265,-503326209,-536881153,-570436097,-603991297,-637546497,-671101697,-721434113,-771766785,-822099457,-872432129,-922764801,-989874945,-1056985089,-1124095489,-1191205889,-1275093505,-1358981377,-1459646465,-1560311809,-1677754369,-1795197185,-1912640257,-2046860545,2097108991,1946110975,1778335487,1593782527,1392452095,1174344191,939458815,-419439105,-436216833,-452994561,-469772289,-503327233,-536882433,-570437633,-603992833,-637548033,-671103489,-721436161,-771768833,-822101505,-872434433,-922767361,-989877761,-1056988161,-1124098561,-1207986433,-1291874305,-1375762433,-1476427777,-1577093377,-1694536449,-1811979521,-1946200065,-2080420865,2063548159,1912549631,1744773631,1560220159,1358889215,-385884673,-402662401,-419440129,-436217857,-452995585,-469773569,-503328769,-536883969,-570439169,-603994625,-637550081,-671105537,-721438209,-771771137,-822104065,-872437249,-922770433,-989880833,-1056991489,-1124102145,-1191213057,-1275101185,-1358989569,-1459655425,-1560321281,-1677764609,-1795208193,-1912652033,-2046873345,2097095167,1946096127,1778319615,-335553025,-352330753,-369108481,-385886209,-402663937,-419441921,-436219905,-452997889,-486553089,-520108545,-553664001,-587219457,-620774913,-654330625,-687886337,-738219521,-788552705,-838885889,-889219329,-939552769,-1006663681,-1073774593,-1140885761,-1224774401,-1308663041,-1392551937,-1493218305,-1593884929,-1711329025,-1828773377,-1962995201,-2097217281,-285221377,-301999105,-318776833,-335554561,-352332289,-369110273,-385888257,-402666241,-419444225,-436222465,-453000705,-469778945,-503334401,-536890113,-570445825,-604001793,-637557761,-671113729,-721447169,-771780609,-822114305,-872448001,-922781953,-989893377,-1057004801,-1124116481,-1191228417,-1275117825,-1359007489,-1459674625,-1560342017,-1677786881,-234889729,-234890241,-251667969,-268445697,-285223425,-302001409,-318779393,-335557377,-352335361,-369113601,-385891841,-402670081,-419448321,-436226817,-453005313,-469784065,-503340033,-536896001,-570452225,-604008449,-637564929,-671121409,-704678145,-755012353,-805346561,-855681025,-906015745,-973127937,-1040240385,-1107353089,-1174466049,-1258356481,-234889729,-234890241,-234890753,-234891265,-234891777,-234892545,-234893313,-234894081,-234894849,-251673089,-268451329,-285229569,-302007809,-318786305,-335564801,-352343553,-369122305,-385901057,-402680065,-419459073,-436238337,-453017601,-486574337,-520131329,-553688321,-587245569,-620803073,-654360833,-687918849,-738254337,-788590081,-838926081,-234889729,-234890241,-234890753,-234891265,-234891777,-234892545,-234893313,-234894081,-234894849,-234895873,-234896897,-234897921,-234898945,-234900225,-234901505,-234903041,-234904577,-234906113,-234907905,-234909697,-234911745,-251691009,-268470529,-285250305,-302030081,-318810113,-335590401,-352370945,-369151745,-385932801,-402714113,-419495681,-8705,-9217,-9729,-10241,-10753,-11521,-12289,-13057,-13825,-14849,-15873,-16897,-17921,-19201,-20481,-22017,-23553,-25089,-26881,-28673,-30721,-32769,-35073,-37633,-40193,-43009,-46081,-49409,-52993,-56833,-60929,-65281,-926209,-926721,-927233,-927745,-928257,-929025,-929793,-930561,-931329,-932353,-933377,-934401,-935425,-936705,-937985,-939521,-941057,-1008129,-1075457,-1142785,-1210369,-1277953,-1345793,-1413889,-1481985,-1550337,-1618945,-1687809,-1756929,-1826305,-1895937,-2031361,-926209,-926721,-927233,-927745,-928257,-929025,-929793,-996097,-1062401,-1128961,-1195521,-1262081,-1328641,-1395457,-1462273,-1529345,-1596417,-1663489,-1730817,-1798145,-1865729,-1998849,-2132225,-2265857,-2399489,-2533377,-2667521,-2867457,-3067649,-3268097,-3468801,-3669761,-926209,-992257,-1058305,-1124353,-1190401,-1256705,-1323009,-1389313,-1455617,-1522177,-1588737,-1655297,-1721857,-1788673,-1855489,-1988097,-2120705,-2253313,-2386177,-2519041,-2652161,-2785281,-2984193,-3183361,-3382529,-3581953,-3847169,-4112641,-4378369,-4644353,-4976129,-5308161,-1188353,-1254401,-1320449,-1386497,-1452545,-1518849,-1585153,-1651457,-1717761,-1784321,-1850881,-1982977,-2115073,-2247425,-2379777,-2512385,-2644993,-2777601,-2976001,-3174401,-3373057,-3571713,-3836161,-4100865,-4365569,-4630529,-4961281,-5292289,-5689089,-6086145,-6483457,-6946561,-1384961,-1451009,-1517057,-1583105,-1649153,-1715457,-1781761,-1848065,-1979905,-2112001,-2244097,-2376193,-2508289,-2640641,-2838529,-3036673,-3234817,-3432961,-3631361,-3895297,-4159489,-4423681,-4688129,-5018369,-5348609,-5744641,-6140929,-6537473,-6999809,-7462401,-7990785,-8584961,-1581569,-1647617,-1713665,-1779713,-1845761,-1977601,-2109441,-2241281,-2373121,-2505217,-2637313,-2769409,-2967041,-3164929,-3362817,-3560961,-3759105,-4022785,-4286721,-4550657,-4880385,-5210113,-5540097,-5935873,-6331649,-6793217,-7255041,-7782657,-8310529,-8904193,-9563649,-10223361,-1712641,-1778689,-1844737,-1976321,-2107905,-2239745,-2371585,-2503425,-2635265,-2767361,-2964993,-3162625,-3360257,-3558145,-3821569,-4085249,-4348929,-4612609,-4942081,-5271553,-5666817,-6062081,-6457601,-6918913,-7380225,-7907329,-8434689,-9027841,-9686785,-10345985,-11070977,-11861761,-1843713,-1975297,-2106881,-2238465,-2370049,-2501889,-2633729,-2765569,-2962945,-3160577,-3358209,-3555841,-3753473,-4016897,-4280321,-4544001,-4873217,-5202433,-5531905,-5926913,-6322177,-6782977,-7244033,-7770881,-8297729,-8890369,-9548801,-10207489,-10931969,-11722241,-12578305,-13500161,-1974785,-2106369,-2237953,-2369537,-2501121,-2632961,-2830337,-3027713,-3225089,-3422721,-3620353,-3883521,-4146689,-4410113,-4673537,-5002753,-5331969,-5726721,-6121729,-6582273,-7043073,-7503873,-8030465,-8622849,-9215233,-9873409,-10597377,-11387137,-12242689,-13164033,-14085633,-15138561,-2236929,-2368513,-2500097,-2631681,-2763265,-2960641,-3158017,-3355393,-3552769,-3815937,-4079105,-4342273,-4605441,-4934401,-5263361,-5658113,-6052865,-6447617,-6908161,-7368705,-7895041,-8421377,-9013505,-9671425,-10329345,-11053057,-11842561,-12697857,-13618945,-14605825,-15658497,-16776961]
\ No newline at end of file
diff --git a/release/scripts/flt_palettemanager.py b/release/scripts/flt_palettemanager.py
deleted file mode 100644 (file)
index 6edaf29..0000000
+++ /dev/null
@@ -1,388 +0,0 @@
-#!BPY
-
-"""
-Name: 'FLT Palette Manager'
-Blender: 240
-Group: 'Misc'
-Tooltip: 'Manage FLT colors'
-"""
-
-__author__ = "Geoffrey Bantle"
-__version__ = "1.0 11/21/2007"
-__email__ = ('scripts', 'Author, ')
-__url__ = ('blender', 'blenderartists.org')
-
-__bpydoc__ ="""\
-
-This script manages colors in OpenFlight databases. OpenFlight is a
-registered trademark of MultiGen-Paradigm, Inc.
-
-Todo:
--Figure out whats causing the PC speaker to beep when initializing...
-
-Feature overview and more availible at:
-http://wiki.blender.org/index.php/Scripts/Manual/FLTools
-"""
-
-# --------------------------------------------------------------------------
-# flt_palettemanager.py version 0.1 2005/04/08
-# --------------------------------------------------------------------------
-# ***** BEGIN GPL LICENSE BLOCK *****
-#
-# Copyright (C) 2007: Blender Foundation
-#
-# 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.
-#
-# ***** END GPL LICENCE BLOCK *****
-# --------------------------------------------------------------------------
-
-import Blender.Draw as Draw
-from Blender.BGL import *
-import Blender
-import flt_properties
-import flt_defaultp as defaultp
-from flt_properties import *
-
-
-palette_size = 12
-palette_x = 0
-palette_y = 0
-
-colors = list()
-curint = 1.0
-curswatch = 0
-#make a default palette, not very useful.
-cinc = 1.0 / 1024.0
-cstep = 0.0
-picker = None
-ptt = ""
-for i in xrange(1024):
-       colors.append([cstep,cstep,cstep])
-       cstep = cstep + cinc
-def update_state():
-       state = dict()
-       state["activeScene"] = Blender.Scene.getCurrent()
-       state["activeObject"] = state["activeScene"].getActiveObject()
-       state["activeMesh"] = None
-       if state["activeObject"] and state["activeObject"].type == 'Mesh':
-               state["activeMesh"] = state["activeObject"].getData(mesh=True)
-       
-       state["activeFace"] = None
-       if state["activeMesh"]:
-               if state["activeMesh"].faceUV and state["activeMesh"].activeFace != None:
-                       state["activeFace"] = state["activeMesh"].faces[state["activeMesh"].activeFace]
-               
-       return state
-       
-def pack_face_index(index, intensity):
-       return ((127*intensity)+(128*index))
-def unpack_face_index(face_index):
-       index = face_index / 128
-       intensity = float(face_index - 128.0 * index) / 127.0
-       return(index,intensity)
-
-def event(evt,val):
-       global palette_size
-       global palette_x
-       global palette_y
-       global colors
-       global curint
-       global curswatch
-       
-       areas = Blender.Window.GetScreenInfo()
-       curarea = Blender.Window.GetAreaID()
-       curRect = None
-       editmode = 0
-
-       for area in areas:
-               if area['id'] == curarea:
-                       curRect = area['vertices']
-                       break
-               
-       if evt == Draw.LEFTMOUSE:
-               mval = Blender.Window.GetMouseCoords()
-               rastx = mval[0] - curRect[0]
-               rasty = mval[1] - curRect[1]
-               
-               swatchx = (rastx -palette_x) / palette_size #+state["palette_x"]
-               swatchy = (rasty -palette_y) / palette_size #+state["palette_y"]
-                if rastx > palette_x and rastx < (palette_x + palette_size * 32) and rasty > palette_y and rasty < (palette_y+ palette_size* 32):
-                        if swatchx < 32 and swatchy < 32:
-                                curswatch = (swatchx * 32) + swatchy
-                                Draw.Redraw(1)
-               
-                elif swatchy < 34 and swatchx < 32:
-                        curint = 1.0 - (float(rastx-palette_x)/(palette_size*32.0))
-                        Draw.Redraw(1)
-       
-       #copy current color and intensity to selected faces.
-       elif evt == Draw.CKEY:
-               
-               if Blender.Window.EditMode():
-                       Blender.Window.EditMode(0)
-                       editmode = 1
-               state = update_state()
-               
-               #retrieve color from palette
-               color = struct.unpack('>BBBB',struct.pack('>I',colors[curswatch]))
-               actmesh = state["activeMesh"]
-               if actmesh: 
-                       if(Blender.Window.GetKeyQualifiers() != Blender.Window.Qual["CTRL"]):
-                               selfaces = list()
-                               for face in actmesh.faces:
-                                       if face.sel:
-                                               selfaces.append(face)
-                               
-                               if not "FLT_COL" in actmesh.faces.properties:
-                                       actmesh.faces.addPropertyLayer("FLT_COL",Blender.Mesh.PropertyTypes["INT"])
-                                       for face in actmesh.faces:
-                                               face.setProperty("FLT_COL",127) #default
-                               try:
-                                       actmesh.activeColorLayer = "FLT_Fcol"
-                               except:
-                                       actmesh.addColorLayer("FLT_Fcol")
-                                       actmesh.activeColorLayer = "FLT_Fcol"
-                               
-
-                               for face in selfaces:
-                                       #First append packed index + color and store in face property
-                                       face.setProperty("FLT_COL",int(pack_face_index(curswatch,curint))) 
-                                       #Save baked color to face vertex colors
-                                       for col in face.col:
-                                               col.r = int(color[0] * curint)
-                                               col.g = int(color[1] * curint)
-                                               col.b = int(color[2] * curint)
-                                               col.a = int(color[3] * curint)
-                       else:
-                               if Blender.Mesh.Mode() == Blender.Mesh.SelectModes['VERTEX']:
-                                       if not 'FLT_VCOL' in actmesh.verts.properties:
-                                               actmesh.verts.addPropertyLayer("FLT_VCOL",Blender.Mesh.PropertyTypes["INT"])
-                                               for vert in actmesh.verts:
-                                                       vert.setProperty("FLT_VCOL",127)
-                                       else:
-                                               for vert in actmesh.verts:
-                                                       if vert.sel:
-                                                               vert.setProperty("FLT_VCOL",int(pack_face_index(curswatch,curint)))
-                       
-                       if editmode:
-                               Blender.Window.EditMode(1)
-                       
-                       Blender.Window.RedrawAll()
-       
-       #grab color and intensity from active face
-       elif evt == Draw.VKEY:
-               if Blender.Window.EditMode():
-                       Blender.Window.EditMode(0)
-                       editmode = 1
-               state = update_state()
-               
-               actmesh = state["activeMesh"]
-               activeFace = state["activeFace"]
-               
-               
-               if activeFace:
-                       if not "FLT_COL" in actmesh.faces.properties:
-                               actmesh.faces.addPropertyLayer("FLT_COL",Blender.Mesh.PropertyTypes["INT"])
-                               for face in actmesh.faces:
-                                       face.setProperty("FLT_COL",127) #default
-                       try:
-                               actmesh.activeColorLayer = "FLT_Fcol"
-                       except:
-                               actmesh.addColorLayer("FLT_Fcol")
-                               actmesh.activeColorLayer = "FLT_Fcol"
-                       tcol = activeFace.getProperty("FLT_COL")
-                       (index,intensity) = unpack_face_index(tcol)
-                       curswatch = index
-                       curint = intensity
-                       
-               if editmode:
-                       Blender.Window.EditMode(1)
-               
-               Blender.Window.RedrawAll()
-                       
-       elif evt == Draw.ESCKEY:
-               Draw.Exit()
-       
-       if editmode:
-               Blender.Window.EditMode(1)
-
-def update_all():
-       global colors
-       state = update_state()
-       #update the baked FLT colors for all meshes.
-       for object in state["activeScene"].objects:
-               if object.type == "Mesh":
-                       mesh = object.getData(mesh=True)
-                       if 'FLT_COL' in mesh.faces.properties:
-                               mesh.activeColorLayer = "FLT_Fcol"
-                               for face in mesh.faces:
-                                       (index,intensity) = unpack_face_index(face.getProperty('FLT_COL'))
-                                       color = struct.unpack('>BBBB',struct.pack('>I',colors[index]))
-                                       #update the vertex colors for this face
-                                       for col in face.col:
-                                               col.r = int(color[0] * intensity)
-                                               col.g = int(color[1] * intensity)
-                                               col.b = int(color[2] * intensity)
-                                               col.a = 255
-
-
-def but_event(evt):
-       global palette_size
-       global palette_x
-       global palette_y
-       global colors
-       global curint
-       global curswatch
-       global picker
-       state = update_state()
-
-       if evt == 1:
-               if picker.val:
-                       rval = (int(picker.val[0]*255),int(picker.val[1]*255),int(picker.val[2]*255),255)
-                       rval = struct.pack('>BBBB',rval[0],rval[1],rval[2],rval[3])
-                       rval = struct.unpack('>i',rval)
-                       colors[curswatch] = rval[0]     
-                       #go cd through all meshes and update their FLT colors
-                       update_all()
-
-       Draw.Redraw(1)
-def init_pal():
-       global palette_size
-       global palette_x
-       global palette_y
-       global colors
-       global curint
-       global curswatch
-       
-       state = update_state()
-
-       if not state["activeScene"].properties.has_key('FLT'):
-               state["activeScene"].properties['FLT'] = dict()
-
-       try:
-               colors = state["activeScene"].properties['FLT']['Color Palette']
-       except:
-               state["activeScene"].properties['FLT']['Color Palette'] = defaultp.pal
-               colors = state["activeScene"].properties['FLT']['Color Palette']
-
-def draw_palette():
-       global palette_size
-       global palette_x
-       global palette_y
-       global colors
-       global curint
-       global curswatch
-        global picker
-
-       state = update_state()
-       init_pal()
-
-       ssize = palette_size
-       xpos = palette_x
-       cid = 0
-
-       highlight = [(palette_x,palette_y),(palette_x+palette_size,palette_y),(palette_x+palette_size,palette_y+palette_size),(palette_x,palette_y+palette_size)]
-       for x in xrange(32):
-               ypos = palette_y
-               for y in xrange(32):
-                       color = struct.unpack('>BBBB',struct.pack('>I',colors[cid]))
-                       glColor3f(color[0]/255.0,color[1]/255.0,color[2]/255.0)
-                       glBegin(GL_POLYGON)
-                       glVertex2i(xpos,ypos)
-                       glVertex2i(xpos+ssize,ypos)
-                       glVertex2i(xpos+ssize,ypos+ssize)
-                       glVertex2i(xpos,ypos+ssize)                             
-                       glEnd()
-                       
-                       if curswatch == cid:
-                               highlight[0] = (xpos,ypos)
-                               highlight[1] = (xpos+ssize,ypos)
-                               highlight[2] = (xpos+ssize,ypos+ssize)
-                               highlight[3] = (xpos,ypos+ssize)
-               
-                       glColor3f(0.0,0.0,0.0)
-                       glBegin(GL_LINE_LOOP)
-                       glVertex2i(xpos,ypos)
-                       glVertex2i(xpos+ssize,ypos)
-                       glVertex2i(xpos+ssize,ypos+ssize)
-                       glVertex2i(xpos,ypos+ssize)
-                       glVertex2i(xpos,ypos)                           
-                       glEnd()                 
-                               
-                       
-                       cid = cid + 1
-                       ypos = ypos + ssize
-               
-               xpos = xpos + ssize
-       
-       #draw intensity gradient
-       color = struct.unpack('>BBBB',struct.pack('>I',colors[curswatch]))
-       color = [color[0]/255.0,color[1]/255.0,color[2]/255.0]
-       colsteps = [color[0]/255.0,color[1]/255.0,color[2]/255.0]
-       stripwidth = (palette_size * 32.0) / 256
-       strippad = palette_size / 2.0
-       
-       xpos = palette_x
-       grady = (palette_y + (palette_size * 32.0)) + strippad
-       for x in xrange(256):
-               color[0] = color[0] - colsteps[0]
-               color[1] = color[1] - colsteps[1] 
-               color[2] = color[2] - colsteps[2]
-
-               glColor3f(color[0], color[1] ,color[2])
-               glBegin(GL_POLYGON)
-               glVertex2f(xpos,grady)
-               glVertex2f(xpos+stripwidth,grady)
-               glVertex2f(xpos+stripwidth,grady+palette_size)
-               glVertex2f(xpos,grady+palette_size)
-               glEnd()
-               xpos = xpos + stripwidth
-               
-       #draw intensity slider bar
-       #xposition ==  512 - ((curint) * 512)
-       xpos = ((palette_size*32) * (1.0 - curint)) + palette_x
-       glColor3f(1.0,1.0,1.0)
-       glBegin(GL_LINE_LOOP)
-       glVertex2i(xpos-6,grady-1)
-       glVertex2i(xpos+6,grady-1)
-       glVertex2i(xpos+6,grady+palette_size+1)
-       glVertex2i(xpos-6,grady+palette_size+1)
-       #glVertex2i(xpos-6,grady+7)
-       glEnd()
-
-       #draw color picker
-       color = struct.unpack('>BBBB',struct.pack('>I',colors[curswatch]))
-       pickcol = (color[0]/255.0,color[1]/255.0,color[2]/255.0)
-       picker = Blender.Draw.ColorPicker(1,highlight[0][0]+1,highlight[0][1]+1,ssize-2,ssize-2,pickcol,ptt)
-
-       #draw highlight swatch
-       glColor3f(1.0,1.0,1.0)
-       glBegin(GL_LINE_LOOP)
-       glVertex2i(highlight[0][0],highlight[0][1])
-       glVertex2i(highlight[1][0],highlight[1][1])
-       glVertex2i(highlight[2][0],highlight[2][1])
-       glVertex2i(highlight[3][0],highlight[3][1])
-       glVertex2i(highlight[0][0],highlight[0][1])
-       glEnd()                 
-
-def gui():
-       glClearColor(0.5,0.5,0.5,1.0)
-       glClear(GL_COLOR_BUFFER_BIT)
-       draw_palette()
-
-
-init_pal()
-Draw.Register(gui,event,but_event)
-       
diff --git a/release/scripts/flt_properties.py b/release/scripts/flt_properties.py
deleted file mode 100644 (file)
index bc7c972..0000000
+++ /dev/null
@@ -1,628 +0,0 @@
-#!BPY
-# flt_properties.py. For setting default OpenFLight ID property types
-# Copyright (C) 2007 Blender Foundation
-#
-# 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-__bpydoc__ ="""\
-Utility functions and data defintions used by OpenFlight I/O and tool scripts. OpenFlight is a
-registered trademark of MultiGen-Paradigm, Inc.
-"""
-
-
-import struct 
-
-bitsLSB = [2147483648]
-for i in xrange(31):
-       bitsLSB.append(bitsLSB[-1]/2)
-bitsRSB = bitsLSB[:]
-bitsRSB.reverse()
-
-def pack_color(col):
-       return struct.pack('>B',col[3]) + struct.pack('>B',col[2]) + struct.pack('>B',col[1]) + struct.pack('>B',col[0])
-       
-def unpack_color(col):
-       string = struct.pack('>I', col)
-       r = struct.unpack('>B',string[3:4])
-       g = struct.unpack('>B',string[2:3])
-       b = struct.unpack('>B',string[1:2])
-       a = struct.unpack('>B',string[0:1])
-       return [r,g,b,a] 
-
-def reverse_bits(len,num):
-       bitbucket = list()
-       rval = 0
-       
-       for i in xrange(len):
-               if num & bitsRSB[i]:
-                       bitbucket.append(1)
-               else:
-                       bitbucket.append(0)
-       
-       bitbucket.reverse()
-       
-       for i, bit in enumerate(bitbucket):
-               if bit:
-                       rval |= bitsLSB[i]
-       
-       return rval
-       
-       
-opcode_name = { 0: 'db',
-                               1: 'head',
-                               2: 'grp',
-                               4: 'obj',
-                               5: 'face',
-                               10: 'push',
-                               11: 'pop',
-                               14: 'dof',
-                               19: 'push sub',
-                               20: 'pop sub',
-                               21: 'push ext',
-                               22: 'pop ext',
-                               23: 'cont',
-                               31: 'comment',
-                               32: 'color pal',
-                               33: 'long id',
-                               49: 'matrix',
-                               50: 'vector',
-                               52: 'multi-tex',
-                               53: 'uv lst',
-                               55: 'bsp',
-                               60: 'rep',
-                               61: 'inst ref',
-                               62: 'inst def',
-                               63: 'ext ref',
-                               64: 'tex pal',
-                               67: 'vert pal',
-                               68: 'vert w col',
-                               69: 'vert w col & norm',
-                               70: 'vert w col, norm & uv',
-                               71: 'vert w col & uv',
-                               72: 'vert lst',
-                               73: 'lod',
-                               74: 'bndin box',
-                               76: 'rot edge',
-                               78: 'trans',
-                               79: 'scl',
-                               80: 'rot pnt',
-                               81: 'rot and/or scale pnt',
-                               82: 'put',
-                               83: 'eyepoint & trackplane pal',
-                               84: 'mesh',
-                               85: 'local vert pool',
-                               86: 'mesh prim',
-                               87: 'road seg',
-                               88: 'road zone',
-                               89: 'morph vert lst',
-                               90: 'link pal',
-                               91: 'snd',
-                               92: 'rd path',
-                               93: 'snd pal',
-                               94: 'gen matrix',
-                               95: 'txt',
-                               96: 'sw',
-                               97: 'line styl pal',
-                               98: 'clip reg',
-                               100: 'ext',
-                               101: 'light src',
-                               102: 'light src pal',
-                               103: 'reserved',
-                               104: 'reserved',
-                               105: 'bndin sph',
-                               106: 'bndin cyl',
-                               107: 'bndin hull',
-                               108: 'bndin vol cntr',
-                               109: 'bndin vol orient',
-                               110: 'rsrvd',
-                               111: 'light pnt',
-                               112: 'tex map pal',
-                               113: 'mat pal',
-                               114: 'name tab',
-                               115: 'cat',
-                               116: 'cat dat',
-                               117: 'rsrvd',
-                               118: 'rsrvd',
-                               119: 'bounding hist',
-                               120: 'rsrvd',
-                               121: 'rsrvd',
-                               122: 'push attrib',
-                               123: 'pop attrib',
-                               124: 'rsrvd',
-                               125: 'rsrvd',
-                               126: 'curv',
-                               127: 'road const',
-                               128: 'light pnt appear pal',
-                               129: 'light pnt anim pal',
-                               130: 'indexed lp',
-                               131: 'lp sys',
-                               132: 'indx str',
-                               133: 'shdr pal'}
-
-
-typecodes = ['c','C','s','S','i','I','f','d','t']
-
-FLT_GRP =      2
-FLT_OBJ =      4
-FLT_LOD =      73
-FLT_XRF =      63
-FLT_DOF =      14
-FLT_ILP =      111
-FLT_DB =       1
-FLT_FCE =      5
-
-#not actual opcodes
-FLT_NUL =      0
-FLT_EXP =      -1
-
-#valid childtypes for each FLT node type
-FLT_CHILDTYPES = { 
-       FLT_GRP : [111,2,73,4,14,63],
-       FLT_OBJ : [111],
-       FLT_LOD : [111,2,73,4,14,63],
-       FLT_XRF : [],
-       FLT_DOF : [111,2,73,4,14,63],
-       FLT_ILP : []
-}
-
-#List of nodes that can have faces as children
-FLT_FACETYPES = [
-       FLT_GRP,
-       FLT_OBJ,
-       FLT_LOD,
-       FLT_DOF
-]
-
-def write_prop(fw,type,value,length):
-       if type == 'c':
-               fw.write_char(value)
-       elif type == 'C':
-               fw.write_uchar(value)
-       elif type == 's':
-               fw.write_short(value)
-       elif type == 'S':
-               fw.write_ushort(value)
-       elif type == 'i':
-               fw.write_int(value)
-       elif type == 'I':
-               fw.write_uint(value)
-       elif type == 'd':
-               fw.write_double(value)
-       elif type == 'f':
-               fw.write_float(value)
-       elif type == 't':
-               fw.write_string(value,length)
-
-def read_prop(fw,type,length):
-       rval = None
-       if type == 'c':
-               rval = fw.read_char()
-       elif type == 'C':
-               rval = fw.read_uchar()
-       elif type == 's':
-               rval = fw.read_short()
-       elif type == 'S':
-               rval = fw.read_ushort()
-       elif type == 'i':
-               rval = fw.read_int()
-       elif type == 'I':
-               rval = fw.read_uint()
-       elif type == 'd':
-               rval = fw.read_double()
-       elif type == 'f':
-               rval = fw.read_float()
-       elif type == 't':
-               rval = fw.read_string(length)
-       return rval
-       
-       
-FLTExt = {
-       '3t8!id' : 'Ext',
-       '4t8!sid' : '',
-       '5c!reserved': 0,
-       '6c!revision' : 0,
-       '7S!recordcode' : 0
-}
-FLTGroup = {
-       '3t8!id' : 'G',
-       '4s!priority' : 0, 
-       '5s!reserved1' : 0, 
-       '6i!flags' : 0, 
-       '7s!special1' : 0,
-       '8s!special2' : 0, 
-       '9s!significance' : 0,
-       '10c!layer code' : 0,
-       '11c!reserved2' : 0,
-       '12i!reserved3' : 0,
-       '13i!loop count' : 0,
-       '14f!loop duration' : 0,
-       '15f!last frame duration' : 0
-}
-FLTGroupDisplay = [5,11,12]
-
-FLTObject = {
-       '3t8!id' : 'O',
-       '4I!flags' : 0,
-       '5s!priority' : 0,
-       '6S!transp' : 0,
-       '7s!SFX1' : 0,
-       '8s!SFX2' : 0,
-       '9s!significance' : 0,
-       '10s!reserved' : 0
-}
-FLTObjectDisplay = [10]
-
-FLTLOD = {
-       '3t8!id' : 'L',
-       '4i!reserved' : 0,
-       '5d!switch in' : 0,
-       '6d!switch out' : 0,
-       '7s!sfx ID1' : 0,
-       '8s!sfx ID2' : 0,
-       '9I!flags' : 0,
-       '10d!X co' : 0,
-       '11d!Y co' : 0,
-       '12d!Z co' : 0,
-       '13d!Transition' : 0,
-       '14d!Sig Size' : 0
-}
-FLTLODDisplay = [4]
-
-FLTInlineLP = {
-       '3t8!id' : 'Lp',
-       '4s!smc' : 0,
-       '5s!fid' : 0,
-       '6C!back color: a' : 255,
-       '7C!back color: b' : 255,
-       '8C!back color: g' : 255,
-       '9C!back color: r' : 255,
-       '10i!display mode' : 0,
-       '11f!intensity' : 1.0,
-       '12f!back intensity' : 0.0,
-       '13f!minimum defocus' : 0.0,
-       '14f!maximum defocus' : 1.0,
-       '15i!fading mode' : 0,
-       '16i!fog punch mode' : 0,
-       '17i!directional mode' : 1,
-       '18i!range mode' : 0,
-       '19f!min pixel size' : 1.0,
-       '20f!max pixel size' : 1024,
-       '21f!actual size' : 0.25,
-       '22f!trans falloff pixel size' : 0.25,
-       '23f!trans falloff exponent' : 1.0,
-       '24f!trans falloff scalar' : 1.0,
-       '25f!trans falloff clamp' : 1.0,
-       '26f!fog scalar' : 0.25,
-       '27f!fog intensity' : 1.0,
-       '28f!size threshold' : 0.1,
-       '29i!directionality' : 0,
-       '30f!horizontal lobe angle' : 180.0,
-       '31f!vertical lobe angle' : 180.0,
-       '32f!lobe roll angle' : 0.0,
-       '33f!dir falloff exponent' : 1.0,
-       '34f!dir ambient intensity' : 0.1,
-       '35f!anim period' : 2,
-       '36f!anim phase' : 0,
-       '37f!anim enabled' : 1.0,
-       '38f!significance' : 0.0,
-       '39i!draw order' : 0,
-       '40I!flags' : 277004288, 
-       '41f!roti' : 0,
-       '42f!rotj' : 0,
-       '43f!rotk' : 1.0
-}
-
-FLTInlineLPDisplay = [35,36,37,41,42,43]
-
-FLTXRef = {
-       '3t200!filename' : '', #we dont actually use this value on export
-       '4i!reserved' : 0,
-       '5I!flag' : -478150656,
-       '6s!bbox' : 0,
-       '7s!reserved' : 0
-}
-
-FLTXRefDisplay = [4,7,3]
-
-FLTDOF = {
-       '3t8!id' : 'D',         
-       '4i!reserved' : 0,
-       '5d!ORIGX' : 0.0,
-       '6d!ORIGY' : 0.0, 
-       '7d!ORIGZ' : 0.0,
-       '8d!XAXIS-X' : 10.0,
-       '9d!XAXIS-Y' : 0.0,
-       '10d!XAXIS-Z' : 0.0,
-       '11d!XYPLANE-X' : 0.0,
-       '12d!XYPLANE-Y' : 10.0,
-       '13d!XZPLANE-Z' : 0.0,
-       '14d!ZMIN' : 0.0,
-       '15d!ZMAX' : 0.0,
-       '16d!ZCUR' : 0.0,
-       '17d!ZSTEP' : 0.0,
-       '18d!YMIN' : 0.0,
-       '19d!YMAX' : 0.0,
-       '20d!YCUR' : 0.0,
-       '21d!YSTEP' : 0.0,
-       '22d!XMIN' : 0.0,
-       '23d!XMAX' : 0.0,
-       '24d!XCUR' : 0.0,
-       '25d!XSTEP' : 0.0,
-       '26d!PITCH-MIN' : 0.0,
-       '27d!PITCH-MAX' : 0.0,
-       '28d!PITCH-CUR' : 0.0,
-       '29d!PITCH-STEP' : 0.0,
-       '30d!ROLL-MIN' : 0.0,
-       '31d!ROLL-MAX' : 0.0,
-       '32d!ROLL-CUR' : 0.0,
-       '33d!ROLL-STEP' : 0.0,
-       '34d!YAW-MIN' : 0.0,
-       '35d!YAW-MAX' : 0.0,
-       '36d!YAW-CUR' : 0.0,
-       '37d!YAW-STEP' : 0.0,
-       '38d!ZSIZE-MIN' : 0.0,
-       '39d!ZSIZE-MAX' : 0.0,
-       '40d!ZSIZE-CUR' : 1.0,
-       '41d!ZSIZE-STEP' : 0.0,
-       '42d!YSIZE-MIN' : 0.0,
-       '43d!YSIZE-MAX' : 0.0,
-       '44d!YSIZE-CUR' : 1.0,
-       '45d!YSIZE-STEP' : 0.0,
-       '46d!XSIZE-MIN' : 0.0,
-       '47d!XSIZE-MAX' : 0.0,
-       '48d!XSIZE-CUR' : 1.0,
-       '49d!XSIZE-STEP' : 0.0,
-       '50I!FLAG' : 1897582,
-       '51i!reserved2' : 0
-}
-
-FLTDOFDisplay = [4]
-
-FLTImage = {
-       '3i!RealU Direction' : 0, 
-       '4i!RealV Direction' : 0, 
-       '5i!UpX' : 0, 
-       '6i!UpY' : 0, 
-       '7i!File Format' : 0, 
-       '8i!Min Filter' : 6, 
-       '9i!Mag Filter' : 1, 
-       '10i!Wrap' : 0, 
-       '11i!WrapU' : 0, 
-       '12i!WrapV' : 0, 
-       '13i!Modified' : 0,
-       '14i!PivotX' : 0, 
-       '15i!PivotY' : 0, 
-       '16i!Enviorment' : 0, 
-       '17i!WhiteAlpha' : 0, 
-       '18i!reserved1' : 0,
-       '19i!reserved2' : 0,
-       '20i!reserved3' : 0,
-       '21i!reserved4' : 0,
-       '22i!reserved5' : 0,
-       '23i!reserved6' : 0,
-       '24i!reserved7' : 0,
-       '25i!reserved8' : 0,
-       '26i!reserved9' : 0,
-       '27d!RealU Direction' : 0, 
-       '28d!RealV Direction' : 0, 
-       '29i!Origin' : 0, 
-       '30i!Kernel no.' : 0, 
-       '31i!Internal Format' : 0, 
-       '32i!External Format' : 0, 
-       '33i!MipMap Filter?' : 0, 
-       '34f!MMF1' : 0.0, 
-       '35f!MMF2' : 0.0, 
-       '36f!MMF3' : 0.0, 
-       '37f!MMF4' : 0.0, 
-       '38f!MMF5' : 0.0, 
-       '39f!MMF6' : 0.0, 
-       '40f!MMF7' : 0.0, 
-       '41f!MMF8' : 0.0, 
-       '42i!Tex CPs?' : 0, 
-       '43f!LOD0 CP' : 0.0, 
-       '44f!Scale0 CP' : 0.0, 
-       '45f!LOD1 CP' : 0.0, 
-       '46f!Scale1 CP' : 0.0, 
-       '47f!LOD2 CP' : 0.0, 
-       '48f!Scale2 CP' : 0.0, 
-       '49f!LOD3 CP' : 0.0, 
-       '50f!Scale3 CP' : 0.0, 
-       '51f!LOD4 CP' : 0.0, 
-       '52f!Scale4 CP' : 0.0, 
-       '53f!LOD5 CP' : 0.0, 
-       '54f!Scale5 CP' : 0.0, 
-       '55f!LOD6 CP' : 0.0, 
-       '56f!Scale6 CP' : 0.0, 
-       '57f!LOD7 CP' : 0.0, 
-       '58f!Scale7 CP' : 0.0, 
-       '59f!Control Clamp' : 0.0, 
-       '60i!Mag Alpha Filter' : 0, 
-       '61i!Mag Color Filter' : 0, 
-       '62f!reserved10' : 0,
-       '63f!reserved11' : 0,
-       '64f!reserved12' : 0,
-       '65f!reserved13' : 0,
-       '66f!reserved14' : 0,
-       '67f!reserved15' : 0,
-       '68f!reserved16' : 0,
-       '69f!reserved17' : 0,
-       '70f!reserved18' : 0,
-       '71d!Lambert Central' : 0.0, 
-       '72d!Lambert Upper' : 0.0, 
-       '73d!Lambert Lower' : 0.0, 
-       '74d!reserved19' : 0,
-       '75f!reserved20' : 0,
-       '76f!reserved21' : 0,
-       '77f!reserved22' : 0,
-       '78f!reserved23' : 0,
-       '79f!reserved24' : 0,
-       '80i!Tex Detail?' : 0, 
-       '81i!Tex J' : 0, 
-       '82i!Tex K' : 0, 
-       '83i!Tex M' : 0, 
-       '84i!Tex N' : 0, 
-       '85i!Tex Scramble' : 0, 
-       '86i!Tex Tile?' : 0, 
-       '87f!Tex Tile LLU' : 0.0, 
-       '88f!Tex Tile LLV' : 0.0, 
-       '89f!Tex Tile URU' : 0.0,
-       '90f!Tex Tile URV' : 0.0, 
-       '91i!Projection' : 0, 
-       '92i!Earth Model' : 0, 
-       '93i!reserved25' : 0,
-       '94i!UTM Zone' : 0, 
-       '95i!Image Origin' : 0,
-       '96i!GPU' : 0, 
-       '97i!reserved26' : 0,
-       '98i!reserved27' : 0,
-       '99i!GPU Hemi' : 0, 
-       '100i!reserved41' : 0,
-       '101i!reserved42' : 0,
-       '102i!reserved43' : 0,
-       '103i!Cubemap' : 0, 
-       '104t588!reserved44' : '',
-       '105t512!Comments' : '', 
-       '106i!reserved28' : 0,
-       '107i!reserved29' : 0,
-       '108i!reserved30' : 0,
-       '109i!reserved31' : 0,
-       '110i!reserved32' : 0,
-       '111i!reserved33' : 0,
-       '112i!reserved34' : 0,
-       '113i!reserved35' : 0,
-       '114i!reserved36' : 0,
-       '115i!reserved37' : 0,
-       '116i!reserved38' : 0,
-       '117i!reserved39' : 0,
-       '118i!reserved40' : 0,
-       '119i!reserved45' : 0,
-       '120i!Format Version' : 0, 
-       '121i!GPU num' : 0,
-}
-
-FLTImageDisplay = [18,19,29,21,22,23,24,25,26,62,63,64,65,66,67,68,69,70,74,75,76,77,78,79,93,97,98,102,114]
-
-FLTHeader = {
-       '3t8!id' : 'db',
-       '4i!version' : 1620,
-       '5i!editversion' : 0,
-       '6t32!date' : 0,
-       '7s!NGID' : 0,
-       '8s!NLID' : 0,
-       '9s!NOID' : 0,
-       '10s!NFID' : 0,
-       '11s!UMULT' : 1,
-       '12c!units' : 0,
-       '13c!set white' : 0,
-       '14I!flags' : 0x80000000,
-       '15i!reserved1' : 0,
-       '16i!reserved2' : 0,
-       '17i!reserved3' : 0,
-       '18i!reserved4' : 0,
-       '19i!reserved5' : 0,
-       '20i!reserved6' : 0,
-       '21i!projection type' : 0,
-       '22i!reserved7' : 0,
-       '23i!reserved8' : 0,
-       '24i!reserved9' : 0,
-       '25i!reserved10' : 0,
-       '26i!reserved11' : 0,
-       '27i!reserved12' : 0,
-       '28i!reserved13' : 0,
-       '29s!NDID' : 0,
-       '30s!vstore' : 1,
-       '31i!origin' : 0,
-       '32d!sw x' : 0,
-       '33d!sw y' : 0,
-       '34d!dx' : 0,
-       '35d!dy' : 0,
-       '36s!NSID' : 0,
-       '37s!NPID' : 0,
-       '38i!reserved14' : 0,
-       '39i!reserved15' : 0,
-       '40s!NCID' : 0,
-       '41s!NTID' : 0,
-       '42s!NBID' : 0,
-       '43s!NWID' : 0,
-       '44i!reserved14' : 0,
-       '45d!sw lat' : 0,
-       '46d!sw lon' : 0,
-       '47d!ne lat' : 0,
-       '48d!ne lon' : 0,
-       '49d!origin lat' : 0,
-       '50d!origin lon' : 0,
-       '51d!lambert lat1' : 0,
-       '52d!lambert lat2' : 0,
-       '53s!NLSID' : 0,
-       '54s!NLPID' : 0,
-       '55s!NRID' : 0,
-       '56s!NCATID' : 0,
-       '57s!reserved15' : 0,
-       '58s!reserved16' : 0,
-       '59s!reserved17' : 0,
-       '60s!reserved18' : 0,
-       '61i!ellipsoid model' : 1,
-       '62s!NAID' : 0,
-       '63s!NCVID' : 0,
-       '64s!utm zone' : 0,
-       '65t6!reserved19' : 0,
-       '66d!dz' : 0,
-       '67d!radius' : 0,
-       '68S!NMID' : 0,
-       '69S!NLPSID' : 0,
-       '70i!reserved20' : 0,
-       '71d!major axis' : 0,
-       '72d!minor axis' : 0,
-}
-
-FLT_Records = {
-               2 : FLTGroup,
-               4 : FLTObject,
-               73 : FLTLOD,
-               63 : FLTXRef,
-               14 : FLTDOF,
-               1 : FLTHeader,
-               111 : FLTInlineLP,
-               100 : FLTExt,
-               'Image' : FLTImage
-}
-
-def process_recordDefs(): 
-       records = dict()
-       for record in FLT_Records:
-               props = dict()
-               for prop in FLT_Records[record]:
-                       position = ''
-                       slice = 0
-                       (format,name) = prop.split('!')
-                       for i in format:
-                               if i not in typecodes:
-                                       position = position + i
-                                       slice = slice + 1
-                               else:
-                                       break
-                       type = format[slice:]
-                       length = type[1:] 
-                       if len(length) == 0:
-                               length = 1
-                       else:
-                               type = type[0]
-                               length = int(length)
-                       
-                       props[int(position)] = (type,length,prop)
-               records[record] = props
-       return records
-
-
diff --git a/release/scripts/flt_toolbar.py b/release/scripts/flt_toolbar.py
deleted file mode 100644 (file)
index a707b87..0000000
+++ /dev/null
@@ -1,809 +0,0 @@
-#!BPY
-
-"""
-Name: 'FLT Toolbar'
-Blender: 240
-Group: 'Misc'
-Tooltip: 'Tools for working with FLT databases'
-"""
-
-__author__ = "Geoffrey Bantle"
-__version__ = "1.0 11/21/07"
-__email__ = ('scripts', 'Author, ')
-__url__ = ('blender', 'blenderartists.org')
-
-__bpydoc__ ="""\
-This script provides tools for working with OpenFlight databases in Blender. OpenFlight is a
-registered trademark of MultiGen-Paradigm, Inc.
-
-Feature overview and more availible at:
-http://wiki.blender.org/index.php/Scripts/Manual/FLTools
-"""
-
-# --------------------------------------------------------------------------
-# flt_palettemanager.py version 0.1 2005/04/08
-# --------------------------------------------------------------------------
-# ***** BEGIN GPL LICENSE BLOCK *****
-#
-# Copyright (C) 2007: Blender Foundation
-#
-# 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.
-#
-# ***** END GPL LICENCE BLOCK *****
-# --------------------------------------------------------------------------
-
-import Blender.Draw as Draw
-from Blender.BGL import *
-import Blender
-import flt_properties
-reload(flt_properties)
-from flt_properties import *
-
-xrefprefix = ""
-xrefstack = list()
-vofsstack = list()
-vquatstack = list()
-prop_w = 256
-prop_h = 256
-
-
-#event codes
-evcode = {
-       "XREF_MAKE" : 100,
-       "XREF_EDIT" : 101,
-       "XREF_FILE" : 102,
-       "XREF_PICK" : 103,
-       "XREF_SELECT" : 104,
-        "XREF_POP" : 105,
-        "XREF_PREFIX" : 106,
-       "FACE_NAME" : 200,
-       "FACE_MAKESUB" : 201,
-       "FACE_KILLSUB" : 202,
-       "FACE_SELSUB" : 203,
-       "SCENE_UPDATE" : 303,
-       "IDPROP_COPY" : 501,
-       "IDPROP_KILL" : 502,
-       "CLIGHT_MAKE" : 700,
-       "DFROMACT" : 701,
-       "FIXCOL" : 702
-}
-
-XREF_PREFIX = None
-XREF_MAKE = None
-XREF_EDIT = None
-XREF_SELECT = None
-XREF_POP = None
-FACE_MAKESUB = None
-FACE_SELSUB = None
-FACE_KILLSUB = None
-IDPROP_KILL = None
-IDPROP_COPY = None
-SCENE_UPDATE = None
-CLIGHT_MAKE = None
-DFROMACT = None
-FIXCOL = None
-
-
-def RGBtoHSV( r, g, b):
-       cmin = min( r, g, b )
-       cmax = max( r, g, b )
-       v = cmax                                
-
-       if(cmax!=0.0):
-               s = (cmax-cmin)/cmax
-       else:
-               s = 0.0
-               h = 0.0
-       
-       if(s == 0.0):
-               h = -1.0
-       else:
-               cdelta = cmax-cmin
-               rc = (cmax-r)/cdelta
-               gc = (cmax-g)/cdelta
-               bc = (cmax-b)/cdelta
-               if(r==cmax):
-                       h = bc-gc
-               else:
-                       if(g==cmax):
-                               h = 2.0+rc-bc
-                       else:
-                               h = 4.0+gc-rc
-               h = h*60.0
-               if(h<0.0):
-                       h += 360.0
-                       
-               
-       h = h/360.0
-       if(h < 0.0): 
-               h = 0.0
-       return (h,s,v)
-
-
-def update_state():
-       state = dict()
-       state["activeScene"] = Blender.Scene.GetCurrent()
-       state["activeObject"] = state["activeScene"].objects.active
-       if state["activeObject"] and not state["activeObject"].sel:
-               state["activeObject"] = None
-       state["activeMesh"] = None
-       if state["activeObject"] and state["activeObject"].type == 'Mesh':
-               state["activeMesh"] = state["activeObject"].getData(mesh=True)
-       
-       state["activeFace"] = None
-       if state["activeMesh"]:
-               if state["activeMesh"].faceUV and state["activeMesh"].activeFace != None:
-                       state["activeFace"] = state["activeMesh"].faces[state["activeMesh"].activeFace]
-               
-       #update editmode
-       state["editmode"]       = Blender.Window.EditMode()
-
-       return state
-def pack_face_index(index, intensity):
-       return ((127*intensity)+(128*index))
-def unpack_face_index(face_index):
-       index = face_index / 128
-       intensity = float(face_index - 128.0 * index) / 127.0
-       return(index,intensity)
-       
-def idprops_append(object, typecode, props):
-       object.properties["FLT"] = dict()
-       object.properties["FLT"]['type'] = typecode 
-       for prop in props:
-               object.properties["FLT"][prop] = props[prop]
-       object.properties["FLT"]['3t8!id'] = object.name
-
-def idprops_kill(object):
-       state = update_state()
-       if object and object.properties.has_key('FLT'):
-               object.properties.pop('FLT')
-
-def idprops_copy(source):
-       state = update_state()
-       if source.properties.has_key('FLT'):
-               for object in state["activeScene"].objects:
-                       if object.sel and object != source and (state["activeScene"].Layers & object.Layers):
-                               idprops_kill(object)
-                               object.properties['FLT'] = dict()
-                               for key in source.properties['FLT']:
-                                       object.properties['FLT'][key] = source.properties['FLT'][key]
-
-def unpack_color(color):
-       return struct.unpack('>BBBB',struct.pack('>I',color))
-
-
-def findColorKey(colordict, hsv):
-       hdelta = 0.001
-       for key in colordict:
-               if not (((hsv[0] < (key[0] + hdelta)) and (hsv[0] > (key[0] - hdelta))) and ((hsv[1] < (key[1] + hdelta)) and (hsv[1] > (key[1] - hdelta)))):
-                       return key
-       return None
-
-def hsvsort(a, b):
-       (index1, mag1) = a
-       (index2, mag2) = b
-       if mag1 > mag2:
-               return 1
-       elif mag1 < mag2:
-               return -1
-       return 0
-
-def fix_colors():
-       
-       editmode = 0
-       if Blender.Window.EditMode():
-               Blender.Window.EditMode(0)
-               editmode = 1
-       state = update_state()
-       
-       scene = state["activeScene"]
-       colors = None
-       if state["activeScene"].properties.has_key('FLT'):
-               try:
-                       colors = state["activeScene"].properties['FLT']['Color Palette']
-               except:
-                       pass
-       if not colors:
-               return
-       
-       #first build a HSV version of our palette
-       hsvpalette = list()
-       for swatch in colors:
-               color = unpack_color(swatch)
-               hsv = RGBtoHSV(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0)
-               hsvpalette.append(hsv)
-               
-       #collect all of our meshes
-       meshes = list()
-       for object in scene.objects.context:
-               if object.sel and object.type == 'Mesh':
-                       mesh = object.getData(mesh=True)
-                       if "FLT_COL" in mesh.faces.properties:
-                               meshes.append(mesh)
-                               
-                               
-       #Now go through our meshes, and build a dictionary of face lists keyed according to (hue,saturation) of the baked color
-       colordict = dict()
-       for mesh in meshes:
-               for face in mesh.faces:
-                       hsv = RGBtoHSV(face.col[0].r/255.0, face.col[0].g/255.0, face.col[0].b/255.0) #retrieve baked color
-                       if colordict.has_key((hsv[0],hsv[1])):
-                               colordict[(hsv[0],hsv[1])].append(face)
-                       else:
-                               colordict[(hsv[0],hsv[1])] = [face]                             
-       
-
-       #for each color key in the color dict, build a list of distances from it to the values in hsvpalette and then quicksort them for closest match
-       for key in colordict:
-               maglist = list()
-               for i, hsv in enumerate(hsvpalette):
-                       norm = Blender.Mathutils.Vector(hsv[0], hsv[1]) - Blender.Mathutils.Vector(key[0],key[1])
-                       maglist.append((i,norm.length))
-               maglist.sort(hsvsort)
-               print maglist[0]
-               for face in colordict[key]:
-                       (index, intensity) = unpack_face_index(face.getProperty("FLT_COL"))
-                       newfindex = pack_face_index(maglist[0][0],intensity)
-                       face.setProperty("FLT_COL", int(newfindex))
-       
-       for mesh in meshes:
-               update_mesh_colors(colors,mesh) 
-       
-       if editmode:
-               Blender.Window.EditMode(1)      
-       
-
-def update_mesh_colors(colors, mesh):
-       if 'FLT_COL' in mesh.faces.properties:
-               mesh.activeColorLayer = "FLT_Fcol"
-               for face in mesh.faces:
-                       (index,intensity) = unpack_face_index(face.getProperty('FLT_COL'))
-                       color = struct.unpack('>BBBB',struct.pack('>I',colors[index]))
-                       
-                       if index == 0 and intensity == 0:
-                               color = (255,255,255)
-                               intensity  = 1.0
-                       #update the vertex colors for this face
-                       for col in face.col:
-                               col.r = int(color[0] * intensity)
-                               col.g = int(color[1] * intensity)
-                               col.b = int(color[2] * intensity)
-                               col.a = 255
-       
-               
-def update_all():
-       
-       editmode = 0
-       if Blender.Window.EditMode():
-               Blender.Window.EditMode(0)
-               editmode = 1
-       state = update_state()
-       colors = None
-       if state["activeScene"].properties.has_key('FLT'):
-               try:
-                       colors = state["activeScene"].properties['FLT']['Color Palette']
-               except:
-                       pass
-       if colors:
-               #update the baked FLT colors for all meshes.
-               for object in state["activeScene"].objects:
-                       if object.type == "Mesh":
-                               mesh = object.getData(mesh=True)
-                               update_mesh_colors(colors,mesh)
-       if editmode:
-               Blender.Window.EditMode(1)
-
-#Change this to find the deep parent
-def xref_create():
-       global xrefprefix
-       global xrefstack
-       global vofsstack
-       global vquatstack
-       global prop_w
-       global prop_h
-       
-       state = update_state()
-       
-       def findchildren(object):
-               children = list()
-               for candidate in state["activeScene"].objects:
-                       if candidate.parent == object:
-                               children.append(candidate)
-               retlist = list(children)
-               for child in children:
-                       retlist = retlist + findchildren(child)
-               return retlist
-               
-       actObject = state["activeObject"]
-        if actObject and xrefprefix:
-                scenenames = list()
-                for scene in Blender.Scene.Get():
-                        scenenames.append(scene.name)
-
-                if xrefprefix in scenenames:
-                        #build a unique name for the xref...
-                        suffix = 1
-                        found = False
-                        while not found:
-                                candidate = xrefprefix + str(suffix)
-                                if not candidate in scenenames:
-                                        xrefname = candidate
-                                        found = True
-                                suffix+=1
-                else:
-                        xrefname = xrefprefix
-                #create our XRef node
-                xnode = state["activeScene"].objects.new('Empty')
-                xnode.name = 'X:' + xrefname
-                xnode.properties['FLT'] = dict()
-                for prop in FLTXRef:
-                        xnode.properties['FLT'][prop] = FLTXRef[prop]
-                xnode.properties['FLT']['3t200!filename'] = xrefname + '.flt'
-               xnode.properties['FLT']['type'] = 63
-               xnode.enableDupGroup = True
-               xnode.DupGroup = Blender.Group.New(xrefname) #this is dangerous... be careful!
-
-                #copy rot and loc of actObject
-                xnode.setLocation(actObject.getLocation())
-                xnode.setEuler(actObject.getEuler())         
-                
-                #build the new scene
-               xrefscene = Blender.Scene.New(xrefname)
-               xrefscene.properties['FLT'] = dict()
-               xrefscene.properties['FLT']['Filename'] = xrefname
-               xrefscene.properties['FLT']['Main'] = 0
-
-                #find the children of actObject so that we can add them to the group
-               linkobjects = findchildren(actObject)
-                linkobjects.append(actObject)
-               for object in linkobjects:
-                        xrefscene.objects.link(object)
-                        state["activeScene"].objects.unlink(object)
-                        xnode.DupGroup.objects.link(object)
-                #clear rotation of actObject and location
-                actObject.setLocation(0.0,0.0,0.0)
-                actObject.setEuler(0.0,0.0,0.0)
-
-                xrefscene.update(1)
-                state["activeScene"].update(1)
-
-def xref_select():
-       state = update_state()
-       candidates = list()
-       scenelist = [scene.name for scene in Blender.Scene.Get()]
-       for object in state["activeScene"].objects:
-               if object.type == 'Empty' and object.enableDupGroup == True and object.DupGroup:
-                       candidates.append(object)
-               
-       for object in candidates:
-               if object.DupGroup.name in scenelist:
-                       object.sel = 1
-
-def xref_edit():
-       global xrefprefix
-       global xrefstack
-       global vofsstack
-       global vquatstack
-       global prop_w
-       global prop_h
-       
-       state = update_state()
-
-       actObject = state["activeObject"]
-
-       if actObject and actObject.type == 'Empty' and actObject.DupGroup:
-#              if actObject.properties.has_key('FLT') and actObject.properties['FLT']['type'] == 63:
-               for FLTscene in Blender.Scene.Get():
-                       if FLTscene.properties.has_key('FLT') and FLTscene.name == actObject.DupGroup.name:
-                               actObject.sel = 0
-                               xrefstack.append(state["activeScene"])
-                               vofsstack.append(Blender.Window.GetViewOffset())
-                               vquatstack.append(Blender.Window.GetViewQuat())
-                               FLTscene.makeCurrent()
-                               Blender.Window.SetViewOffset(0.0,0.0,0.0)
-
-def xref_finish():
-       global xrefprefix
-       global xrefstack
-       global vofsstack
-       global vquatstack
-       global prop_w
-       global prop_h
-       
-       state = update_state() 
-        if xrefstack:
-                scene = xrefstack.pop()
-                Blender.Window.SetViewQuat(vquatstack.pop())
-                Blender.Window.SetViewOffset(vofsstack.pop())
-                scene.makeCurrent()
-                
-
-def sortSub(a,b):
-       aindex = a.getProperty("FLT_ORIGINDEX")
-       bindex = b.getProperty("FLT_ORIGINDEX")
-       
-       if aindex > bindex:
-               return 1
-       elif aindex < bindex:
-               return -1
-       return 0
-
-def subface_make():
-       global xrefprefix
-       global xrefstack
-       global vofsstack
-       global vquatstack
-       global prop_w
-       global prop_h
-       
-       editmode = 0
-       if Blender.Window.EditMode():
-               Blender.Window.EditMode(0)
-               editmode = 1
-
-       state = update_state()
-       
-       actmesh = state["activeMesh"]
-       activeFace = state["activeFace"]
-       if actmesh:
-               if not "FLT_ORIGINDEX" in actmesh.faces.properties:
-                       actmesh.faces.addPropertyLayer("FLT_ORIGINDEX",Blender.Mesh.PropertyTypes["INT"])
-                       for i, face in enumerate(actmesh.faces):
-                               face.setProperty("FLT_ORIGINDEX",i)
-               if not "FLT_SFLEVEL" in actmesh.faces.properties:
-                       actmesh.faces.addPropertyLayer("FLT_SFLEVEL",Blender.Mesh.PropertyTypes["INT"])
-                       
-               #attach the subfaces to the active face. Note, this doesnt really work 100 percent properly yet, just enough for one level!
-               if activeFace:
-                       #steps:
-                       #remove actface and selected faces from the facelist
-                       #quicksort facelist
-                       #append actface and subfaces to end of facelist.
-                       #generate new indices
-                       facelist = list()
-                       sublist = list()
-                       for face in actmesh.faces:
-                               facelist.append(face)
-                       for face in facelist:   
-                               if face == activeFace:
-                                       face.setProperty("FLT_SFLEVEL",0)
-                                       sublist.insert(0,face)
-                               elif face.sel:
-                                       face.setProperty("FLT_SFLEVEL",1)
-                                       sublist.append(face)
-                       for face in sublist:
-                               facelist.remove(face)
-                       facelist.sort(sortSub)
-                       for face in sublist:
-                               facelist.append(face)
-                       for i, face in enumerate(facelist):
-                               face.setProperty("FLT_ORIGINDEX",i)
-               else:
-                       pass
-       
-       if editmode:
-               Blender.Window.EditMode(1)
-
-def subface_kill():
-       global xrefprefix
-       global xrefstack
-       global vofsstack
-       global vquatstack
-       global prop_w
-       global prop_h
-       
-       editmode = 0
-       if Blender.Window.EditMode():
-               Blender.Window.EditMode(0)
-               editmode = 1
-       state = update_state()
-       
-       actmesh = state["activeMesh"]
-       if actmesh:
-               if "FLT_ORIGINDEX" in actmesh.faces.properties and "FLT_SFLEVEL" in actmesh.faces.properties:
-                       for i,face in enumerate(actmesh.faces):
-                               face.setProperty("FLT_ORIGINDEX",i)
-                               face.setProperty("FLT_SFLEVEL",0)
-       if editmode:
-               Blender.Window.EditMode(1)
-
-def subface_select():
-       global xrefprefix
-       global xrefstack
-       global vofsstack
-       global vquatstack
-       global prop_w
-       global prop_h
-       
-       editmode = 0
-       if Blender.Window.EditMode():
-               Blender.Window.EditMode(0)
-               editmode = 1
-       state = update_state()
-       
-       actmesh = state["activeMesh"]
-       activeFace = state["activeFace"]
-       if actmesh and activeFace:
-               if "FLT_ORIGINDEX" in actmesh.faces.properties and "FLT_SFLEVEL" in actmesh.faces.properties:
-                       facelist = list()
-                       actIndex = None
-                       sublevel = None
-                       for face in actmesh.faces:
-                               facelist.append(face)
-                               facelist.sort(sortSub)
-                       for i, face in enumerate(facelist):
-                               if face == activeFace:
-                                       actIndex = i
-                                       sublevel = face.getProperty("FLT_SFLEVEL")+1
-                                       break
-                       leftover = facelist[actIndex+1:]
-                       for face in leftover:
-                               if face.getProperty("FLT_SFLEVEL") == sublevel:
-                                       face.sel = 1
-                               else:
-                                       break
-       if editmode:
-               Blender.Window.EditMode(1)
-
-def select_by_typecode(typecode):
-       global xrefprefix
-       global xrefstack
-       global vofsstack
-       global vquatstack
-       global prop_w
-       global prop_h
-       
-       state = update_state()
-       
-       for object in state["activeScene"].objects:
-               if object.properties.has_key('FLT') and object.properties['FLT']['type'] == typecode and state["activeScene"].Layers & object.Layers:
-                               object.select(1)
-def clight_make():
-       state = update_state()
-       actmesh = state["activeMesh"]
-       actobj = state["activeObject"]
-       
-       if actobj and actmesh:
-               actobj.properties['FLT'] = dict()
-               actobj.properties['FLT']['type'] = 111
-               for prop in FLTInlineLP:
-                       actobj.properties['FLT'][prop] = FLTInlineLP[prop]
-       
-               actmesh.verts.addPropertyLayer("FLT_VCOL", Blender.Mesh.PropertyTypes["INT"])
-               for v in actmesh.verts:
-                       v.setProperty("FLT_VCOL", 83815)
-                       
-def dfromact():
-       state = update_state()
-       actobj = state["activeObject"]
-       actscene = state["activeScene"]
-       dof = None
-       
-       for object in actscene.objects.context:
-               if object.sel and (object != actobj):
-                       if not dof:
-                               dof = object
-                       else:
-                               break
-       
-       if not dof:
-               return
-       
-       if 'FLT' not in dof.properties:
-               dof.properties['FLT'] = dict()  
-       
-       #Warning! assumes 1 BU == 10 meters.
-       #do origin
-       dof.properties['FLT']['5d!ORIGX'] = actobj.getLocation('worldspace')[0]*10.0
-       dof.properties['FLT']['6d!ORIGY'] = actobj.getLocation('worldspace')[1]*10.0
-       dof.properties['FLT']['7d!ORIGZ'] = actobj.getLocation('worldspace')[2]*10.0
-       #do X axis
-       x = Blender.Mathutils.Vector(1.0,0.0,0.0)
-       x = x * actobj.getMatrix('worldspace')
-       x = x * 10.0
-       dof.properties['FLT']['8d!XAXIS-X'] = x[0]
-       dof.properties['FLT']['9d!XAXIS-Y'] = x[1]
-       dof.properties['FLT']['10d!XAXIS-Z'] = x[2]
-       #do X/Y plane
-       x = Blender.Mathutils.Vector(1.0,1.0,0.0)
-       x.normalize()
-       x = x * actobj.getMatrix('worldspace')
-       x = x * 10.0
-       dof.properties['FLT']['11d!XYPLANE-X'] = x[0]
-       dof.properties['FLT']['12d!XYPLANE-Y'] = x[1]
-       dof.properties['FLT']['13d!XZPLANE-Z'] = x[2]
-       
-       
-       
-       
-       
-def event(evt,val):
-       if evt == Draw.ESCKEY:
-               Draw.Exit()
-               
-def but_event(evt):
-       global xrefprefix
-       global xrefstack
-       global vofsstack
-       global vquatstack
-       global prop_w
-       global prop_h
-       global evcode
-       
-       state = update_state()
-       
-       #do Xref buttons
-        if evt == evcode["XREF_PREFIX"]:
-                xrefprefix = XREF_PREFIX.val
-       if evt == evcode["XREF_EDIT"]:
-               xref_edit()
-       if evt == evcode["XREF_SELECT"]:
-               xref_select()
-       if evt == evcode["XREF_MAKE"]:
-               xref_create()
-       #do scene buttons                               
-       if evt == evcode["SCENE_UPDATE"]:
-               update_all()
-       #do face buttons
-       if evt == evcode["FACE_MAKESUB"]:
-               subface_make()
-       if evt== evcode["FACE_KILLSUB"]:
-               subface_kill()
-       if evt== evcode["FACE_SELSUB"]:
-               subface_select()
-       #common buttons
-       if evt == evcode["IDPROP_KILL"]:
-               if state["activeObject"]:
-                       idprops_kill(state["activeObject"])
-        if evt == evcode["IDPROP_COPY"]:
-                if state["activeObject"]:
-                        idprops_copy(state["activeObject"])
-        if evt == evcode["XREF_POP"]:
-                xref_finish()
-       if evt == evcode["CLIGHT_MAKE"]:
-               clight_make()
-       if evt == evcode["DFROMACT"]:
-               dfromact()
-       if evt == evcode["FIXCOL"]:
-               fix_colors()
-       Draw.Redraw(1)
-       Blender.Window.RedrawAll()
-
-
-def box(x,y,w,h,c,mode):
-        glColor3f(c[0],c[1],c[2])
-       if mode == "outline":
-                glBegin(GL_LINE_LOOP)
-       else:
-                glBegin(GL_POLYGON)
-       glVertex2i(x,y)
-       glVertex2i(x+w,y)
-       glVertex2i(x+w,y+h)
-       glVertex2i(x,y+h)
-       glEnd()
-
-def draw_postcommon(x,y,finaly):
-       global sheetlabel
-       global xrefprefix
-       global xrefstack
-       global vofsstack
-       global vquatstack
-       global prop_w
-       global prop_h
-       global evcode
-       
-       state = update_state()
-       
-       width = prop_w
-        height = prop_h
-        
-       #draw the header
-       glColor3f(0.15,0.15,0.15)
-       glBegin(GL_POLYGON)
-       glVertex2i(x-1,y)
-       glVertex2i(x+width+1,y)
-       glVertex2i(x+width+1,y-25)
-       glVertex2i(x-1,y-25)
-       glEnd()
-       glColor3f(1,1,1)
-       glRasterPos2i(x,y-20)
-       sheetlabel = Blender.Draw.Text("FLT Tools Panel")
-       #draw the box outline
-       glColor3f(0,0,0)
-       glBegin(GL_LINE_LOOP)
-       glVertex2i(x-1,y)
-       glVertex2i(x+1+width,y)
-       glVertex2i(x+1+width,finaly-1)
-       glVertex2i(x-1,finaly-1)
-       glEnd()
-       return finaly
-
-
-def draw_propsheet(x,y):
-       global XREF_PREFIX
-       global XREF_MAKE
-       global XREF_EDIT
-       global XREF_SELECT
-       global XREF_POP
-       global FACE_MAKESUB
-       global FACE_SELSUB
-       global FACE_KILLSUB
-       global IDPROP_KILL
-       global IDPROP_COPY
-       global SCENE_UPDATE
-       global DFROMACT
-       global FIXCOL
-               
-       global CLIGHT_MAKE
-       global xrefprefix
-       global xrefstack
-       global vofsstack
-       global vquatstack
-       global prop_w
-       global prop_h
-       global evcode
-       
-       state = update_state()
-
-       width = prop_w
-       height = prop_h
-       origx = x
-       origy = y
-       
-         #draw Xref tools
-        y = y-20
-        XREF_PREFIX = Blender.Draw.String("XRef Name:",evcode["XREF_PREFIX"],x,y,width,20,xrefprefix,18,"Xref prefix name, Actual name is generated from this")
-       y = y-20
-       XREF_MAKE = Blender.Draw.PushButton("Make XRef",evcode["XREF_MAKE"],x,y,width,20,"Make External Reference")
-        y = y-20
-       XREF_EDIT = Blender.Draw.PushButton("Edit XRef",evcode["XREF_EDIT"],x,y,width,20,"Edit External Reference")
-       y = y-20
-       XREF_SELECT = Blender.Draw.PushButton("Select XRefs",evcode["XREF_SELECT"],x,y,width,20,"Select External References")
-        y = y - 20
-        XREF_POP = Blender.Draw.PushButton("Return to previous scene",evcode["XREF_POP"],x,y,width,20,"Go up one level in xref hierarchy")
-
-        #Draw facetools
-       y = y-20
-       FACE_MAKESUB = Blender.Draw.PushButton("Make Subfaces",evcode["FACE_MAKESUB"],x,y,width,20,"Make subfaces")
-       y = y-20
-        FACE_SELSUB = Blender.Draw.PushButton("Select Subfaces",evcode["FACE_SELSUB"],x,y,width,20,"Select subfaces")
-       y = y-20
-       FACE_KILLSUB = Blender.Draw.PushButton("Kill Subfaces",evcode["FACE_KILLSUB"],x,y,width,20,"Kill subfaces")
-
-        #Draw ID Property tools
-       y = y - 20
-       IDPROP_KILL = Blender.Draw.PushButton("Delete ID props",evcode["IDPROP_KILL"],x,y,width,20,"Delete ID props")
-       y = y - 20
-       IDPROP_COPY = Blender.Draw.PushButton("Copy to selected",evcode["IDPROP_COPY"],x,y,width,20, "Copy from active to all selected")
-       
-       y= y - 20
-       CLIGHT_MAKE = Blender.Draw.PushButton("Make Light Point", evcode["CLIGHT_MAKE"],x,y,width,20,"Create inline light points from current mesh")
-        #General tools
-        y = y-20
-       SCENE_UPDATE = Blender.Draw.PushButton("Update All",evcode["SCENE_UPDATE"],x,y,width,20,"Update all vertex colors")
-       
-       y=y-20
-       DFROMACT = Blender.Draw.PushButton("Dof from Active", evcode["DFROMACT"],x,y,width,20,"Get Dof origin from active object")
-       y=y-20
-       FIXCOL = Blender.Draw.PushButton("Fix Colors", evcode["FIXCOL"],x,y,width,20,"Fix baked FLT colors of selected meshes")         
-       draw_postcommon(origx, origy,y)
-               
-def gui():
-       #draw the propsheet/toolbox.
-       psheety = 300
-       #psheetx = psheety + 10
-       draw_propsheet(0,psheety)
-Draw.Register(gui,event,but_event)
-       
\ No newline at end of file
diff --git a/release/scripts/weightpaint_invert.py b/release/scripts/weightpaint_invert.py
deleted file mode 100644 (file)
index cdae83a..0000000
+++ /dev/null
@@ -1,95 +0,0 @@
-#!BPY
-"""
-Name: 'Invert Active Group'
-Blender: 245
-Group: 'WeightPaint'
-Tooltip: 'Invert the active vertex group'
-"""
-
-# -------------------------------------------------------------------------- 
-# ***** 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. 
-# 
-# ***** END GPL LICENCE BLOCK ***** 
-# --------------------------------------------------------------------------
-import Blender
-from Blender import Scene, Mesh, Window, sys
-
-import BPyMessages
-import bpy
-
-def vgroup_invert(ob_orig, me):
-       if not me.getVertGroupNames():
-               return
-       group_act = me.activeGroup
-       if group_act == None:
-               return
-       
-       group_data = me.getVertsFromGroup(group_act, 1)
-       
-       weights= [1.0] * len(me.verts) # 1.0 - initialize inverted
-       
-       group_data = me.getVertsFromGroup(group_act, 1) # (i,w)  tuples.
-       
-       me.removeVertGroup(group_act) # messes up the active group.
-       for i,w in group_data:
-               weights[i] = 1.0-w
-       
-       me.addVertGroup(group_act)
-       
-       rep = Blender.Mesh.AssignModes.REPLACE
-       vertList= [None]
-       for i,weight in enumerate(weights):
-               vertList[0] = i
-               me.assignVertsToGroup(group_act, vertList, weight, rep)
-       
-       me.activeGroup = group_act
-       me.update()
-
-def main():
-       
-       # Gets the current scene, there can be many scenes in 1 blend file.
-       sce = bpy.data.scenes.active
-       
-       # Get the active object, there can only ever be 1
-       # and the active object is always the editmode object.
-       ob_act = sce.objects.active
-       
-       if not ob_act or ob_act.type != 'Mesh':
-               BPyMessages.Error_NoMeshActive()
-               return 
-       
-       # Saves the editmode state and go's out of 
-       # editmode if its enabled, we cant make
-       # changes to the mesh data while in editmode.
-       is_editmode = Window.EditMode()
-       Window.EditMode(0)
-       
-       Window.WaitCursor(1)
-       me = ob_act.getData(mesh=1) # old NMesh api is default
-       t = sys.time()
-       
-       # Run the mesh editing function
-       vgroup_invert(ob_act, me)
-       
-       # Timing the script is a good way to be aware on any speed hits when scripting
-       print 'Invert VGroup in %.2f seconds' % (sys.time()-t)
-       Window.WaitCursor(0)
-       if is_editmode: Window.EditMode(1)
-       
-# This lets you can import the script without running it
-if __name__ == '__main__':
-       main()
\ No newline at end of file
diff --git a/release/scripts/wizard_curve2tree.py b/release/scripts/wizard_curve2tree.py
deleted file mode 100644 (file)
index eb27f1c..0000000
+++ /dev/null
@@ -1,4034 +0,0 @@
-#!BPY
-"""
-Name: 'Tree from Curves'
-Blender: 245
-Group: 'Wizards'
-Tip: 'Generate trees from curve shapes'
-"""
-
-__author__ = "Campbell Barton"
-__url__ = ['www.blender.org', 'blenderartists.org']
-__version__ = "0.1"
-
-__bpydoc__ = """\
-
-"""
-
-# --------------------------------------------------------------------------
-# Tree from Curves v0.1 by Campbell Barton (AKA Ideasman42)
-# --------------------------------------------------------------------------
-# ***** 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.
-#
-# ***** END GPL LICENCE BLOCK *****
-# --------------------------------------------------------------------------
-
-import bpy
-import Blender
-import BPyMesh
-from Blender.Mathutils import Vector, Matrix, CrossVecs, AngleBetweenVecs, LineIntersect, TranslationMatrix, ScaleMatrix, RotationMatrix, Rand
-from Blender.Geometry import ClosestPointOnLine
-from Blender.Noise import randuvec
-
-GLOBALS = {}
-GLOBALS['non_bez_error'] = 0
-
-'''
-def debugVec(v1,v2):
-       sce = bpy.data.scenes.active
-       me = bpy.data.meshes.new()
-       me.verts.extend( [v1,v2] )
-       me.edges.extend( [(0,1)] )
-       sce.objects.new(me)
-'''
-
-def AngleBetweenVecsSafe(a1, a2):
-       try:
-               return AngleBetweenVecs(a1,a2)
-       except:
-               return 180.0
-
-# Copied from blender, we could wrap this! - BKE_curve.c
-# But probably not toooo bad in python
-def forward_diff_bezier(q0, q1, q2, q3, pointlist, steps, axis):
-       f= float(steps)
-       rt0= q0
-       rt1= 3.0*(q1-q0)/f
-       f*= f
-       rt2= 3.0*(q0-2.0*q1+q2)/f
-       f*= steps
-       rt3= (q3-q0+3.0*(q1-q2))/f
-       
-       q0= rt0
-       q1= rt1+rt2+rt3
-       q2= 2*rt2+6*rt3
-       q3= 6*rt3
-       if axis == None:
-               for a in xrange(steps+1):
-                       pointlist[a] = q0
-                       q0+= q1
-                       q1+= q2
-                       q2+= q3;
-               
-       else:
-               for a in xrange(steps+1):
-                       pointlist[a][axis] = q0
-                       q0+= q1
-                       q1+= q2
-                       q2+= q3;
-
-def points_from_bezier_seg(steps, pointlist, radlist, bez1_vec, bez2_vec, radius1, radius2):
-       
-       # x,y,z,axis
-       for ii in (0,1,2):
-               forward_diff_bezier(bez1_vec[1][ii], bez1_vec[2][ii],  bez2_vec[0][ii], bez2_vec[1][ii], pointlist, steps, ii)
-       
-       # radius - no axis, Copied from blenders BBone roll interpolation.
-       forward_diff_bezier(radius1, radius1 + 0.390464*(radius2-radius1), radius2 - 0.390464*(radius2-radius1),        radius2,        radlist, steps, None)
-
-
-def debug_pt(co):
-       Blender.Window.SetCursorPos(tuple(co))
-       Blender.Window.RedrawAll()
-       print 'debugging', co
-
-def freshMesh(mesh):
-       '''
-       Utility function to get a new mesh or clear the existing one, but dont clear everything.
-       '''
-       if mesh:
-               materials = mesh.materials
-               mesh.verts = None
-               for group in mesh.getVertGroupNames():
-                       mesh.removeVertGroup(group) 
-                       
-               # Add materials back
-               mesh.materials = materials
-       else:
-               mesh = bpy.data.meshes.new()
-               
-       return mesh
-
-def getObFromName(name):
-       if name:
-               try:    return bpy.data.objects[name]
-               except: return None
-       else:
-               return None
-
-def getGroupFromName(name):
-       if name:
-               try:    return bpy.data.groups[name]
-               except: return None
-       else:
-               return None     
-
-def closestVecIndex(vec, vecls):
-       best= -1
-       best_dist = 100000000
-       for i, vec_test in enumerate(vecls):
-               # Dont use yet, we may want to tho
-               if vec_test: # Seems odd, but use this so we can disable some verts in the list.
-                       dist = (vec-vec_test).length
-                       if dist < best_dist:
-                               best = i
-                               best_dist = dist
-       
-       return best
-
-IRATIONAL_NUM = 22.0/7.0
-def next_random_num(rnd):
-       '''
-       return a random number between 0.0 and 1.0
-       '''
-       rnd[0] += (rnd[0] * IRATIONAL_NUM) % 1
-       # prevent 
-       if rnd[0] > 1000000:
-               rnd[0]-=1000000
-       return rnd[0] % 1
-
-eul = 0.00001
-
-BRANCH_TYPE_CURVE = 0
-BRANCH_TYPE_GROWN = 1
-BRANCH_TYPE_FILL = 2
-
-class tree:
-       def __init__(self):
-               self.branches_all =             []
-               self.branches_root =    []
-               self.branches_twigs =   []
-               self.mesh = None
-               self.armature = None
-               self.objectCurve = None
-               self.objectCurveMat = None
-               self.objectCurveIMat = None
-               
-               self.objectTwigBounds = None # use for twigs only at the moment.
-               self.objectTwigBoundsIMat = None
-               self.objectTwigBoundsMat = None
-               self.objectTwigBoundsMesh = None
-               
-               self.objectLeafBounds = None
-               self.objectLeafBoundsIMat = None
-               self.objectLeafBoundsMesh = None
-               
-               self.limbScale = 1.0
-               
-               self.debug_objects = []
-               self.steps = 6 # defalt, curve overwrites
-       
-       def __repr__(self):
-               s = ''
-               s += '[Tree]'
-               s += '  limbScale: %.6f' % self.limbScale
-               s += '  object: %s' % self.objectCurve
-               
-               for brch in self.branches_root:
-                       s += str(brch)
-               return s
-       
-       def fromCurve(self, objectCurve):
-               # Now calculate the normals
-               self.objectCurve = objectCurve
-               self.objectCurveMat = objectCurve.matrixWorld
-               self.objectCurveIMat = self.objectCurveMat.copy().invert()
-               curve = objectCurve.data
-               self.steps = curve.resolu # curve resolution
-               
-               # Set the curve object scale
-               if curve.bevob:
-                       # A bit of a hack to guess the size of the curve object if you have one.
-                       bb = curve.bevob.boundingBox
-                       # self.limbScale = (bb[0] - bb[7]).length / 2.825 # THIS IS GOOD WHEN NON SUBSURRFED
-                       self.limbScale = (bb[0] - bb[7]).length / 1.8
-               elif curve.ext2 != 0.0:
-                       self.limbScale = curve.ext2 * 1.5
-                       
-               # forward_diff_bezier will fill in the blanks
-               # nice we can reuse these for every curve segment :)
-               pointlist = [[None, None, None] for i in xrange(self.steps+1)]
-               radlist = [ None for i in xrange(self.steps+1) ]
-               
-               for spline in curve:
-                       
-                       if len(spline) < 2: # Ignore single point splines
-                               continue
-                       
-                       if spline.type != 1: # 0 poly, 1 bez, 4 nurbs
-                               GLOBALS['non_bez_error'] = 1
-                               continue
-                       
-                               
-                       brch = branch()
-                       brch.type = BRANCH_TYPE_CURVE
-                       
-                       
-                       
-                       bez_list = list(spline)
-                       for i in xrange(1, len(bez_list)):
-                               bez1 = bez_list[i-1]
-                               bez2 = bez_list[i]
-                               vec1 = bez1.vec
-                               vec2 = bez2.vec
-                               if abs(vec1[1][0]-vec2[1][0]) > 0.000001 or\
-                                  abs(vec1[1][1]-vec2[1][1]) > 0.000001 or\
-                                  abs(vec1[1][2]-vec2[1][2]) > 0.000001:
-
-                                       points_from_bezier_seg(self.steps, pointlist, radlist, vec1, vec2, bez1.radius, bez2.radius)
-                               
-                                       # remove endpoint for all but the last
-                                       len_pointlist = len(pointlist)
-                                       if i != len(bez_list)-1:
-                                               len_pointlist -= 1
-                                       
-                                       brch.bpoints.extend([ bpoint(brch, Vector(pointlist[ii]), Vector(), radlist[ii] * self.limbScale) for ii in xrange(len_pointlist) ])
-                       
-                       # Finalize once point data is there
-                       if brch.bpoints:
-                               # if all points are in the same location, this is possible
-                               self.branches_all.append(brch)
-                               if brch.bpoints[0].radius < brch.bpoints[-1].radius: # This means we dont have to worry about curve direction.
-                                       brch.bpoints.reverse()
-                               brch.calcData()
-                       
-               # Sort from big to small, so big branches get priority
-               self.branches_all.sort( key = lambda brch: -brch.bpoints[0].radius )
-       
-       
-       def closestBranchPt(self, co):
-               best_brch = None
-               best_pt = None
-               best_dist = 10000000000
-               for brch in self.branches_all:
-                       for pt in brch.bpoints:
-                               # if pt.inTwigBounds: # only find twigs, give different results for leaves
-                               l = (pt.co-co).length
-                               if l < best_dist:
-                                       best_dist = l
-                                       best_brch = brch
-                                       best_pt = pt
-               return best_brch, best_pt
-       
-       def setTwigBounds(self, objectMesh):
-               self.objectTwigBounds = objectMesh
-               self.objectTwigBoundsMesh = objectMesh.getData(mesh=1)
-               self.objectTwigBoundsMat = objectMesh.matrixWorld.copy()
-               self.objectTwigBoundsIMat = self.objectTwigBoundsMat.copy().invert()
-               
-               for brch in self.branches_all:
-                       brch.calcTwigBounds(self)
-                       
-       def setLeafBounds(self, objectMesh):
-               self.objectLeafBounds = objectMesh
-               self.objectLeafBoundsMesh = objectMesh.getData(mesh=1)
-               self.objectLeafBoundsIMat = objectMesh.matrixWorld.copy().invert()
-       
-       def isPointInTwigBounds(self, co, selected_only=False):
-               return self.objectTwigBoundsMesh.pointInside(co * self.objectCurveMat * self.objectTwigBoundsIMat, selected_only)
-
-       def isPointInLeafBounds(self, co, selected_only=False):
-               return self.objectLeafBoundsMesh.pointInside(co * self.objectCurveMat * self.objectLeafBoundsIMat, selected_only)
-
-       def resetTags(self, value):
-               for brch in self.branches_all:
-                       brch.tag = value
-       
-       def buildConnections(   self,\
-                                                       sloppy = 1.0,\
-                                                       connect_base_trim = 1.0,\
-                                                       do_twigs = False,\
-                                                       twig_ratio = 2.0,\
-                                                       twig_select_mode = 0,\
-                                                       twig_select_factor = 0.5,\
-                                                       twig_scale = 0.8,\
-                                                       twig_scale_width = 1.0,\
-                                                       twig_random_orientation = 180,\
-                                                       twig_random_angle = 33,\
-                                                       twig_recursive=True,\
-                                                       twig_recursive_limit=3,\
-                                                       twig_ob_bounds=None,\
-                                                       twig_ob_bounds_prune=True,\
-                                                       twig_ob_bounds_prune_taper=1.0,\
-                                                       twig_placement_maxradius=10.0,\
-                                                       twig_placement_maxtwig=0,\
-                                                       twig_follow_parent=0.0,\
-                                                       twig_follow_x=0.0,\
-                                                       twig_follow_y=0.0,\
-                                                       twig_follow_z=0.0,\
-                                                       do_variation = 0,\
-                                                       variation_seed = 1,\
-                                                       variation_orientation = 0.0,\
-                                                       variation_scale = 0.0,\
-                                                       do_twigs_fill = 0,\
-                                                       twig_fill_levels=4,\
-                                                       twig_fill_rand_scale=0.0,\
-                                                       twig_fill_fork_angle_max=180.0,\
-                                                       twig_fill_radius_min=0.1,\
-                                                       twig_fill_radius_factor=0.75,\
-                                                       twig_fill_shape_type=0,\
-                                                       twig_fill_shape_rand=0.0,\
-                                                       twig_fill_shape_power=0.3,\
-                                               ):
-               '''
-               build tree data - fromCurve must run first
-               '''
-               
-               
-               # Sort the branchs by the first radius, so big branchs get joins first
-               ### self.branches_all.sort( key = lambda brch: brch.bpoints[0].radius )
-               
-               #self.branches_all.reverse()
-               
-               # Connect branches
-               for i in xrange(len(self.branches_all)):
-                       brch_i = self.branches_all[i]
-                       
-                       for j in xrange(len(self.branches_all)):
-                               if i != j:
-                                       # See if any of the points match this branch
-                                       # see if Branch 'i' is the child of branch 'j'
-                                       
-                                       brch_j = self.branches_all[j]
-                                       
-                                       if not brch_j.inParentChain(brch_i): # So we dont make cyclic tree!
-                                               
-                                               pt_best_j, dist = brch_j.findClosest(brch_i.bpoints[0].co)
-                                               
-                                               # Check its in range, allow for a bit out - hense the sloppy
-                                               # The second check in the following IF was added incase the point is close enough to the line but the midpoint is further away
-                                               # ...in this case the the resulting mesh will be adjusted to fit the join so its best to make it.
-                                               if      (dist <                                                                                 pt_best_j.radius * sloppy)  or \
-                                                       ((brch_i.bpoints[0].co - pt_best_j.co).length < pt_best_j.radius * sloppy):
-                                                       
-                                                       
-                                                       brch_i.parent_pt = pt_best_j
-                                                       pt_best_j.childCount += 1 # dont remove me
-                                                       
-                                                       brch_i.baseTrim(connect_base_trim)
-                                                       
-                                                       '''
-                                                       if pt_best_j.childCount>4:
-                                                               raise "ERROR"
-                                                       '''
-                                                       
-                                                       # addas a member of best_j.children later when we have the geometry info available.
-                                                       
-                                                       #### print "Found Connection!!!", i, j
-                                                       break # go onto the next branch
-               
-               """
-                       children = [brch_child for brch_child in pt.children]
-                       if children:
-                               # This pt is one side of the segment, pt.next joins this segment.
-                               # calculate the median point the 2 segments would spanal
-                               # Once this is done we need to adjust 2 things
-                               # 1) move both segments up/down so they match the branches best.
-                               # 2) set the spacing of the segments around the point.
-                               
-               
-               # First try to get the ideal some space around each joint
-               # the spacing shoule be an average of 
-               for brch.bpoints:
-               """
-               
-               '''
-               for brch in self.branches_all:
-                       brch.checkPointList()
-               '''
-               
-               # Variations - use for making multiple versions of the same tree.
-               if do_variation:
-                       irational_num = 22.0/7.0 # use to make the random number more odd
-                       rnd = [variation_seed]
-                       
-                       # Add children temporarily
-                       for brch in self.branches_all:
-                               if brch.parent_pt:
-                                       rnd_rot = ((next_random_num(rnd) * variation_orientation) - 0.5) * 720
-                                       mat_orientation = RotationMatrix(rnd_rot, 3, 'r', brch.parent_pt.no)
-                                       rnd_sca = 1 + ((next_random_num(rnd)-0.5)* variation_scale )
-                                       mat_scale = Matrix([rnd_sca,0,0],[0,rnd_sca,0],[0,0,rnd_sca])
-                                       # mat_orientation = RotationMatrix(0, 3, 'r', brch.parent_pt.no)
-                                       brch.transformRecursive(self, mat_scale * mat_orientation, brch.parent_pt.co)
-               
-               if (do_twigs or do_twigs_fill) and twig_ob_bounds: # Only spawn twigs inside this mesh
-                       self.setTwigBounds(twig_ob_bounds)
-               
-               # Important we so this with existing parent/child but before connecting and calculating verts.
-               if do_twigs:
-                       
-                       # scale values down
-                       twig_random_orientation= twig_random_orientation/360.0
-                       twig_random_angle= twig_random_angle/360.0
-                       
-                       irational_num = 22.0/7.0 # use to make the random number more odd
-                       
-                       if not twig_recursive:
-                               twig_recursive_limit = 0
-                       
-                       self.buildTwigs(twig_ratio, twig_select_mode, twig_select_factor)
-                       
-                       branches_twig_attached = []
-                       
-                       # This wont add all! :/
-                       brch_twig_index = 0
-                       brch_twig_index_LAST = -1 # use this to prevent in inf loop, since its possible we cant place every branch
-                       while brch_twig_index < len(self.branches_twigs) and brch_twig_index_LAST != brch_twig_index:
-                               ###print "While"
-                               ### print brch_twig_index, len(self.branches_twigs) # if this dosnt change, quit the while
-                               
-                               brch_twig_index_LAST = brch_twig_index
-                               
-                               # new twigs have been added, recalculate
-                               branches_twig_sort = [brch.bestTwigSegment() for brch in self.branches_all]
-                               branches_twig_sort.sort() # this will sort the branches with best braches for adding twigs to at the start of the list
-                               
-                               for tmp_sortval, twig_pt_index, brch_parent in branches_twig_sort: # tmp_sortval is not used.
-                                       if              twig_pt_index != -1 and \
-                                                       (twig_recursive_limit == 0 or brch_parent.generation < twig_recursive_limit) and \
-                                                       (twig_placement_maxtwig == 0 or brch_parent.twig_count < twig_placement_maxtwig) and \
-                                                       brch_parent.bpoints[twig_pt_index].radius < twig_placement_maxradius:
-                                               
-                                               if brch_twig_index >= len(self.branches_twigs):
-                                                       break
-                                               
-                                               brch_twig = self.branches_twigs[brch_twig_index]
-                                               parent_pt = brch_parent.bpoints[twig_pt_index]
-                                               
-                                               brch_twig.parent_pt = parent_pt
-                                               parent_pt.childCount += 1
-                                               
-                                               # Scale this twig using this way...
-                                               # The size of the parent, scaled by the parent point's radius,
-                                               # ...compared to the parent branch;s root point radius.
-                                               # Also take into account the length of the parent branch
-                                               # Use this for pretend random numbers too.
-                                               scale = twig_scale * (parent_pt.branch.bpoints[0].radius / brch_twig.bpoints[0].radius) * (parent_pt.radius / parent_pt.branch.bpoints[0].radius)
-                                               
-                                               # Random orientation
-                                               # THIS IS NOT RANDOM - Dont be real random so we can always get re-produceale results.
-                                               if twig_random_orientation:     rnd1 = (((irational_num * scale * 10000000) % 360) - 180) * twig_random_orientation
-                                               else:                                           rnd1 = 0.0
-                                               if twig_random_angle:           rnd2 = (((irational_num * scale * 66666666) % 360) - 180) * twig_random_angle
-                                               else:                                           rnd2 = 0.0
-                                               
-                                               # Align this with the existing branch
-                                               angle = AngleBetweenVecsSafe(zup, parent_pt.no)
-                                               cross = CrossVecs(zup, parent_pt.no)
-                                               mat_align = RotationMatrix(angle, 3, 'r', cross)
-                                               
-                                               # Use the bend on the point to work out which way to make the branch point!
-                                               if parent_pt.prev:      cross = CrossVecs(parent_pt.no, parent_pt.prev.no - parent_pt.no)
-                                               else:                           cross = CrossVecs(parent_pt.no, parent_pt.next.no - parent_pt.no)
-                                               
-                                               if parent_pt.branch.parent_pt:
-                                                       angle = AngleBetweenVecsSafe(parent_pt.branch.parent_pt.no, parent_pt.no)
-                                               else:
-                                                       # Should add a UI for this... only happens when twigs come off a root branch
-                                                       angle = 66
-                                               
-                                               mat_branch_angle = RotationMatrix(angle+rnd1, 3, 'r', cross)
-                                               mat_scale = Matrix([scale,0,0],[0,scale,0],[0,0,scale])
-                                               
-                                               mat_orientation = RotationMatrix(rnd2, 3, 'r', parent_pt.no)
-                                               
-                                               if twig_scale_width != 1.0:
-                                                       # adjust length - no radius adjusting
-                                                       for pt in brch_twig.bpoints:
-                                                               pt.radius *= twig_scale_width
-                                               
-                                               brch_twig.transform(mat_scale * mat_branch_angle * mat_align * mat_orientation, parent_pt.co)
-                                               
-                                               # Follow the parent normal
-                                               if twig_follow_parent or twig_follow_x or twig_follow_y or twig_follow_z:
-                                                       
-                                                       vecs = []
-                                                       brch_twig_len = float(len(brch_twig.bpoints))
-                                                       
-                                                       if twig_follow_parent:
-                                                               no = parent_pt.no.copy() * twig_follow_parent
-                                                       else:
-                                                               no = Vector()
-                                                       
-                                                       no.x += twig_follow_x
-                                                       no.y += twig_follow_y
-                                                       no.z += twig_follow_z
-                                                       
-                                                       for i, pt in enumerate(brch_twig.bpoints):
-                                                               if pt.prev:
-                                                                       fac = i / brch_twig_len
-                                                                       
-                                                                       # Scale this value
-                                                                       fac_inv = 1-fac
-                                                                       
-                                                                       no_orig = pt.co - pt.prev.co
-                                                                       len_orig = no_orig.length
-                                                                       
-                                                                       no_new = (fac_inv * no_orig) + (fac * no)
-                                                                       no_new.length = len_orig
-                                                                       
-                                                                       # Mix the 2 normals
-                                                                       vecs.append(no_new)
-                                                                       
-                                                       # Apply the coords
-                                                       for i, pt in enumerate(brch_twig.bpoints):
-                                                               if pt.prev:
-                                                                       pt.co = pt.prev.co + vecs[i-1]
-                                                       
-                                                       brch_twig.calcPointExtras()
-                                               
-                                               
-                                               # When using a bounding mesh, clip and calculate points in bounds.
-                                               #print "Attempting to trim base"
-                                               brch_twig.baseTrim(connect_base_trim)
-                                               
-                                               if twig_ob_bounds and (twig_ob_bounds_prune or twig_recursive):
-                                                       brch_twig.calcTwigBounds(self)
-                                               
-                                                       # we would not have been but here if the bounds were outside
-                                                       if twig_ob_bounds_prune:
-                                                               brch_twig.boundsTrim()
-                                                               if twig_ob_bounds_prune_taper != 1.0:
-                                                                       # taper to a point. we could use some nice taper algo here - just linear atm.
-                                                                       
-                                                                       brch_twig.taper(twig_ob_bounds_prune_taper)
-                                               
-                                               # Make sure this dosnt mess up anything else
-                                               
-                                               brch_twig_index += 1
-                                               
-                                               # Add to the branches
-                                               #self.branches_all.append(brch_twig)
-                                               if len(brch_twig.bpoints) > 2:
-                                                       branches_twig_attached.append(brch_twig)
-                                                       brch_twig.generation = brch_parent.generation + 1
-                                                       brch_parent.twig_count += 1
-                                               else:
-                                                       # Dont add the branch
-                                                       parent_pt.childCount -= 1
-                               
-                               # Watch This! - move 1 tab down for no recursive twigs
-                               if twig_recursive:
-                                       self.branches_all.extend(branches_twig_attached)
-                                       branches_twig_attached = []
-                       
-                       if not twig_recursive:
-                               self.branches_all.extend(branches_twig_attached)
-                               branches_twig_attached = []
-               
-               
-               if do_twigs_fill and twig_ob_bounds:
-                       self.twigFill(\
-                               twig_fill_levels,\
-                               twig_fill_rand_scale,\
-                               twig_fill_fork_angle_max,\
-                               twig_fill_radius_min,\
-                               twig_fill_radius_factor,\
-                               twig_fill_shape_type,\
-                               twig_fill_shape_rand,\
-                               twig_fill_shape_power,\
-                       )
-               
-               ### self.branches_all.sort( key = lambda brch: brch.parent_pt != None )
-               
-               # Calc points with dependancies
-               # detect circular loops!!! - TODO
-               #### self.resetTags(False) # NOT NEEDED NOW
-               done_nothing = False
-               while done_nothing == False:
-                       done_nothing = True
-                       
-                       for brch in self.branches_all:
-                               
-                               if brch.tag == False and (brch.parent_pt == None or brch.parent_pt.branch.tag == True):
-                                       # Assign this to a spesific side of the parents point
-                                       # we know this is a child but not which side it should be attached to.
-                                       if brch.parent_pt:
-                                               
-                                               child_locs = [\
-                                               brch.parent_pt.childPointUnused(0),\
-                                               brch.parent_pt.childPointUnused(1),\
-                                               brch.parent_pt.childPointUnused(2),\
-                                               brch.parent_pt.childPointUnused(3)]
-                                               
-                                               best_idx = closestVecIndex(brch.bpoints[0].co, child_locs)
-                                               
-                                               # best_idx could be -1 if all childPoint's are used however we check for this and dont allow it to happen.
-                                               #if best_idx==-1:
-                                               #       raise "Error"z
-                                               brch.parent_pt.children[best_idx] = brch
-                                       
-                                       for pt in brch.bpoints:
-                                               pt.calcVerts()
-                                       
-                                       done_nothing = False
-                                       brch.tag = True
-               
-               '''
-               for i in xrange(len(self.branches_all)):
-                       brch_i = self.branches_all[i]
-                       print brch_i.myindex,
-                       print 'tag', brch_i.tag,
-                       print 'parent is',
-                       if brch_i.parent_pt:
-                               print brch_i.parent_pt.branch.myindex
-                       else:
-                               print None
-               '''
-       
-       def optimizeSpacing(self, seg_density=0.5, seg_density_angle=20.0, seg_density_radius=0.3, joint_compression=1.0, joint_smooth=1.0):
-               '''
-               Optimize spacing, taking branch hierarchy children into account,
-               can add or subdivide segments so branch joins dont look horrible.
-               '''
-               for brch in self.branches_all:
-                       brch.evenJointDistrobution(joint_compression)
-               
-               # Correct points that were messed up from sliding
-               # This happens when one point is pushed past another and the branch gets an overlaping line
-               
-               for brch in self.branches_all:
-                       brch.fixOverlapError(joint_smooth)
-               
-               
-               # Collapsing
-               for brch in self.branches_all:
-                       brch.collapsePoints(seg_density, seg_density_angle, seg_density_radius, joint_smooth)
-                       
-               '''
-               for brch in self.branches_all:
-                       brch.branchReJoin()
-               '''
-       
-       def twigFill(self_tree,\
-                       twig_fill_levels,\
-                       twig_fill_rand_scale,\
-                       twig_fill_fork_angle_max,\
-                       twig_fill_radius_min,\
-                       twig_fill_radius_factor,\
-                       twig_fill_shape_type,\
-                       twig_fill_shape_rand,\
-                       twig_fill_shape_power,\
-               ):
-               '''
-               Fill with twigs, this function uses its own class 'segment'
-               
-               twig_fill_shape_type;
-                       0 - no child smoothing
-                       1 - smooth one child
-                       2 - smooth both children
-               
-               '''
-               
-               rnd = [1]
-               
-               segments_all = []
-               segments_level = []
-               
-               # Only for testing
-               def preview_curve():
-                       TWIG_WIDTH_MAX = 1.0
-                       TWIG_WIDTH_MIN = 0.1
-                       cu = bpy.data.curves["cu"]
-                       # remove all curves
-                       while len(cu):
-                               del cu[0]
-                       # return
-                       
-                       cu.setFlag(1)
-                       cu.ext2 = 0.01
-                       
-                       WIDTH_STEP = (TWIG_WIDTH_MAX-TWIG_WIDTH_MIN) / twig_fill_levels
-                       
-                       for i, seg in enumerate(segments_all):
-                               
-                               # 1 is the base and 2 is the tail
-                               
-                               p1_h2 = seg.getHeadHandle() # isnt used
-                               p1_co = seg.headCo
-                               p1_h1 = seg.getHeadHandle()
-                               
-                               p2_h1 = seg.getTailHandle()
-                               
-                               p2_co = seg.tailCo
-                               p2_h2 = seg.tailCo # isnt used
-                               
-                               bez1 = Blender.BezTriple.New([ p1_h1[0], p1_h1[1], p1_h1[2], p1_co[0], p1_co[1], p1_co[2], p1_h2[0], p1_h2[1], p1_h2[2] ])
-                               bez2 = Blender.BezTriple.New([ p2_h1[0], p2_h1[1], p2_h1[2], p2_co[0], p2_co[1], p2_co[2], p2_h2[0], p2_h2[1], p2_h2[2] ])
-                               bez1.handleTypes = bez2.handleTypes = [Blender.BezTriple.HandleTypes.FREE, Blender.BezTriple.HandleTypes.FREE]
-                               
-                               bez1.radius = TWIG_WIDTH_MIN + (WIDTH_STEP * (seg.levelFromLeaf+1))
-                               bez2.radius = TWIG_WIDTH_MIN + (WIDTH_STEP * seg.levelFromLeaf)
-                               
-                               cunurb = cu.appendNurb(bez1)
-                               cunurb.append(bez2)
-                               
-                               # This sucks
-                               for bez in cunurb:
-                                       bez.handleTypes = [Blender.BezTriple.HandleTypes.FREE, Blender.BezTriple.HandleTypes.FREE]
-                       
-                       ### cc = sce.objects.new( cu )
-                       cu.update()
-               
-               
-               def mergeCo(parentCo, ch1Co, ch2Co, twig_fill_shape_rand):
-                       if twig_fill_shape_rand==0.0:
-                               return (parentCo + ch1Co + ch2Co) / 3.0
-                       else:
-                               
-                               w1 = (next_random_num(rnd)*twig_fill_shape_rand) + (1-twig_fill_shape_rand)
-                               w2 = (next_random_num(rnd)*twig_fill_shape_rand) + (1-twig_fill_shape_rand)
-                               w3 = (next_random_num(rnd)*twig_fill_shape_rand) + (1-twig_fill_shape_rand)
-                               wtot = w1+w2+w3
-                               w1=w1/wtot
-                               w2=w2/wtot
-                               w3=w3/wtot
-                               
-                               # return (parentCo*w1 + ch1Co*w2 + ch2Co*w2)
-                               co1 = (parentCo * w1)   + (ch1Co * (1.0-w1))
-                               co2 = (ch1Co * w2)              + (ch2Co * (1.0-w2))
-                               co3 = (ch2Co * w3)              + (parentCo * (1.0-w3))
-                               
-                               return (co1 + co2 + co3) / 3.0
-                               
-                               
-               
-               class segment:
-                       def __init__(self, level):
-                               self.headCo = Vector()
-                               self.tailCo = Vector()
-                               self.parent = None
-                               self.mergeCount = 0
-                               self.levelFromLeaf = level # how far we are from the leaf in levels
-                               self.levelFromRoot = -1 # set later, assume root bone
-                               self.children = []
-                               segments_all.append(self)
-                               
-                               if level >= len(segments_level):        segments_level.append([self])
-                               else:                                                           segments_level[level].append(self)
-                               
-                               self.brothers = []
-                               self.no = Vector() # only endpoints have these
-                               # self.id = len(segments_all)
-                               
-                               # First value is the bpoint,
-                               # Second value is what to do -
-                               #  0 - dont join
-                               #  1 - Join to parent (tree point)
-                               #  2 - join to parent, point from another fill-twig branch we just created.
-                               
-                               self.bpt = (None, False) # branch point for root segs only
-                               self.new_bpt = None
-                               
-                               self.used = False # use this to tell if we are apart of a branch
-                       
-                       def sibling(self):
-                               i = self.parent.children.index(self)
-                               
-                               if i == 0:
-                                       return self.parent.children[ 1 ]
-                               elif i == 1:
-                                       return self.parent.children[ 0 ]
-                               else:
-                                       raise "error"
-                                       
-                       
-                       def getHeadHandle(self):
-                               """
-                               For Bezier only
-                               """
-                               
-                               if not self.parent:
-                                       return self.headCo
-                               
-                               if twig_fill_shape_type == 0: # no smoothing
-                                       return self.headCo
-                               elif twig_fill_shape_type == 1:
-                                       if self.parent.children[1] == self:
-                                               return self.headCo
-                               # 2 - always do both
-                               
-                               
-                               # Y shape with curve? optional
-                               
-                               # we have a parent but it has no handle direction, easier
-                               if not self.parent.parent:      no = self.parent.headCo - self.parent.tailCo
-                               else:                                           no = self.parent.parent.headCo-self.parent.tailCo
-                               
-                               no.length =  self.getLength() * twig_fill_shape_power
-                               # Ok we have to account for the parents handle
-                               return self.headCo - no
-                               # return self.headCo - Vector(1, 0,0)
-                       
-                       def getTailHandle(self):
-                               """
-                               For Bezier only
-                               """
-                               if self.parent:
-                                       no = self.parent.headCo-self.tailCo
-                                       no.length = self.getLength() * twig_fill_shape_power
-                                       return self.tailCo + no
-                               else:
-                                       return self.tailCo # isnt used
-                       
-                       def getRootSeg(self):
-                               seg = self
-                               while seg.parent:
-                                       seg = seg.parent
-                               
-                               return seg
-                       
-                       def calcBrothers(self):
-                               # Run on children first
-                               self.brothers.extend( \
-                                       [seg_child_sibling.parent \
-                                               for seg_child in self.children \
-                                               for seg_child_sibling in seg_child.brothers \
-                                               if seg_child_sibling.parent not in (self, None)]\
-                                       )
-                                       #print self.brothers
-                       
-                       def calcLevelFromRoot(self):
-                               if self.parent:
-                                       self.levelFromRoot = self.parent.levelFromRoot + 1
-                               
-                               for seg_child in self.children:
-                                       seg_child.calcLevelFromRoot()
-                                       
-                       # Dont use for now, but scale worked, transform was never tested.
-                       """
-                       def transform(self, matrix):
-                               self.headCo = self.headCo * matrix
-                               self.tailCo = self.tailCo * matrix
-                               
-                               if self.children:
-                                       ch1 = self.children[0]
-                                       ch2 = self.children[1]
-                                       
-                                       ch1.transform(matrix)
-                                       ch2.transform(matrix)
-                       
-                       def scale(self, scale, cent=None):
-                               # scale = 0.9
-                               #matrix = Matrix([scale,0,0],[0,scale,0],[0,0,scale]).resize4x4()
-                               #self.transform(matrix)
-                               if cent == None: # first iter
-                                       cent = self.headCo
-                                       self.tailCo = ((self.tailCo-cent) * scale) + cent
-                               else:
-                                       self.headCo = ((self.headCo-cent) * scale) + cent
-                                       self.tailCo = ((self.tailCo-cent) * scale) + cent
-                               
-                               if self.children:
-                                       self.children[0].scale(scale, cent)
-                                       self.children[1].scale(scale, cent)
-                       """
-                       def recalcChildLoc(self):
-                               if not self.children:
-                                       return
-                               ch1 = self.children[0]
-                               ch2 = self.children[1]
-                               new_mid = mergeCo(self.headCo, ch1.tailCo, ch2.tailCo, twig_fill_shape_rand)
-                               
-                               self.tailCo[:] = ch1.headCo[:] = ch2.headCo[:] = new_mid
-                               
-                               ch1.recalcChildLoc()
-                               ch2.recalcChildLoc()
-                       
-                       def merge(self, other):
-                               """
-                               Merge other into self and make a new segment
-                               """
-                               """
-                               seg_child = segment(self.levelFromLeaf)
-                               self.levelFromLeaf += 1
-                               
-                               seg_child.parent = other.parent = self
-                               
-                               # No need, recalcChildLoc sets the other coords
-                               #self.parent.tailCo = (self.headCo + self.tailCo + other.tailCo) / 3.0
-                               #self.parent.headCo[:] = self.headCo
-                               
-                               seg_child.headCo[:] = self.headCo
-                               
-                               # isect = LineIntersect(self.headCo, self.tailCo, other.headCo, other.tailCo)
-                               # new_head = (isect[0]+isect[1]) * 0.5
-                               
-                               seg_child.mergeCount += 1
-                               other.mergeCount += 1
-                               
-                               self.children.extend([ seg_child, other ])
-                               
-                               self.recalcChildLoc()
-                               
-                               # print 'merging', self.id, other.id
-                               """
-                               
-                               #new_head = (self.headCo + self.tailCo + other.headCo + other.tailCo) * 0.25
-                               
-                               self.parent = other.parent = segment(self.levelFromLeaf + 1)
-                               
-                               # No need, recalcChildLoc sets the self.parent.tailCo
-                               # self.parent.tailCo = (self.headCo + self.tailCo + other.tailCo) / 3.0
-                               
-                               self.parent.headCo[:] = self.headCo
-                               self.parent.bpt = self.bpt
-                               self.bpt = (None, False)
-                               
-                               # isect = LineIntersect(self.headCo, self.tailCo, other.headCo, other.tailCo)
-                               # new_head = (isect[0]+isect[1]) * 0.5
-                               
-                               self.mergeCount += 1
-                               other.mergeCount += 1
-                               
-                               self.parent.children.extend([ self, other ])
-                               
-                               self.parent.recalcChildLoc()
-                               # print 'merging', self.id, other.id
-                               
-                               
-                       def findBestMerge(self, twig_fill_fork_angle_max):
-                               # print "findBestMerge"
-                               if self.parent != None:
-                                       return
-                               
-                               best_dist = 1000000
-                               best_seg = None
-                               for seg_list in (self.brothers, segments_level[self.levelFromLeaf]):
-                                       #for seg_list in (segments_level[self.levelFromLeaf],):
-                                       
-                                       # only use all other segments if we cant find any from our brothers
-                                       if seg_list == segments_level[self.levelFromLeaf] and best_seg != None:
-                                               break
-                                       
-                                       for seg in seg_list:
-                                               # 2 ppoint join 
-                                               if seg != self and seg.mergeCount == 0 and seg.parent == None:
-                                                       
-                                                       # find the point they would join        
-                                                       test_dist = (self.tailCo - seg.tailCo).length
-                                                       if test_dist < best_dist:
-                                                               if twig_fill_fork_angle_max > 179:
-                                                                       best_dist = test_dist
-                                                                       best_seg = seg
-                                                               else:
-                                                                       # Work out if the desired angle range is ok.
-                                                                       mco = mergeCo( self.headCo, self.tailCo, seg.tailCo, 0.0 ) # we dont want the random value for this test
-                                                                       ang = AngleBetweenVecsSafe(self.tailCo-mco, seg.tailCo-mco)
-                                                                       if ang < twig_fill_fork_angle_max:
-                                                                               best_dist = test_dist
-                                                                               best_seg = seg
-                               return best_seg
-                       
-                       def getNormal(self):
-                               return (self.headCo - self.tailCo).normalize()
-                       
-                       def getLength(self):
-                               return (self.headCo - self.tailCo).length
-                       """
-                       def toMatrix(self, LEAF_SCALE, LEAF_RANDSCALE, LEAF_RANDVEC):
-                               if LEAF_RANDSCALE:      scale = LEAF_SCALE * Rand(1.0-LEAF_RANDSCALE, 1.0+LEAF_RANDSCALE)
-                               else:                           scale = LEAF_SCALE * 1.0
-                               
-                               if LEAF_RANDVEC:        rand_vec = Vector( Rand(-1, 1), Rand(-1, 1), Rand(-1, 1) ).normalize() * LEAF_RANDVEC
-                               else:                           rand_vec = Vector( )
-                               
-                               return Matrix([scale,0,0],[0,scale,0],[0,0,scale]).resize4x4() * (self.no + rand_vec).toTrackQuat('x', 'z').toMatrix().resize4x4() * TranslationMatrix(self.tailCo)
-                       """
-               def distripute_seg_on_mesh(me__, face_group):
-                       """
-                       add segment endpoints
-                       """
-                       
-                       vert_segment_mapping = {}
-                       for f in face_group:
-                               for v in f:
-                                       i = v.index
-                                       if i not in vert_segment_mapping:
-                                               vert_segment_mapping[i] = len(segments_all)
-                                               v.sel = True
-                                               seg = segment(0)
-                                               # seg.tailCo = v.co.copy() # headCo undefined atm.
-                                               seg.tailCo = v.co.copy() * self_tree.objectTwigBoundsMat * self_tree.objectCurveIMat
-                                               
-                                               # self_tree.objectCurveMat
-                                               
-                                               seg.no = v.no
-                       
-                       # Build connectivity
-                       for ed in me__.edges:
-                               if ed.v1.sel and ed.v2.sel:
-                                       i1,i2 = ed.key
-                                       i1 = vert_segment_mapping[i1]
-                                       i2 = vert_segment_mapping[i2]
-                                       
-                                       segments_all[i1].brothers.append( segments_all[i2] )
-                                       segments_all[i2].brothers.append( segments_all[i1] )
-                       
-                       # Dont need to return anything, added when created.
-               
-               def set_seg_attach_point(seg, interior_points, twig_fill_rand_scale):
-                       """
-                       Can only run on end nodes that have normals set
-                       """
-                       best_dist = 1000000000.0
-                       best_point = None
-                       
-                       co = seg.tailCo
-                       
-                       for pt in interior_points:
-                               # line from the point to the seg endpoint
-                               
-                               line_normal = seg.tailCo - pt.nextMidCo
-                               l = line_normal.length
-                               
-                               
-                               cross1 = CrossVecs( seg.no, line_normal )
-                               cross2 = CrossVecs( pt.no, line_normal )
-                               
-                               angle_line = min(AngleBetweenVecsSafe(cross1, cross2), AngleBetweenVecsSafe(cross1, -cross2))
-                               angle_leaf_no_diff = min(AngleBetweenVecsSafe(line_normal, seg.no), AngleBetweenVecsSafe(line_normal, -seg.no))
-                               
-                               # BEST_ANG=66.0
-                               # angle = 66.0 # min(AngleBetweenVecs(v2_co-v1_co, leaf.co-cc), AngleBetweenVecs(v1_co-v2_co, leaf.co-cc))
-                               # print angle, angle2
-                               # l = (l * ((1+abs(angle-BEST_ANG))**2 )) / (1+angle_line)
-                               l = (1+(angle_leaf_no_diff/180)) * (1+(angle_line/180)) * l
-                               
-                               if l < best_dist:
-                                       best_pt = pt
-                                       best_co = pt.nextMidCo
-                                       
-                                       best_dist = l
-       
-                       # twig_fill_rand_scale
-                       seg.headCo = best_co.copy()
-                       
-                       if twig_fill_rand_scale:
-                               seg_dir = seg.tailCo - seg.headCo
-                               
-                               seg_dir.length = seg_dir.length * ( 1.0 - (next_random_num(rnd)*twig_fill_rand_scale) )
-                               seg.tailCo = seg.headCo + seg_dir
-                       
-                       
-                       if best_pt.childCount < 4:
-                               # Watch this!!! adding a user before its attached and the branch is created!
-                               # make sure if its not added later on, this isnt left added
-                               best_pt.childCount += 1
-                               
-                               # True/False denotes weather we try to connect to our parent branch
-                               seg.bpt = (best_pt, True)
-                       else:
-                               seg.bpt = (best_pt, False)
-                               
-                       return True
-
-
-               # END Twig code, next add them
-               
-               
-               """
-               Uses a reversed approch, fill in twigs from a bounding mesh
-               """
-               # print "twig_fill_fork_angle_max"
-               # twig_fill_fork_angle_max = 60.0 # 
-               # forward_diff_bezier will fill in the blanks
-               # nice we can reuse these for every curve segment :)
-               pointlist = [[None, None, None] for i in xrange(self_tree.steps+1)]
-               radlist = [ None for i in xrange(self_tree.steps+1) ]
-               
-               orig_branch_count = len(self_tree.branches_all)
-               
-               for face_group in BPyMesh.mesh2linkedFaces(self_tree.objectTwigBoundsMesh):
-                       # Set the selection to do point inside.
-                       self_tree.objectTwigBoundsMesh.sel = False
-                       for f in face_group: f.sel = True
-                       
-                       interior_points = []
-                       interior_normal = Vector()
-                       for i, brch in enumerate(self_tree.branches_all):
-                               
-                               if i == orig_branch_count:
-                                       break # no need to check new branches are inside us
-                                       
-                               for pt in brch.bpoints:
-                                       if pt.next and pt.childCount < 4: # cannot attach to the last points
-                                               if self_tree.isPointInTwigBounds(pt.co, True): # selected_only
-                                                       interior_points.append(pt)
-                                                       interior_normal += pt.no * pt.radius
-                       
-                       segments_all[:] = []
-                       segments_level[:] = []
-                       
-                       if interior_points:
-                               # Ok, we can add twigs now
-                               distripute_seg_on_mesh( self_tree.objectTwigBoundsMesh, face_group )
-                               
-                               for seg in segments_level[0]: # only be zero segments
-                                       # Warning, increments the child count for bpoints we attach to!!
-                                       set_seg_attach_point(seg, interior_points, twig_fill_rand_scale)
-                               
-                               # Try sorting by other properties! this is ok for now
-                               for segments_level_current in segments_level:
-                                       segments_level_current.sort( key = lambda seg:  -(seg.headCo-seg.tailCo).length )
-                               
-                               for level in xrange(twig_fill_levels):
-                                       if len(segments_level) > level:
-                                               for seg in segments_level[level]:
-                                                       # print level, seg.brothers
-                                                       if seg.mergeCount == 0:
-                                                               seg_merge = seg.findBestMerge(twig_fill_fork_angle_max)
-                                                               if seg_merge:
-                                                                       seg.merge( seg_merge )
-                                       
-                                       if len(segments_level) > level+1:
-                                               for seg in segments_level[level+1]:
-                                                       seg.calcBrothers()
-                               
-                               for seg in segments_all:
-                                       if seg.parent == None:
-                                               seg.levelFromRoot = 0
-                                               seg.calcLevelFromRoot()
-                               
-                               '''
-                               for i, seg in enumerate(segments_all):  
-                                       # Make a branch from this data!
-                                       
-                                       brch = branch()
-                                       brch.type = BRANCH_TYPE_FILL
-                                       self_tree.branches_all.append(brch)
-                                       
-                                       # ============================= do this per bez pair
-                                       # 1 is the base and 2 is the tail
-                                       
-                                       #p1_h1 = seg.getHeadHandle()
-                                       p1_co = seg.headCo.copy()
-                                       p1_h2 = seg.getHeadHandle() # isnt used
-                                       
-                                       p2_h1 = seg.getTailHandle()
-                                       p2_co = seg.tailCo.copy()
-                                       #p2_h2 = seg.getTailHandle() # isnt used
-                                       
-                                       
-                                       bez1_vec = (None, p1_co, p1_h2)
-                                       bez2_vec = (p2_h1, p2_co, None)
-                                       
-                                       seg_root = seg.getRootSeg()
-                                       
-                                       radius_root = seg_root.bpt.radius * twig_fill_radius_factor
-                                       # Clamp so the head is never smaller then the tail
-                                       if radius_root < twig_fill_radius_min: radius_root = twig_fill_radius_min
-                                               
-                                       if seg_root.levelFromLeaf:
-                                               # print seg_root.levelFromLeaf, seg.levelFromRoot
-                                               WIDTH_STEP = (radius_root - twig_fill_radius_min) / (seg_root.levelFromLeaf+1)
-                                               
-                                               radius1 = twig_fill_radius_min + (WIDTH_STEP * (seg.levelFromLeaf+1))
-                                               if seg.levelFromLeaf:   radius2 = twig_fill_radius_min + (WIDTH_STEP * seg.levelFromLeaf)
-                                               else:                                   radius2 = twig_fill_radius_min
-                                       else:
-                                               radius1 = radius_root
-                                               radius2 = twig_fill_radius_min 
-                                       
-                                       
-                                       points_from_bezier_seg(self_tree.steps, pointlist, radlist, bez1_vec, bez2_vec, radius1, radius2)
-                                       
-                                       # dont apply self_tree.limbScale here! - its alredy done
-                                       bpoints = [ bpoint(brch, Vector(pointlist[ii]), Vector(), radlist[ii]) for ii in xrange(len(pointlist)) ]
-                                       
-                                       # remove endpoint for all but the last
-                                       #if i != len(bez_list)-1:
-                                       #       bpoints.pop()
-                                       
-                                       brch.bpoints.extend(bpoints)
-                                       # =============================
-                                       
-                                       # Finalize once point data is there
-                                       brch.calcData()
-                               #
-                               #preview_curve()
-                               '''
-                       
-                               for segments_level_current in reversed(segments_level):
-                                       for seg in segments_level_current:
-                                               if seg.used == False and (seg.parent == None or seg.parent.used == True):
-                                                       
-                                                       # The root segment for this set of links.
-                                                       # seg_root_linked = seg
-                                                       
-                                                       brch = branch()
-                                                       brch.type = BRANCH_TYPE_FILL
-                                                       self_tree.branches_all.append(brch)
-                                                       
-                                                       # Can we attach to a real branch?
-                                                       if seg.parent == None:
-                                                               if seg.bpt[1]: # we can do a real join into the attach point
-                                                                       brch.parent_pt = seg.bpt[0]
-                                                                       # brch.parent_pt.childCount # this has alredy changed from 
-                                                       
-                                                       '''
-                                                       if seg.parent:
-                                                               if seg.bpt[1] == 2:
-                                                                       #if seg.bpt[1]:
-                                                                       # print "Making Connection"
-                                                                       if seg.bpt[0] == None:
-                                                                               raise "Error"
-                                                                       if seg.bpt[1] != 2:
-                                                                               print seg.bpt[1]
-                                                                               raise "Error"
-                                                                       
-                                                                       brch.parent_pt = seg.bpt[1]
-                                                                       brch.parent_pt.childCount += 1
-                                                                       if brch.parent_pt.childCount > 4:
-                                                                               raise "Aeeae"
-                                                                       print "\n\nM<aking Joint!!"
-                                                       '''
-                                                       
-                                                       if seg.parent:
-                                                               sibling = seg.sibling()
-                                                               if sibling.new_bpt:
-                                                                       if sibling.new_bpt.childCount < 4:
-                                                                               brch.parent_pt = sibling.new_bpt
-                                                                               brch.parent_pt.childCount +=1
-                                                       
-                                                       # Go down the hierarhy
-                                                       is_first = True
-                                                       while seg != None:
-                                                               seg.used = True
-                                                               
-                                                               # ==============================================
-                                                               
-                                                               #p1_h1 = seg.getHeadHandle()
-                                                               p1_co = seg.headCo.copy()
-                                                               p1_h2 = seg.getHeadHandle() # isnt used
-                                                               
-                                                               p2_h1 = seg.getTailHandle()
-                                                               p2_co = seg.tailCo.copy()
-                                                               #p2_h2 = seg.getTailHandle() # isnt used
-                                                               
-                                                               
-                                                               bez1_vec = (None, p1_co, p1_h2)
-                                                               bez2_vec = (p2_h1, p2_co, None)
-                                                               
-                                                               seg_root = seg.getRootSeg()
-                                                               
-                                                               radius_root = seg_root.bpt[0].radius * twig_fill_radius_factor
-                                                               # Clamp so the head is never smaller then the tail
-                                                               if radius_root < twig_fill_radius_min: radius_root = twig_fill_radius_min
-                                                                       
-                                                               if seg_root.levelFromLeaf:      
-                                                                       # print seg_root.levelFromLeaf, seg.levelFromRoot
-                                                                       widthStep = (radius_root - twig_fill_radius_min) / (seg_root.levelFromLeaf+1)
-                                                                       
-                                                                       radius1 = twig_fill_radius_min + (widthStep * (seg.levelFromLeaf+1))
-                                                                       if seg.levelFromLeaf:   radius2 = twig_fill_radius_min + (widthStep * seg.levelFromLeaf)
-                                                                       else:                                   radius2 = twig_fill_radius_min
-                                                               else:
-                                                                       radius1 = radius_root
-                                                                       radius2 = twig_fill_radius_min 
-                                                               
-                                                               points_from_bezier_seg(self_tree.steps, pointlist, radlist, bez1_vec, bez2_vec, radius1, radius2)
-                                                               
-                                                               
-                                                               start_pointlist = 0
-                                                               
-                                                               # This is like baseTrim, (remove the base points to make nice joins, accounting for radius of parent point)
-                                                               # except we do it before the branch is made
-                                                               
-                                                               if brch.parent_pt:
-                                                                       while len(pointlist) - start_pointlist > 2 and (Vector(pointlist[start_pointlist]) - brch.parent_pt.co).length < (brch.parent_pt.radius*2):
-                                                                               start_pointlist +=1
-
-                                                               if is_first and brch.parent_pt:
-                                                                       # We need to move the base point to a place where it looks good on the parent branch
-                                                                       # to do this. move the first point, then remove the following points that look horrible (double back on themself)
-                                                                       
-                                                                       no = Vector(pointlist[0]) - Vector(pointlist[-1])
-                                                                       no.length = brch.parent_pt.radius*2
-                                                                       pointlist[0] = list(Vector(pointlist[0]) - no)
-                                                                       
-                                                                       """
-                                                                       pointlist[1][0] = (pointlist[0][0] + pointlist[2][0])/2.0
-                                                                       pointlist[1][1] = (pointlist[0][1] + pointlist[2][1])/2.0
-                                                                       pointlist[1][2] = (pointlist[0][2] + pointlist[2][2])/2.0
-                                                                       
-                                                                       pointlist[2][0] = (pointlist[1][0] + pointlist[3][0])/2.0
-                                                                       pointlist[2][1] = (pointlist[1][1] + pointlist[3][1])/2.0
-                                                                       pointlist[2][2] = (pointlist[1][2] + pointlist[3][2])/2.0
-                                                                       """
-                                                                       
-                                                                       
-                                                               # Done setting the start point
-                                                                       
-                                                                       
-                                                               len_pointlist = len(pointlist)
-                                                               if seg.children:
-                                                                       len_pointlist -= 1
-                                                               
-                                                               # dont apply self_tree.limbScale here! - its alredy done
-                                                               bpoints = [ bpoint(brch, Vector(pointlist[ii]), Vector(), radlist[ii]) for ii in xrange(start_pointlist, len_pointlist) ]
-                                                               brch.bpoints.extend( bpoints )
-                                                               # ==============================================
-                                                               
-                                                               seg.new_bpt = bpoints[0]
-                                                               
-                                                               if seg.children:
-                                                                       seg = seg.children[0]
-                                                               else:
-                                                                       seg = None
-                                                               
-                                                               is_first = False
-                                                               
-                                                       # done adding points
-                                                       brch.calcData()
-                                                       
-                                                       
-                                                       
-               
-       def buildTwigs(self, twig_ratio, twig_select_mode, twig_select_factor):
-               
-               ratio_int = int(len(self.branches_all) * twig_ratio)
-               if ratio_int == 0:
-                       return
-               
-               # So we only mix branches of similar lengths
-               branches_sorted = self.branches_all[:]
-               
-               # Get the branches based on our selection method!
-               if twig_select_mode==0:
-                       branches_sorted.sort( key = lambda brch: brch.getLength())
-               elif twig_select_mode==1:
-                       branches_sorted.sort( key = lambda brch:-brch.getLength())
-               elif twig_select_mode==2:
-                       branches_sorted.sort( key = lambda brch:brch.getStraightness())
-               elif twig_select_mode==3:
-                       branches_sorted.sort( key = lambda brch:-brch.getStraightness())
-               
-               factor_int = int(len(self.branches_all) * twig_select_factor)
-               branches_sorted[factor_int:] = []  # remove the last part of the list
-               
-               branches_sorted.sort( key = lambda brch: len(brch.bpoints))
-               
-               branches_new = []
-               #for i in xrange(ratio_int):
-               tot_twigs = 0
-               
-               step = 1
-               while tot_twigs < ratio_int and step < len(branches_sorted):
-                       # Make branches from the existing
-                       for j in xrange(step, len(branches_sorted)):
-                               brch = branches_sorted[j-step].mixToNew(branches_sorted[j], None)
-                               branches_new.append( brch )
-                               tot_twigs +=1
-                               
-                               if tot_twigs > ratio_int:
-                                       break
-               
-               ### print "TwigCount", len(branches_new), ratio_int
-               
-               self.branches_twigs = branches_new
-       
-       def toDebugDisplay(self):
-               '''
-               Should be able to call this at any time to see whats going on, dosnt work so nice ATM.
-               '''
-               sce = bpy.data.scenes.active
-               
-               for ob in self.debug_objects:
-                       for ob in sce.objects:
-                               sce.objects.unlink(ob)
-               
-               for branch_index, brch in enumerate(self.branches_all):
-                       pt_index = 0
-                       for pt_index, pt in enumerate(brch.bpoints):
-                               name = '%.3d_%.3d' % (branch_index, pt_index) 
-                               if pt.next==None:
-                                       name += '_end'
-                               if pt.prev==None:
-                                       name += '_start'
-                                       
-                               ob = sce.objects.new('Empty', name)
-                               self.debug_objects.append(ob)
-                               mat = ScaleMatrix(pt.radius, 4) * TranslationMatrix(pt.co)
-                               ob.setMatrix(mat)
-                               ob.setDrawMode(8) # drawname
-               Blender.Window.RedrawAll()
-               
-               
-       
-       def toMesh(self, mesh=None,\
-                       do_uv=True,\
-                       do_uv_keep_vproportion=True,\
-                       do_uv_vnormalize=False,\
-                       do_uv_uscale=False,\
-                       uv_image = None,\
-                       uv_x_scale=1.0,\
-                       uv_y_scale=4.0,\
-                       do_uv_blend_layer= False,\
-                       do_cap_ends=False,\
-               ):
-               
-               self.mesh = freshMesh(mesh)
-               totverts = 0
-               
-               for brch in self.branches_all:
-                       totverts += len(brch.bpoints)
-               
-               self.mesh.verts.extend( [ (0.0,0.0,0.0) ] * ((totverts * 4)+1) ) # +1 is a dummy vert
-               verts = self.mesh.verts
-               
-               # Assign verts to points, 4 verts for each point.
-               i = 1 # dummy vert, should be 0
-               for brch in self.branches_all:                  
-                       for pt in brch.bpoints:
-                               pt.verts[0] = verts[i]
-                               pt.verts[1] = verts[i+1]
-                               pt.verts[2] = verts[i+2]
-                               pt.verts[3] = verts[i+3]
-                               i+=4
-                               
-                       # Do this again because of collapsing
-                       # pt.calcVerts(brch)
-               
-               # roll the tube so quads best meet up to their branches.
-               for brch in self.branches_all:
-                       #for pt in brch.bpoints:
-                       if brch.parent_pt:
-                               
-                               # Use temp lists for gathering an average
-                               if brch.parent_pt.roll_angle == None:
-                                       brch.parent_pt.roll_angle = [brch.getParentQuadAngle()]
-                               # More then 2 branches use this point, add to the list
-                               else:
-                                       brch.parent_pt.roll_angle.append( brch.getParentQuadAngle() )
-               
-               # average the temp lists into floats
-               for brch in self.branches_all:
-                       #for pt in brch.bpoints:
-                       if brch.parent_pt and type(brch.parent_pt.roll_angle) == list:
-                               # print brch.parent_pt.roll_angle
-                               f = 0.0
-                               for val in brch.parent_pt.roll_angle:
-                                       f += val
-                               brch.parent_pt.roll_angle = f/len(brch.parent_pt.roll_angle)
-               
-               # set the roll of all the first segments that have parents,
-               # this is because their roll is set from their parent quad and we dont want them to roll away from that.
-               for brch in self.branches_all:
-                       if brch.parent_pt:
-                               # if the first joint has a child then apply half the roll
-                               # theres no correct solition here, but this seems ok
-                               if brch.bpoints[0].roll_angle != None:
-                                       #brch.bpoints[0].roll_angle *= 0.5
-                                       #brch.bpoints[0].roll_angle = 0.0
-                                       #brch.bpoints[1].roll_angle = 0.0
-                                       brch.bpoints[0].roll_angle = 0.0
-                                       pass
-                               else:
-                                       # our roll was set from the branches parent and needs no changing
-                                       # set it to zero so the following functions know to interpolate.
-                                       brch.bpoints[0].roll_angle = 0.0
-                                       #brch.bpoints[1].roll_angle = 0.0
-               
-               '''
-               Now interpolate the roll!
-               The method used here is a little odd.
-               
-               * first loop up the branch and set each points value to the "last defined" value and record the steps
-               since the last defined value
-               * Do the same again but backwards
-               
-               now for each undefined value we have 1 or 2 values, if its 1 its simple we just use that value 
-               ( no interpolation ), if there are 2 then we use the offsets from each end to work out the interpolation.
-               
-               one up, one back, and another to set the values, so 3 loops all up.
-               '''
-               #### print "scan up the branch..."
-               for brch in self.branches_all:
-                       last_value = None
-                       last_index = -1
-                       for i in xrange(len(brch.bpoints)):
-                               pt = brch.bpoints[i]
-                               if type(pt.roll_angle) in (float, int):
-                                       last_value = pt.roll_angle
-                                       last_index = i
-                               else:
-                                       if type(last_value) in (float, int):
-                                               # Assign a list, because there may be a connecting roll value from another joint
-                                               pt.roll_angle = [(last_value, i-last_index)]
-                               
-                       #### print "scan down the branch..."
-                       last_value = None
-                       last_index = -1
-                       for i in xrange(len(brch.bpoints)-1, -1, -1): # same as above but reverse
-                               pt = brch.bpoints[i]
-                               if type(pt.roll_angle) in (float, int):
-                                       last_value = pt.roll_angle
-                                       last_index = i
-                               else:
-                                       if last_value != None:
-                                               if type(pt.roll_angle) == list:
-                                                       pt.roll_angle.append((last_value, last_index-i))
-                                               else:
-                                                       #pt.roll_angle = [(last_value, last_index-i)]
-                                                       
-                                                       # Dont bother assigning a list because we wont need to add to it later
-                                                       pt.roll_angle = last_value 
-                       
-                       # print "looping ,...."
-                       ### print "assigning/interpolating roll values"
-                       for pt in brch.bpoints:
-                               
-                               # print "this roll IS", pt.roll_angle
-                               
-                               if pt.roll_angle == None:
-                                       continue
-                               elif type(pt.roll_angle) in (float, int):
-                                       pass
-                               elif len(pt.roll_angle) == 1:
-                                       pt.roll_angle = pt.roll_angle[0][0]
-                               else:
-                                       # interpolate
-                                       tot = pt.roll_angle[0][1] + pt.roll_angle[1][1]
-                                       pt.roll_angle = \
-                                        (pt.roll_angle[0][0] * (tot - pt.roll_angle[0][1]) +\
-                                         pt.roll_angle[1][0] * (tot - pt.roll_angle[1][1])) / tot
-                                       
-                                       #### print pt.roll_angle, 'interpolated roll'
-                                       
-                               pt.roll(pt.roll_angle)
-                               
-               # Done with temp average list. now we know the best roll for each branch.
-               
-               # mesh the data
-               for brch in self.branches_all:
-                       for pt in brch.bpoints:
-                               pt.toMesh(self.mesh)
-               
-               #faces_extend = [ face for brch in self.branches_all for pt in brch.bpoints for face in pt.faces if face ]
-               
-               
-               
-               faces_extend = []
-               for brch in self.branches_all:
-                       if brch.parent_pt:
-                               faces_extend.extend(brch.faces)
-                       for pt in brch.bpoints:
-                               for face in pt.faces:
-                                       if face:
-                                               faces_extend.append(face)
-               
-               if do_cap_ends:
-                       # TODO - UV map and image?
-                       faces_extend.extend([ brch.bpoints[-1].verts for brch in self.branches_all ])
-               
-               faces = self.mesh.faces
-
-               faces.extend(faces_extend, smooth=True)
-               
-               if do_uv:
-                       # Assign the faces back
-                       face_index = 0
-                       for brch in self.branches_all:
-                               if brch.parent_pt:
-                                       for i in (0,1,2,3):
-                                               face = brch.faces[i] = faces[face_index+i]
-                                       face_index +=4
-                               
-                               for pt in brch.bpoints:
-                                       for i in (0,1,2,3):
-                                               if pt.faces[i]:
-                                                       pt.faces[i] = faces[face_index]
-                                                       face_index +=1
-                       
-                       #if self.mesh.faces:
-                       #       self.mesh.faceUV = True
-                       mesh.addUVLayer( 'base' )
-                       
-                       # rename the uv layer
-                       #mesh.renameUVLayer(mesh.getUVLayerNames()[0], 'base')
-                       
-                       for brch in self.branches_all:
-                               
-                               uv_x_scale_branch = 1.0
-                               if do_uv_uscale:
-                                       uv_x_scale_branch = 0.0
-                                       for pt in brch.bpoints:
-                                               uv_x_scale_branch += pt.radius
-                                       
-                                       uv_x_scale_branch = uv_x_scale_branch / len(brch.bpoints)
-                                       # uv_x_scale_branch = brch.bpoints[0].radius
-                               
-                               if do_uv_vnormalize:
-                                       uv_normalize = []
-                               
-                               def uvmap_faces(my_faces, y_val, y_size):
-                                       '''
-                                       Accept a branch or pt faces
-                                       '''
-                                       uv_ls = [None, None, None, None]
-                                       for i in (0,1,2,3):
-                                               if my_faces[i]:
-                                                       if uv_image:
-                                                               my_faces[i].image = uv_image
-                                                       uvs = my_faces[i].uv
-                                               else:
-                                                       # Use these for calculating blending values
-                                                       uvs = [Vector(0,0), Vector(0,0), Vector(0,0), Vector(0,0)]
-                                               
-                                               uv_ls[i] = uvs
-                                               
-                                               x1 = i*0.25 * uv_x_scale * uv_x_scale_branch    
-                                               x2 = (i+1)*0.25 * uv_x_scale * uv_x_scale_branch
-                                               
-                                               uvs[3].x = x1;
-                                               uvs[3].y = y_val+y_size
-                                               
-                                               uvs[0].x = x1
-                                               uvs[0].y = y_val
-                                               
-                                               uvs[1].x = x2
-                                               uvs[1].y = y_val
-                                               
-                                               uvs[2].x = x2
-                                               uvs[2].y = y_val+y_size
-                                               
-                                               if do_uv_vnormalize:
-                                                       uv_normalize.extend(uvs)
-                                       
-                                       return uv_ls
-                                       
-                               # Done uvmap_faces
-                               
-                               y_val = 0.0
-                               
-                               if brch.parent_pt:
-                                       y_size = (brch.getParentFaceCent() - brch.bpoints[0].co).length
-                                       
-                                       if do_uv_keep_vproportion:
-                                               y_size = y_size / ((brch.bpoints[0].radius + brch.parent_pt.radius)/2) * uv_y_scale
-                                       
-                                       brch.uv = uvmap_faces(brch.faces, 0.0, y_size)
-                                       
-                                       y_val += y_size
-                               
-                               for pt in brch.bpoints:
-                                       if pt.next:
-                                               y_size = (pt.co-pt.next.co).length
-                                               # scale the uvs by the radius, avoids stritching.
-                                               if do_uv_keep_vproportion:
-                                                       y_size = y_size / pt.radius * uv_y_scale
-                                               pt.uv = uvmap_faces(pt.faces, y_val, y_size)
-                                               y_val += y_size
-                               
-                               
-                               if do_uv_vnormalize and uv_normalize:
-                                       # Use yscale here so you can choose to have half the normalized value say.
-                                       vscale = (1/uv_normalize[-1].y) * uv_y_scale
-                                       for uv in uv_normalize:
-                                               uv.y *= vscale
-                       
-                       
-                       # Done with UV mapping the first layer! now map the blend layers
-                       if do_uv_blend_layer:
-                               # Set up the blend UV layer - this is simply the blending for branch joints
-                               mesh.addUVLayer( 'blend' )
-                               mesh.activeUVLayer = 'blend'
-                               
-                               # Set all faces to be on full blend
-                               for f in mesh.faces:
-                                       for uv in f.uv:
-                                               uv.y = uv.x = 0.0
-                               
-                               for brch in self.branches_all:
-                                       if brch.parent_pt:
-                                               for f in brch.faces:
-                                                       if f:
-                                                               uvs = f.uv
-                                                               uvs[0].x = uvs[1].x = uvs[2].x = uvs[3].x = 0.0 
-                                                               uvs[0].y = uvs[1].y = 1.0 # swap these? - same as inverting the blend
-                                                               uvs[2].y = uvs[3].y = 0.0
-                               
-                               # Set up the join UV layer, this overlays nice blended
-                               mesh.addUVLayer( 'join' )
-                               mesh.activeUVLayer = 'join'
-                               
-                               # Set all faces to be on full blend
-                               for f in mesh.faces:
-                                       for uv in f.uv:
-                                               uv.y = uv.x = 0.0
-                               
-                               for brch in self.branches_all:
-                                       if brch.parent_pt:
-                                               # The UV's that this branch would cover if it was a face, 
-                                               uvs_base = brch.parent_pt.uv[brch.getParentQuadIndex()]
-                                               
-                                               uvs_base_mid = Vector(0,0)
-                                               for uv in uvs_base:
-                                                       uvs_base_mid += uv
-                                                       
-                                               uvs_base_mid *= 0.25
-                                               
-                                               # TODO - Factor scale and distance in here 
-                                               ## uvs_base_small = [(uv+uvs_base_mid)*0.5 for uv in uvs_base]
-                                               uvs_base_small = [uvs_base_mid, uvs_base_mid, uvs_base_mid, uvs_base_mid]
-                                               
-                                               if brch.faces[0]:
-                                                       f = brch.faces[0]
-                                                       uvs = f.uv
-                                                       uvs[0][:] = uvs_base[0]
-                                                       uvs[1][:] = uvs_base[1]
-                                                       
-                                                       uvs[2][:] = uvs_base_small[1]
-                                                       uvs[3][:] = uvs_base_small[0]
-                                               
-                                               if brch.faces[1]:
-                                                       f = brch.faces[1]
-                                                       uvs = f.uv
-                                                       uvs[0][:] = uvs_base[1]
-                                                       uvs[1][:] = uvs_base[2]
-                                                       
-                                                       uvs[2][:] = uvs_base_small[2]
-                                                       uvs[3][:] = uvs_base_small[1]
-                                                       
-                                               if brch.faces[2]:
-                                                       f = brch.faces[2]
-                                                       uvs = f.uv
-                                                       uvs[0][:] = uvs_base[2]
-                                                       uvs[1][:] = uvs_base[3]
-                                                       
-                                                       uvs[2][:] = uvs_base_small[3]
-                                                       uvs[3][:] = uvs_base_small[2]
-                                                       
-                                               if brch.faces[3]:
-                                                       f = brch.faces[3]
-                                                       uvs = f.uv
-                                                       uvs[0][:] = uvs_base[3]
-                                                       uvs[1][:] = uvs_base[0]
-                                                       
-                                                       uvs[2][:] = uvs_base_small[0]
-                                                       uvs[3][:] = uvs_base_small[3]
-                       
-                       mesh.activeUVLayer = 'base'  # just so people dont get worried the texture is not there - dosnt effect rendering.
-               else:
-                       # no UV's
-                       pass
-               
-               if do_cap_ends:
-                       # de-select end points for 
-                       i = len(faces)-1
-                       
-                       cap_end_face_start = len(faces) - len(self.branches_all)
-                       
-                       j = 0
-                       for i in xrange(cap_end_face_start, len(faces)):
-                               self.branches_all[j].face_cap = faces[i]
-                               faces[i].sel = 0
-                               
-                               # default UV's are ok for now :/
-                               if do_uv and uv_image:
-                                       faces[i].image = uv_image
-                               
-                               j +=1
-                       
-                       # set edge crease for capped ends.
-                       for ed in self.mesh.edges:
-                               if ed.v1.sel==False and ed.v2.sel==False:
-                                       ed.crease = 255
-                                       ed.sel = True # so its all selected still
-                       
-               del faces_extend
-               
-               return self.mesh
-       
-       def toLeafMesh(self, mesh_leaf,\
-                       leaf_branch_limit = 0.5,\
-                       leaf_branch_limit_rand = 0.8,\
-                       leaf_branch_limit_type_curve = False,\
-                       leaf_branch_limit_type_grow = False,\
-                       leaf_branch_limit_type_fill = False,\
-                       leaf_size = 0.5,\
-                       leaf_size_rand = 0.5,\
-                       leaf_branch_density = 0.2,\
-                       leaf_branch_pitch_angle = 0.0,\
-                       leaf_branch_pitch_rand = 0.2,\
-                       leaf_branch_roll_rand = 0.2,\
-                       leaf_branch_angle = 75.0,\
-                       leaf_rand_seed = 1.0,\
-                       leaf_object=None,\
-               ):
-               
-               '''
-               return a mesh with leaves seperate from the tree
-               
-               Add to the existing mesh.
-               '''
-               
-               #radius = [(pt.radius for pt in self.branches_all for pt in brch.bpoints for pt in brch.bpoints]
-               mesh_leaf = freshMesh(mesh_leaf)
-               self.mesh_leaf = mesh_leaf
-               
-               # if not leaf_object: return # make the dupli anyway :/ - they can do it later or the script could complain
-               
-               if leaf_branch_limit == 1.0:
-                       max_radius = 1000000.0
-               else:
-                       # We wont place leaves on all branches so...
-                       # first collect stats, we want to know the average radius and total segments
-                       totpoints = 0
-                       radius = 0.0
-                       max_radius = 0.0
-                       for brch in self.branches_all:
-                               for pt in brch.bpoints:
-                                       radius += pt.radius
-                                       if pt.radius > max_radius:
-                                               max_radius = pt.radius
-                               
-                               #totpoints += len(brch.bpoints)
-                               
-                       radius_max = max_radius * leaf_branch_limit
-               
-               verts_extend = []
-               faces_extend = []
-               
-               co1 = Vector(0.0, -0.5, -0.5)
-               co2 = Vector(0.0, -0.5, 0.5)
-               co3 = Vector(0.0, 0.5, 0.5)
-               co4 = Vector(0.0, 0.5, -0.5)
-               
-               rnd_seed = [leaf_rand_seed] # could have seed as an input setting
-               
-               for brch in self.branches_all:
-                       
-                       # quick test, do we need leaves on this branch?
-                       if leaf_branch_limit != 1.0 and brch.bpoints[-1].radius > radius_max:
-                               continue
-                       
-                       
-                       for pt in brch.bpoints:
-                               
-                               # For each point we can add 2 leaves
-                               for odd_even in (0,1):
-                                       
-                                       
-                                       if      (pt == brch.bpoints[-1] and odd_even==1) or \
-                                               (leaf_branch_density != 1.0 and leaf_branch_density < next_random_num(rnd_seed)):
-                                               pass
-                                       else:
-                                               if leaf_branch_limit_rand:
-                                                       # (-1 : +1) * leaf_branch_limit_rand
-                                                       rnd = 1 + (((next_random_num(rnd_seed) - 0.5) * 2 ) * leaf_branch_limit_rand)
-                                               else:
-                                                       rnd = 1.0
-                                               
-                                               if pt.childCount == 0 and (leaf_branch_limit == 1.0 or (pt.radius * rnd) < radius_max):
-                                                       leaf_size_tmp = leaf_size * (1.0-(next_random_num(rnd_seed)*leaf_size_rand))
-                                                       
-                                                       # endpoints dont rotate
-                                                       if pt.next != None:
-                                                               cross1 = CrossVecs(zup, pt.no) # use this to offset the leaf later
-                                                               cross2 = CrossVecs(cross1, pt.no)
-                                                               if odd_even ==0:
-                                                                       mat_yaw = RotationMatrix(leaf_branch_angle, 3, 'r',  cross2)
-                                                               else:
-                                                                       mat_yaw = RotationMatrix(-leaf_branch_angle, 3, 'r', cross2)
-                                                               
-                                                               leaf_no = (pt.no * mat_yaw)
-                                                               
-                                                               # Correct upwards pointing from changing the yaw 
-                                                               #my_up = zup * mat
-                                                               
-                                                               # correct leaf location for branch width
-                                                               cross1.length = pt.radius/2
-                                                               leaf_co = pt.co + cross1
-                                                       else:
-                                                               # no correction needed, we are at the end of the branch
-                                                               leaf_no = pt.no
-                                                               leaf_co = pt.co
-                                                       
-                                                       mat = Matrix([leaf_size_tmp,0,0],[0,leaf_size_tmp,0],[0,0,leaf_size_tmp]) * leaf_no.toTrackQuat('x', 'z').toMatrix()
-                                                       
-                                                       # Randomize pitch and roll for the leaf
-                                                       
-                                                       # work out the axis to pitch and roll
-                                                       cross1 = CrossVecs(zup, leaf_no) # use this to offset the leaf later
-                                                       if leaf_branch_pitch_rand or leaf_branch_pitch_angle:
-                                                               
-                                                               angle = -leaf_branch_pitch_angle
-                                                               if leaf_branch_pitch_rand:
-                                                                       angle += leaf_branch_pitch_rand * ((next_random_num(rnd_seed)-0.5)*360)
-                                                               
-                                                               mat_pitch = RotationMatrix( angle, 3, 'r', cross1)
-                                                               mat = mat * mat_pitch
-                                                       if leaf_branch_roll_rand:
-                                                               mat_roll =  RotationMatrix( leaf_branch_roll_rand * ((next_random_num(rnd_seed)-0.5)*360), 3, 'r', leaf_no)
-                                                               mat = mat * mat_roll
-                                                       
-                                                       mat = mat.resize4x4() * TranslationMatrix(leaf_co)
-                                                       
-                                                       i = len(verts_extend)
-                                                       faces_extend.append( (i,i+1,i+2,i+3) )
-                                                       verts_extend.extend([tuple(co4*mat), tuple(co3*mat), tuple(co2*mat), tuple(co1*mat)])
-                                       #count += 1
-                               
-               
-               # setup dupli's
-               
-               self.mesh_leaf.verts.extend(verts_extend)
-               self.mesh_leaf.faces.extend(faces_extend)
-               
-               return self.mesh_leaf
-       
-       
-       def toArmature(self, ob_arm, armature):
-               
-               armature.drawType = Blender.Armature.STICK
-               armature.makeEditable() # enter editmode
-               
-               # Assume toMesh has run
-               self.armature = armature
-               for bonename in armature.bones.keys():
-                       del armature.bones[bonename]
-               
-               
-               group_names = []
-               
-               for i, brch in enumerate(self.branches_all):
-                       
-                       # get a list of parent points to make into bones. use parents and endpoints
-                       bpoints_parent = [pt for pt in brch.bpoints if pt.childCount or pt.prev == None or pt.next == None]
-                       bpbone_last = None
-                       for j in xrange(len(bpoints_parent)-1):
-                               
-                               # bone container class
-                               bpoints_parent[j].bpbone = bpbone = bpoint_bone()
-                               bpbone.name = '%i_%i' % (i,j) # must be unique
-                               group_names.append(bpbone.name)
-                               
-                               bpbone.editbone = Blender.Armature.Editbone() # automatically added to the armature
-                               self.armature.bones[bpbone.name] = bpbone.editbone
-                               
-                               bpbone.editbone.head = bpoints_parent[j].co
-                               bpbone.editbone.head = bpoints_parent[j].co
-                               bpbone.editbone.tail = bpoints_parent[j+1].co
-                               
-                               # parent the chain.
-                               if bpbone_last:
-                                       bpbone.editbone.parent = bpbone_last.editbone
-                                       bpbone.editbone.options = [Blender.Armature.CONNECTED]
-                               
-                               bpbone_last = bpbone
-               
-               for brch in self.branches_all:
-                       if brch.parent_pt: # We must have a parent
-                               
-                               # find the bone in the parent chain to use for the parent of this
-                               parent_pt = brch.parent_pt
-                               bpbone_parent = None
-                               while parent_pt:
-                                       bpbone_parent = parent_pt.bpbone
-                                       if bpbone_parent:
-                                               break
-                                       
-                                       parent_pt = parent_pt.prev
-                               
-                               
-                               if bpbone_parent:
-                                       brch.bpoints[0].bpbone.editbone.parent = bpbone_parent.editbone
-                               else: # in rare cases this may not work. should be verry rare but check anyway.
-                                       print 'this is really odd... look into the bug.'
-               
-               self.armature.update() # exit editmode
-               
-               # Skin the mesh
-               if self.mesh:
-                       for group in group_names:
-                               self.mesh.addVertGroup(group)
-               
-               for brch in self.branches_all:
-                       vertList = []
-                       group = '' # dummy
-                       
-                       for pt in brch.bpoints:
-                               if pt.bpbone:
-                                       if vertList:
-                                               self.mesh.assignVertsToGroup(group, vertList, 1.0, Blender.Mesh.AssignModes.ADD)
-                                       
-                                       vertList = []
-                                       group = pt.bpbone.name
-                               
-                               vertList.extend( [v.index for v in pt.verts] )
-                       
-                       if vertList:
-                               self.mesh.assignVertsToGroup(group, vertList, 1.0, Blender.Mesh.AssignModes.ADD)
-               
-               return self.armature
-       
-       def toAction(self, ob_arm, texture, anim_speed=1.0, anim_magnitude=1.0, anim_speed_size_scale=True, anim_offset_scale=1.0):
-               # Assume armature
-               action = ob_arm.action
-               if not action:
-                       action = bpy.data.actions.new()
-                       action.fakeUser = False # so we dont get masses of bad data
-                       ob_arm.action = action
-               
-               # Blender.Armature.NLA.ob_arm.
-               pose = ob_arm.getPose()
-               
-               for pose_bone in pose.bones.values():
-                       pose_bone.insertKey(ob_arm, 0, [Blender.Object.Pose.ROT], True)
-               
-               # Now get all the IPO's
-               
-               ipo_dict = action.getAllChannelIpos()
-               # print ipo_dict
-               
-               # Sicne its per frame, it increases very fast. scale it down a bit
-               anim_speed = anim_speed/100
-               
-               # When we have the same trees next to eachother, they will animate the same way unless we give each its own texture or offset settings.
-               # We can use the object's location as a factor - this also will have the advantage? of seeing the animation move across the tree's
-               # allow a scale so the difference between tree textures can be adjusted.
-               anim_offset = self.objectCurve.matrixWorld.translationPart() * anim_offset_scale
-               
-               anim_speed_final = anim_speed
-               # Assign drivers to them all
-               for name, ipo in ipo_dict.iteritems():
-                       tex_str = 'b.Texture.Get("%s")' % texture.name
-                       
-                       if anim_speed_size_scale:
-                               # Adjust the speed by the bone size.
-                               # get the point from the name. a bit ugly but works fine ;) - Just dont mess the index up!
-                               lookup = [int(val) for val in name.split('_')]
-                               pt = self.branches_all[ lookup[0] ].bpoints[ lookup[1] ]
-                               anim_speed_final = anim_speed / (1+pt.radius)
-                       
-                       cu = ipo[Blender.Ipo.PO_QUATX]
-                       try:    cu.delBezier(0) 
-                       except: pass
-                       cu.driver = 2 # Python expression
-                       cu.driverExpression = '%.3f*(%s.evaluate(((b.Get("curframe")*%.3f)+%.3f,%.3f,%.3f)).w-0.5)' % (anim_magnitude, tex_str, anim_speed_final, anim_offset.x, anim_offset.y, anim_offset.z)
-                       
-                       cu = ipo[Blender.Ipo.PO_QUATY]
-                       try:    cu.delBezier(0) 
-                       except: pass
-                       cu.driver = 2 # Python expression
-                       cu.driverExpression = '%.3f*(%s.evaluate((%.3f,(b.Get("curframe")*%.3f)+%.3f,%.3f)).w-0.5)' % (anim_magnitude, tex_str,  anim_offset.x, anim_speed_final, anim_offset.y, anim_offset.z)
-                       
-                       cu = ipo[Blender.Ipo.PO_QUATZ]
-                       try:    cu.delBezier(0) 
-                       except: pass
-                       cu.driver = 2 # Python expression
-                       cu.driverExpression = '%.3f*(%s.evaluate((%.3f,%.3f,(b.Get("curframe")*%.3f)+%.3f)).w-0.5)' % (anim_magnitude, tex_str,  anim_offset.x, anim_offset.y, anim_speed_final, anim_offset.z)
-               
-xyzup = Vector(1,1,1).normalize()
-xup = Vector(1,0,0)
-yup = Vector(0,1,0)
-zup = Vector(0,0,1)
-
-class bpoint_bone:
-       def __init__(self):
-               self.name = None
-               self.editbone = None
-               self.blenbone = None
-               self.posebone = None
-
-class bpoint(object):
-       ''' The point in the middle of the branch, not the mesh points
-       '''
-       __slots__ = 'branch', 'co', 'no', 'radius', 'vecs', 'verts', 'children', 'faces', 'uv', 'next', 'prev', 'childCount', 'bpbone', 'roll_angle', 'nextMidCo', 'childrenMidCo', 'childrenMidRadius', 'targetCos', 'inTwigBounds'
-       def __init__(self, brch, co, no, radius):
-               self.branch = brch
-               self.co = co
-               self.no = no
-               self.radius = radius
-               self.vecs =             [None, None, None, None] # 4 for now
-               self.verts =    [None, None, None, None]
-               self.children = [None, None, None, None] # child branches, dont fill in faces here
-               self.faces = [None, None, None, None]
-               self.uv = None # matching faces, except - UV's are calculated even if there is no face, this is so we can calculate the blending UV's
-               self.next = None
-               self.prev = None
-               self.childCount = 0
-               self.bpbone = None # bpoint_bone instance
-               
-               # when set, This is the angle we need to roll to best face our branches
-               # the roll that is set may be interpolated if we are between 2 branches that need to roll.
-               # Set to None means that the roll will be left default (from parent)
-               self.roll_angle = None
-               
-               
-               # The location between this and the next point,
-               # if we want to be tricky we can try make this not just a simple
-               # inbetween and use the normals to have some curvature
-               self.nextMidCo = None
-               
-               # Similar to above, median point of all children
-               self.childrenMidCo = None
-               
-               # Similar as above, but for radius
-               self.childrenMidRadius = None
-               
-               # Target locations are used when you want to move the point to a new location but there are
-               # more then 1 influence, build up a list and then apply
-               self.targetCos = []
-               
-               # When we use twig bounding mesh, store if this point is in the bounding mesh. Assume true unless we set to false and do the test
-               self.inTwigBounds = True 
-       
-       def __repr__(self):
-               s = ''
-               s += '\t\tco:', self.co
-               s += '\t\tno:', self.no
-               s += '\t\tradius:', self.radius
-               s += '\t\tchildren:', [(child != False) for child in self.children]
-               return s
-               
-       def makeLast(self):
-               self.next = None
-               self.nextMidCo = None
-               self.childrenMidCo = None
-       
-       def setCo(self, co):
-               self.co[:] = co
-               self.calcNextMidCo()
-               self.calcNormal()
-               
-               if self.prev:
-                       self.prev.calcNextMidCo()
-                       self.prev.calcNormal()
-                       self.prev.calcChildrenMidData()
-               
-               if self.next:
-                       self.prev.calcNormal()
-               
-               self.calcChildrenMidData()
-               
-               
-       def nextLength(self):
-               return (self.co-self.next.co).length
-       def prevLength(self):
-               return (self.co-self.prev.co).length
-               
-       def hasOverlapError(self):
-               if self.prev == None:
-                       return False
-               if self.next == None:
-                       return False
-               '''
-               # see if this point sits on the line between its siblings.
-               co, fac = ClosestPointOnLine(self.co, self.prev.co, self.next.co)
-               
-               if fac >= 0.0 and fac <= 1.0:
-                       return False # no overlap, we are good
-               else:
-                       return True # error, some overlap
-               '''
-               
-               
-               # Alternate method, maybe better
-               ln = self.nextLength()
-               lp = self.prevLength()
-               ls = (self.prev.co-self.next.co).length
-               
-               # Are we overlapping? the length from our next or prev is longer then the next-TO-previous?
-               if ln>ls or lp>ls:
-                       return True
-               else:
-                       return False
-               
-       
-       def applyTargetLocation(self):
-               if not self.targetCos:
-                       return False
-               elif len(self.targetCos) == 1:
-                       co_all = self.targetCos[0]
-               else:
-                       co_all = Vector()
-                       for co in self.targetCos:
-                               co_all += co
-                       co_all = co_all / len(self.targetCos)
-               
-               self.targetCos[:] = []
-               
-               length = (self.co-co_all).length
-               # work out if we are moving up or down
-               if AngleBetweenVecsSafe(self.no, self.co - co_all) < 90:
-                       
-                       # Up
-                       while length > (self.co-self.prev.co).length:
-                               if not self.collapseUp():
-                                       break
-                       
-               else:
-                       # Down
-                       while length*2 > (self.co-self.next.co).length:
-                               if not self.collapseDown():
-                                       break
-                               
-               self.setCo(co_all)
-               
-               return True
-       
-       def calcNextMidCo(self):
-               if not self.next:
-                       return None
-               
-               # be tricky later.
-               self.nextMidCo = (self.co + self.next.co) * 0.5
-       
-       def calcNormal(self):
-               if self.prev == None:
-                       self.no = (self.next.co - self.co).normalize()
-               elif self.next == None:
-                       self.no = (self.co - self.prev.co).normalize()
-               else:
-                       self.no = (self.next.co - self.prev.co).normalize()
-       
-       def calcChildrenMidData(self):
-               '''
-               Calculate childrenMidCo & childrenMidRadius
-               This is a bit tricky, we need to find a point between this and the next,
-               the medium of all children, this point will be on the line between this and the next.
-               '''
-               if not self.next:
-                       return None
-               
-               # factor between this and the next point
-               radius = factor = factor_i = 0.0
-               
-               count = 0
-               for brch in self.children:
-                       if brch: # we dont need the co at teh moment.
-                               co, fac = ClosestPointOnLine(brch.bpoints[0].co, self.co, self.next.co)
-                               factor_i += fac
-                               count += 1
-                               
-                               radius += brch.bpoints[0].radius
-               
-               if not count:
-                       return
-               
-               # interpolate points 
-               factor_i        = factor_i/count
-               factor          = 1-factor_i
-               
-               self.childrenMidCo = (self.co * factor) + (self.next.co * factor_i)
-               self.childrenMidRadius = radius
-               
-               #debug_pt(self.childrenMidCo)
-               
-       def getAbsVec(self, index):
-               # print self.vecs, index
-               return self.co + self.vecs[index]
-       
-       def slide(self, factor):
-               '''
-               Slides the segment up and down using the prev and next points
-               '''
-               self.setCo(self.slideCo(factor))
-       
-       def slideCo(self, factor):
-               if self.prev == None or self.next == None or factor==0.0:
-                       return
-               
-               if factor < 0.0:
-                       prev_co = self.prev.co
-                       co = self.co
-                       
-                       ofs = co-prev_co
-                       ofs.length = abs(factor)
-                       self.co - ofs
-                       
-                       return self.co - ofs
-               else:
-                       next_co = self.next.co
-                       co = self.co
-                       
-                       ofs = co-next_co
-                       ofs.length = abs(factor)
-                       
-                       return self.co - ofs
-               
-       
-       def collapseDown(self):
-               '''
-               Collapse the next point into this one
-               '''
-               
-               # self.next.next == None check is so we dont shorten the final length of branches.
-               if self.next == None or self.next.next == None or self.childCount or self.next.childCount:
-                       return False
-               
-               self.branch.bpoints.remove(self.next)
-               self.next = self.next.next # skip 
-               self.next.prev = self
-               
-               # Watch this place - must update all data thats needed. roll is not calculaetd yet.
-               self.calcNextMidCo()
-               return True
-               
-       def collapseUp(self):
-               '''
-               Collapse the previous point into this one
-               '''
-               
-               # self.next.next == None check is so we dont shorten the final length of branches.
-               if self.prev == None or self.prev.prev == None or self.prev.childCount or self.prev.prev.childCount:
-                       return False
-               
-               self.branch.bpoints.remove(self.prev)
-               self.prev = self.prev.prev # skip 
-               self.prev.next = self
-               
-               # Watch this place - must update all data thats needed. roll is not calculaetd yet.
-               self.prev.calcNextMidCo()
-               return True
-               
-       
-       def smooth(self, factor, factor_joint):
-               '''
-               Blend this point into the other 2 points
-               '''
-               if self.next == None or self.prev == None:
-                       return False
-               
-               if self.childCount or self.prev.childCount:
-                       factor = factor_joint;
-               
-               if factor==0.0:
-                       return False;
-               
-               radius = (self.next.radius + self.prev.radius)/2.0
-               no = (self.next.no + self.prev.no).normalize()
-               
-               # do a line intersect to work out the best location
-               '''
-               cos = LineIntersect(    self.next.co, self.next.co+self.next.no,\
-                                                               self.prev.co, self.prev.co+self.prev.no)
-               if cos == None:
-                       co = (self.prev.co + self.next.co)/2.0
-               else:
-                       co = (cos[0]+cos[1])/2.0
-               '''
-               # Above can give odd results every now and then
-               co = (self.prev.co + self.next.co)/2.0
-               
-               # Now apply
-               factor_i = 1.0-factor
-               self.setCo(self.co*factor_i  +  co*factor)
-               self.radius = self.radius*factor_i  +  radius*factor
-               
-               return True
-               
-       def childPoint(self, index):
-               '''
-               Returns the middle point for any children between this and the next edge
-               '''
-               if self.next == None:
-                       raise 'Error'
-               
-               if index == 0:  return (self.getAbsVec(0) + self.next.getAbsVec(1)) / 2
-               if index == 1:  return (self.getAbsVec(1) + self.next.getAbsVec(2)) / 2
-               if index == 2:  return (self.getAbsVec(2) + self.next.getAbsVec(3)) / 2
-               if index == 3:  return (self.getAbsVec(3) + self.next.getAbsVec(0)) / 2
-       
-       def childPointUnused(self, index):
-               '''
-               Same as above but return None when the point is alredy used.
-               '''
-               if self.children[index]:
-                       return None
-               return self.childPoint(index)
-               
-       
-       def roll(self, angle):
-               '''
-               Roll the quad about its normal 
-               use for aurienting the sides of a quad to meet a branch that stems from here...
-               '''
-               # debugVec(self.co, self.co + self.no)
-               
-               mat = RotationMatrix(angle, 3, 'r', self.no)
-               for i in xrange(4):
-                       self.vecs[i] = self.vecs[i] * mat
-       
-       
-       def toMesh(self, mesh):
-               self.verts[0].co = self.getAbsVec(0)
-               self.verts[1].co = self.getAbsVec(1)
-               self.verts[2].co = self.getAbsVec(2)
-               self.verts[3].co = self.getAbsVec(3)
-               
-               if not self.next:
-                       return
-               
-               if self.prev == None and self.branch.parent_pt:
-                       # join from parent branch
-                       
-                       # which side are we of the parents quad
-                       index = self.branch.parent_pt.children.index(self.branch)
-                       
-                       # collect the points we are to merge into between the parent its next point
-                       if index==0:    verts = [self.branch.parent_pt.verts[0], self.branch.parent_pt.verts[1], self.branch.parent_pt.next.verts[1], self.branch.parent_pt.next.verts[0]]
-                       if index==1:    verts = [self.branch.parent_pt.verts[1], self.branch.parent_pt.verts[2], self.branch.parent_pt.next.verts[2], self.branch.parent_pt.next.verts[1]]
-                       if index==2:    verts = [self.branch.parent_pt.verts[2], self.branch.parent_pt.verts[3], self.branch.parent_pt.next.verts[3], self.branch.parent_pt.next.verts[2]]
-                       if index==3:    verts = [self.branch.parent_pt.verts[3], self.branch.parent_pt.verts[0], self.branch.parent_pt.next.verts[0], self.branch.parent_pt.next.verts[3]]
-                               
-                               
-                       # Watchout for overlapping faces!
-                       self.branch.faces[:] =\
-                               [verts[0], verts[1], self.verts[1], self.verts[0]],\
-                               [verts[1], verts[2], self.verts[2], self.verts[1]],\
-                               [verts[2], verts[3], self.verts[3], self.verts[2]],\
-                               [verts[3], verts[0], self.verts[0], self.verts[3]]
-               
-               # normal join, parents or no parents
-               if not self.children[0]:        self.faces[0] = [self.verts[0], self.verts[1], self.next.verts[1], self.next.verts[0]]
-               if not self.children[1]:        self.faces[1] = [self.verts[1], self.verts[2], self.next.verts[2], self.next.verts[1]]
-               if not self.children[2]:        self.faces[2] = [self.verts[2], self.verts[3], self.next.verts[3], self.next.verts[2]]
-               if not self.children[3]:        self.faces[3] = [self.verts[3], self.verts[0], self.next.verts[0], self.next.verts[3]]
-       
-       def calcVerts(self):
-               if self.prev == None:
-                       if self.branch.parent_pt:
-                               cross = CrossVecs(self.no, self.branch.parent_pt.no) * RotationMatrix(-45, 3, 'r', self.no)
-                       else:
-                               # parentless branch - for best results get a cross thats not the same as the normal, in rare cases this happens.
-                               
-                               # Was just doing 
-                               #  cross = zup
-                               # which works most of the time, but no verticle lines
-                               
-                               if AngleBetweenVecsSafe(self.no, zup) > 1.0:    cross = zup
-                               elif AngleBetweenVecsSafe(self.no, yup) > 1.0:  cross = yup
-                               else:                                                                                   cross = xup
-                               
-               else:
-                       cross = CrossVecs(self.prev.vecs[0], self.no)
-               
-               self.vecs[0] = Blender.Mathutils.CrossVecs(self.no, cross)
-               self.vecs[0].length = abs(self.radius)
-               mat = RotationMatrix(90, 3, 'r', self.no)
-               self.vecs[1] = self.vecs[0] * mat
-               self.vecs[2] = self.vecs[1] * mat
-               self.vecs[3] = self.vecs[2] * mat
-       
-       def hasChildren(self):
-               '''
-               Use .childCount where possible, this does the real check
-               '''
-               if self.children.count(None) == 4:
-                       return False
-               else:
-                       return True
-       
-class branch:
-       def __init__(self):
-               self.bpoints = []
-               self.parent_pt = None
-               self.tag = False # have we calculated our points
-               self.face_cap = None
-               self.length = -1
-               # self.totchildren = 0
-               # Bones per branch
-               self.faces = [None, None, None, None]
-               self.uv = None # face uvs can be fake, always 4
-               self.bones = []
-               self.generation = 0 # use to limit twig reproduction
-               self.twig_count = 0 # count the number of twigs - so as to limit how many twigs a branch gets
-               # self.myindex = -1
-               ### self.segment_spacing_scale = 1.0 # use this to scale up the spacing - so small twigs dont get WAY too many polys
-               self.type = None
-       
-       def __repr__(self):
-               s = ''
-               s += '\tbranch'
-               s += '\tbpoints:', len(self.bpoints)
-               for pt in brch.bpoints:
-                       s += str(self.pt)
-       
-       def getNormal(self):
-               return (self.bpoints[-1].co - self.bpoints[0].co).normalize()
-       
-       def getParentAngle(self):
-               if self.parent_pt:
-                       return AngleBetweenVecsSafe(self.parent_pt.no, self.bpoints[0].no )
-               else:
-                       return 45.0
-       
-       def getParentRadiusRatio(self):
-               if self.parent_pt:
-                       return self.bpoints[0].radius / self.parent_pt.radius
-               else:
-                       return 0.8
-       
-       def getLength(self):
-               return (self.bpoints[0].co - self.bpoints[-1].co).length
-       
-       def getStraightness(self):
-               straight = 0.0
-               pt = self.bpoints[0]
-               while pt.next:
-                       straight += AngleBetweenVecsSafe(pt.no, pt.next.no)
-                       pt = pt.next
-               return straight
-               
-       
-       '''
-       def calcTotChildren(self):
-               for pt in self.bpoints:
-                       self.totchildren += pt.childCount
-       '''
-       def calcData(self):
-               '''
-               Finalize once point data is there
-               '''
-               self.calcPointLinkedList()
-               self.calcPointExtras()
-       
-       def calcPointLinkedList(self):
-               for i in xrange(1, len(self.bpoints)-1):
-                       self.bpoints[i].next = self.bpoints[i+1]
-                       self.bpoints[i].prev = self.bpoints[i-1]
-               
-               self.bpoints[0].next = self.bpoints[1]  
-               self.bpoints[-1].prev = self.bpoints[-2]
-               
-       def calcPointExtras(self):
-               '''
-               Run on a new branch or after transforming an existing one.
-               '''
-               for pt in self.bpoints:
-                       pt.calcNormal()
-                       pt.calcNextMidCo()
-       
-       def calcTwigBounds(self, tree):
-               '''
-               Check if out points are 
-               '''
-               for pt in self.bpoints:
-                       pt.inTwigBounds = tree.isPointInTwigBounds(pt.co)
-                       #if pt.inTwigBounds:
-                       #       debug_pt(pt.co)
-       
-       def baseTrim(self, connect_base_trim):
-               # if 1) dont remove the whole branch, maybe an option but later
-               # if 2) we are alredy a parent, cant remove me now.... darn :/ not nice...
-               #               could do this properly but it would be slower and its a corner case.
-               #
-               # if 3) this point is within the branch, remove it.
-               #               Scale this value by the difference in radius, a low trim looks better when the parent is a lot bigger..
-               # 
-               
-               while   len(self.bpoints)>2 and\
-                               self.bpoints[0].childCount == 0 and\
-                               (self.parent_pt.nextMidCo - self.bpoints[0].co).length < ((self.parent_pt.radius + self.parent_pt.next.radius)/4) + (self.bpoints[0].radius * connect_base_trim):
-                       # Note /4 - is a bit odd, since /2 is correct, but /4 lets us have more tight joints by default
-                       
-                       
-                       del self.bpoints[0]
-                       self.bpoints[0].prev = None
-       
-       def boundsTrim(self):
-               '''
-               depends on calcTwigBounds running first. - also assumes no children assigned yet! make sure this is always the case.
-               '''
-               trim = False
-               for i, pt in enumerate(self.bpoints):
-                       if not pt.inTwigBounds:
-                               trim = True
-                               break
-               
-               # We must have at least 2 points to be a valid branch. this will be a stump :/
-               if not trim or i < 3:
-                       self.bpoints = [] # 
-                       return
-               
-               # Shorten the point list
-               self.bpoints = self.bpoints[:i]
-               self.bpoints[-1].makeLast()
-       
-       def taper(self, twig_ob_bounds_prune_taper = 0.0):
-               l = float(len( self.bpoints ))
-               for i, pt in enumerate(self.bpoints):
-                       pt.radius *= (((l-i)/l) + (twig_ob_bounds_prune_taper*(i/l)) )
-       
-       def getParentBranch(self):
-               if not self.parent_pt:
-                       return None
-               return self.parent_pt.branch
-               
-       def getParentQuadAngle(self):
-               '''
-               The angle off we are from our parent quad,
-               '''
-               # used to roll the parent so its faces us better
-               
-               # Warning this can be zero sometimes, see the try below for the error
-               parent_normal = self.getParentFaceCent() - self.parent_pt.nextMidCo
-               
-               
-               self_normal = self.bpoints[1].co - self.parent_pt.co
-               # We only want the angle in relation to the parent points normal
-               # modify self_normal to make this so
-               cross = CrossVecs(self_normal, self.parent_pt.no)
-               self_normal = CrossVecs(self.parent_pt.no, cross) # CHECK
-               
-               #try:   angle = AngleBetweenVecs(parent_normal, self_normal)
-               #except:        return 0.0
-               angle = AngleBetweenVecsSafe(parent_normal, self_normal)
-               
-               
-               # see if we need to rotate positive or negative
-               # USE DOT PRODUCT!
-               cross = CrossVecs(parent_normal, self_normal)
-               if AngleBetweenVecsSafe(cross, self.parent_pt.no) > 90:
-                       angle = -angle
-               
-               return angle
-       
-       def getParentQuadIndex(self):
-               return self.parent_pt.children.index(self)
-       def getParentFaceCent(self):
-               return self.parent_pt.childPoint(  self.getParentQuadIndex()  )
-       
-       def findClosest(self, co):
-               '''
-               Find the closest point that can bare a child
-               '''
-               
-               
-               ''' # this dosnt work, but could.
-               best = None
-               best_dist = 100000000
-               for pt in self.bpoints: 
-                       if pt.next:
-                               co_on_line, fac = ClosestPointOnLine(co, pt.co, pt.next.co)
-                               print fac
-                               if fac >= 0.0 and fac <= 1.0:
-                                       
-                                       return pt, (co-co_on_line).length
-               
-               return best, best_dist
-               '''
-               best = None
-               best_dist = 100000000
-               for pt in self.bpoints:
-                       if pt.nextMidCo and pt.childCount < 4:
-                               dist = (pt.nextMidCo-co).length
-                               if dist < best_dist:
-                                       best = pt
-                                       best_dist = dist
-               
-               return best, best_dist
-       
-       def inParentChain(self, brch):
-               '''
-               See if this branch is a parent of self or in the chain
-               '''
-               
-               self_parent_lookup = self.getParentBranch()
-               while self_parent_lookup:
-                       if self_parent_lookup == brch:
-                               return True
-                       self_parent_lookup = self_parent_lookup.getParentBranch()
-               
-&