=bmesh=
authorJoseph Eagar <joeedh@gmail.com>
Sat, 7 May 2011 02:48:14 +0000 (02:48 +0000)
committerJoseph Eagar <joeedh@gmail.com>
Sat, 7 May 2011 02:48:14 +0000 (02:48 +0000)
Cut out some unwanted differences with trunk
in preparation for merge.  Also fixed some
warnings, though many remain.

27 files changed:
intern/audaspace/Python/AUD_PyAPI.cpp
source/blender/blenlib/BLI_math_geom.h
source/blender/blenlib/intern/BLI_cellalloc.c
source/blender/blenlib/intern/math_geom.c
source/blender/bmesh/operators/bevel.c
source/blender/collada/CMakeLists.txt
source/blender/collada/DocumentExporter.cpp
source/blender/editors/curve/editcurve.c
source/blender/editors/curve/editfont.c
source/blender/editors/gpencil/drawgpencil.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/include/ED_curve.h
source/blender/editors/interface/interface_style.c
source/blender/editors/mesh/bmesh_select.c
source/blender/editors/mesh/bmesh_tools.c
source/blender/editors/mesh/bmeshutils.c
source/blender/editors/mesh/editbmesh_add.c
source/blender/editors/mesh/editbmesh_bvh.c
source/blender/editors/mesh/mesh_data.c
source/blender/editors/metaball/mball_edit.c
source/blender/editors/screen/screen_edit.c
source/blender/editors/space_view3d/drawarmature.c
source/blender/makesdna/DNA_modifier_types.h
source/blender/makesdna/DNA_object_types.h
source/blender/makesrna/rna_cleanup/rna_properties.txt
source/blender/makesrna/rna_cleanup/rna_update.sh
source/blender/python/generic/mathutils_geometry.c

index 1fccafa259905bf554ab248a80a6bb7c0fdcf21f..22376a2fcd147dd1e78ff2fbedb3bb9f1b1b6c77 100644 (file)
@@ -2214,6 +2214,7 @@ Device_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
                        switch(device)
                        {
                        case AUD_DEVICE_NULL:
+                               (void)specs; /* quiet warning when others disabled */
                                self->device = new AUD_NULLDevice();
                                break;
                        case AUD_DEVICE_OPENAL:
index d6b0aa750f26a6750cdf0cd76a1ca107d2e19eb6..93d9855c355892a2a08264b2710958526ef68f01 100644 (file)
@@ -44,8 +44,8 @@ extern "C" {
 
 /********************************** Polygons *********************************/
 
-void cent_tri_v3(float r[3], float a[3], float b[3], float c[3]);
-void cent_quad_v3(float r[3], float a[3], float b[3], float c[3], float d[3]);
+void cent_tri_v3(float r[3], const float a[3], const float b[3], const float c[3]);
+void cent_quad_v3(float r[3], const float a[3], const float b[3], const float c[3], const float d[3]);
 
 float normal_tri_v3(float r[3], const float a[3], const float b[3], const float c[3]);
 float normal_quad_v3(float r[3], const float a[3], const float b[3], const float c[3], const float d[3]);
@@ -54,24 +54,24 @@ float area_tri_v2(const float a[2], const float b[2], const float c[2]);
 float area_tri_signed_v2(const float v1[2], const float v2[2], const float v3[2]);
 float area_tri_v3(const float a[3], const float b[3], const float c[3]);
 float area_quad_v3(const float a[3], const float b[3], const float c[3], const float d[3]);
-float area_poly_v3(int nr, float verts[][3], float normal[3]);
+float area_poly_v3(int nr, float verts[][3], const float normal[3]);
+
+int is_quad_convex_v3(const float *v1, const float *v2, const float *v3, const float *v4);
 
 /********************************* Distance **********************************/
 
-float dist_to_line_v2(float p[2], float l1[2], float l2[2]);
-float dist_to_line_segment_v2(float p[2], float l1[2], float l2[2]);
+float dist_to_line_v2(const float p[2], const float l1[2], const float l2[2]);
+float dist_to_line_segment_v2(const float p[2], const float l1[2], const float l2[2]);
 
-float dist_to_line_segment_v3(float p[3], float l1[3], float l2[3]);
+float dist_to_line_segment_v3(const float p[3], const float l1[3], const float l2[3]);
 float closest_to_line_v3(float r[3], const float p[3], const float l1[3], const float l2[3]);
 float closest_to_line_v2(float r[2], const float p[2], const float l1[2], const float l2[2]);
-void closest_to_line_segment_v3(float r[3], float p[3], float l1[3], float l2[3]);
+void closest_to_line_segment_v3(float r[3], const float p[3], const float l1[3], const float l2[3]);
 
 /******************************* Intersection ********************************/
 
 /* TODO int return value consistency */
 
- int is_quad_convex_v3(float *v1, float *v2, float *v3, float *v4);
 /* line-line */
 #define ISECT_LINE_LINE_COLINEAR       -1
 #define ISECT_LINE_LINE_NONE            0
@@ -80,7 +80,7 @@ void closest_to_line_segment_v3(float r[3], float p[3], float l1[3], float l2[3]
 
 int isect_line_line_v2(const float a1[2], const float a2[2], const float b1[2], const float b2[2]);
 int isect_line_line_v2_short(const short a1[2], const short a2[2], const short b1[2], const short b2[2]);
-int isect_seg_seg_v2_point(const float *v1, const float *v2, const float *v3, const float *v4, float vi[2]);
+int isect_seg_seg_v2_point(const float v1[2], const float v2[2], const float v3[2], const float v4[2], float vi[2]);
 
 /* Returns the number of point of interests
  * 0 - lines are colinear
@@ -88,57 +88,57 @@ int isect_seg_seg_v2_point(const float *v1, const float *v2, const float *v3, co
  * 2 - i1 and i2 are the nearest points on line 1 (v1, v2) and line 2 (v3, v4) respectively 
  * */
 
-int isect_line_line_v3(float v1[3], float v2[3],
-       float v3[3], float v4[3], float i1[3], float i2[3]);
-int isect_line_line_strict_v3(float v1[3], float v2[3],
-       float v3[3], float v4[3], float vi[3], float *lambda);
+int isect_line_line_v3(const float v1[3], const float v2[3],
+       const float v3[3], const float v4[3], float i1[3], float i2[3]);
+int isect_line_line_strict_v3(const float v1[3], const float v2[3],
+       const float v3[3], const float v4[3], float vi[3], float *lambda);
 
 /* line/ray triangle */
-int isect_line_tri_v3(float p1[3], float p2[3],
-       float v0[3], float v1[3], float v2[3], float *lambda, float *uv);
-int isect_ray_tri_v3(float p1[3], float d[3],
-       float v0[3], float v1[3], float v2[3], float *lambda, float *uv);
-int isect_ray_tri_threshold_v3(float p1[3], float d[3],
-       float v0[3], float v1[3], float v2[3], float *lambda, float *uv, float threshold);
-int isect_ray_tri_epsilon_v3(float p1[3], float d[3],
-       float v0[3], float v1[3], float v2[3], float *lambda, float *uv, float epsilon);
+int isect_line_tri_v3(const float p1[3], const float p2[3],
+       const float v0[3], const float v1[3], const float v2[3], float *lambda, float uv[2]);
+int isect_ray_tri_v3(const float p1[3], const float d[3],
+       const float v0[3], const float v1[3], const float v2[3], float *lambda, float uv[2]);
+int isect_ray_tri_threshold_v3(const float p1[3], const float d[3],
+       const float v0[3], const float v1[3], const float v2[3], float *lambda, float uv[2], const float threshold);
+int isect_ray_tri_epsilon_v3(const float p1[3], const float d[3],
+       const float v0[3], const float v1[3], const float v2[3], float *lambda, float uv[2], const float epsilon);
 
 /* point in polygon */
-int isect_point_quad_v2(float p[2], float a[2], float b[2], float c[2], float d[2]);
+int isect_point_quad_v2(const float p[2], const float a[2], const float b[2], const float c[2], const float d[2]);
 
-int isect_point_tri_v2(float v1[2], float v2[2], float v3[2], float pt[2]);
-int isect_point_tri_v2_int(int x1, int y1, int x2, int y2, int a, int b);
-int isect_point_tri_prism_v3(float p[3], float v1[3], float v2[3], float v3[3]);
+int isect_point_tri_v2(const float v1[2], const float v2[2], const float v3[2], const float pt[2]);
+int isect_point_tri_v2_int(const int x1, const int y1, const int x2, const int y2, const int a, const int b);
+int isect_point_tri_prism_v3(const float p[3], const float v1[3], const float v2[3], const float v3[3]);
 
-void isect_point_quad_uv_v2(float v0[2], float v1[2], float v2[2], float v3[2],
-       float pt[2], float *uv);
-void isect_point_face_uv_v2(int isquad, float v0[2], float v1[2], float v2[2],
-       float v3[2], float pt[2], float *uv);
+void isect_point_quad_uv_v2(const float v0[2], const float v1[2], const float v2[2], const float v3[2],
+       const float pt[2], float *uv);
+void isect_point_face_uv_v2(const int isquad, const float v0[2], const float v1[2], const float v2[2],
+       const float v3[2], const float pt[2], float *uv);
 
 /* other */
-int isect_sweeping_sphere_tri_v3(float p1[3], float p2[3], float radius,
-       float v0[3], float v1[3], float v2[3], float *lambda, float *ipoint);
+int isect_sweeping_sphere_tri_v3(const float p1[3], const float p2[3], const float radius,
+       const float v0[3], const float v1[3], const float v2[3], float *lambda, float ipoint[3]);
 
-int isect_axial_line_tri_v3(int axis, float co1[3], float co2[3],
-       float v0[3], float v1[3], float v2[3], float *lambda);
+int isect_axial_line_tri_v3(const int axis, const float co1[3], const float co2[3],
+       const float v0[3], const float v1[3], const float v2[3], float *lambda);
 
-int isect_aabb_aabb_v3(float min1[3], float max1[3], float min2[3], float max2[3]);
+int isect_aabb_aabb_v3(const float min1[3], const float max1[3], const float min2[3], const float max2[3]);
 
-int clip_line_plane(float clipco[3], float plane[4], float co[3]);
+int clip_line_plane(float p1[3], float p2[3], const float plane[4]);
 
-void plot_line_v2v2i(int p1[2], int p2[2], int (*callback)(int, int, void *), void *userData);
+void plot_line_v2v2i(const int p1[2], const int p2[2], int (*callback)(int, int, void *), void *userData);
 
 /****************************** Interpolation ********************************/
 
 /* tri or quad, d can be NULL */
 void interp_weights_face_v3(float w[4],
-       float a[3], float b[3], float c[3], float d[3], float p[3]);
-void interp_weights_poly_v3(float w[], float v[][3], int n, float p[3]);
+       const float a[3], const float b[3], const float c[3], const float d[3], const float p[3]);
+void interp_weights_poly_v3(float w[], float v[][3], const int n, const float p[3]);
 
 void interp_cubic_v3(float x[3], float v[3],
-       float x1[3], float v1[3], float x2[3], float v2[3], float t);
+       const float x1[3], const float v1[3], const float x2[3], const float v2[3], const float t);
 
-int interp_sparse_array(float *array, int list_size, float invalid);
+int interp_sparse_array(float *array, const int list_size, const float invalid);
 
 void barycentric_transform(float pt_tar[3], float const pt_src[3],
        const float tri_tar_p1[3], const float tri_tar_p2[3], const float tri_tar_p3[3],
@@ -154,22 +154,22 @@ void lookat_m4(float mat[4][4], float vx, float vy,
 void polarview_m4(float mat[4][4], float dist, float azimuth,
        float incidence, float twist);
 
-void perspective_m4(float mat[4][4], float left, float right,
-       float bottom, float top, float nearClip, float farClip);
-void orthographic_m4(float mat[4][4], float left, float right,
-       float bottom, float top, float nearClip, float farClip);
+void perspective_m4(float mat[4][4], const float left, const float right,
+       const float bottom, const float top, const float nearClip, const float farClip);
+void orthographic_m4(float mat[4][4], const float left, const float right,
+       const float bottom, const float top, const float nearClip, const float farClip);
 void window_translate_m4(float winmat[][4], float perspmat[][4],
-       float x, float y);
+       const float x, const float y);
 
 int box_clip_bounds_m4(float boundbox[2][3],
-       float bounds[4], float winmat[4][4]);
+       const float bounds[4], float winmat[4][4]);
 void box_minmax_bounds_m4(float min[3], float max[3],
        float boundbox[2][3], float mat[4][4]);
 
 /********************************** Mapping **********************************/
 
-void map_to_tube(float *u, float *v, float x, float y, float z);
-void map_to_sphere(float *u, float *v, float x, float y, float z);
+void map_to_tube(float *u, float *v, const float x, const float y, const float z);
+void map_to_sphere(float *u, float *v, const float x, const float y, const float z);
 
 /********************************** Normals **********************************/
 
@@ -184,11 +184,11 @@ typedef struct VertexTangent {
        float tang[3], uv[2];
 } VertexTangent;
 
-float *find_vertex_tangent(VertexTangent *vtang, float *uv);
+float *find_vertex_tangent(VertexTangent *vtang, const float uv[2]);
 void sum_or_add_vertex_tangent(void *arena, VertexTangent **vtang,
-       float *tang, float *uv);
-void tangent_from_uv(float *uv1, float *uv2, float *uv3,
-       float *co1, float *co2, float *co3, float *n, float *tang);
+       const float tang[3], const float uv[2]);
+void tangent_from_uv(float uv1[2], float uv2[2], float uv3[2],
+       float co1[3], float co2[3], float co3[3], float n[3], float tang[3]);
 
 /******************************** Vector Clouds ******************************/
 
@@ -202,16 +202,17 @@ void vcloud_estimate_transform(int list_size, float (*pos)[3], float *weight,
    0 = (0,0),
    1 = (1,-1), 2 = (1,0), 3 = (1,1),
    4 = (2,-2), 5 = (2,-1), 6 = (2,0), 7 = (2,1), 8 = (2,2) */
-
+/*
 MINLINE void zero_sh(float r[9]);
-MINLINE void copy_sh_sh(float r[9], float a[9]);
-MINLINE void mul_sh_fl(float r[9], float f);
-MINLINE void add_sh_shsh(float r[9], float a[9], float b[9]);
-
-MINLINE float eval_shv3(float r[9], float v[3]);
-MINLINE float diffuse_shv3(float r[9], float v[3]);
-MINLINE void vec_fac_to_sh(float r[9], float v[3], float f);
-MINLINE void madd_sh_shfl(float r[9], float sh[3], float f);
+MINLINE void copy_sh_sh(float r[9], const float a[9]);
+MINLINE void mul_sh_fl(float r[9], const float f);
+MINLINE void add_sh_shsh(float r[9], const float a[9], const float b[9]);
+
+MINLINE float eval_shv3(float r[9], const float v[3]);
+MINLINE float diffuse_shv3(float r[9], const float v[3]);
+MINLINE void vec_fac_to_sh(float r[9], const float v[3], const float f);
+MINLINE void madd_sh_shfl(float r[9], const float sh[3], const float f);
+*/
 
 /********************************* Form Factor *******************************/
 
index 88236a78ffcf65d8ae322c1845202997f7c2598a..88344e26464c4a7e56df3cd07359ea05ddd136fa 100644 (file)
@@ -30,7 +30,7 @@
        Simple, fast memory allocator that uses many BLI_mempools for allocation.
        this is meant to be used by lots of relatively small objects.
 
-       this is a temporary and inperfect fix for performance issues caused
+       this is a temporary and imperfect fix for performance issues caused
        by vgroups.  it needs to be replaced with something better, preferably
        integrated into guardedalloc.
        
index 3077a00166c9f046095e7260bb7a9764a58b95a6..71f12d23d53adb7eae53c95a0f2588edb5a75c6a 100644 (file)
 
 /********************************** Polygons *********************************/
 
-void cent_tri_v3(float *cent, float *v1, float *v2, float *v3)
+void cent_tri_v3(float cent[3], const float v1[3], const float v2[3], const float v3[3])
 {
        cent[0]= 0.33333f*(v1[0]+v2[0]+v3[0]);
        cent[1]= 0.33333f*(v1[1]+v2[1]+v3[1]);
        cent[2]= 0.33333f*(v1[2]+v2[2]+v3[2]);
 }
 
-void cent_quad_v3(float *cent, float *v1, float *v2, float *v3, float *v4)
+void cent_quad_v3(float cent[3], const float v1[3], const float v2[3], const float v3[3], const float v4[3])
 {
        cent[0]= 0.25f*(v1[0]+v2[0]+v3[0]+v4[0]);
        cent[1]= 0.25f*(v1[1]+v2[1]+v3[1]+v4[1]);
@@ -99,7 +99,7 @@ float area_tri_v2(const float v1[2], const float v2[2], const float v3[2])
 
 float area_tri_signed_v2(const float v1[2], const float v2[2], const float v3[2])
 {
-   return 0.5f * ((v1[0]-v2[0])*(v2[1]-v3[1]) + (v1[1]-v2[1])*(v3[0]-v2[0]));
+       return 0.5f * ((v1[0]-v2[0])*(v2[1]-v3[1]) + (v1[1]-v2[1])*(v3[0]-v2[0]));
 }
 
 float area_quad_v3(const float v1[3], const float v2[3], const float v3[3], const float v4[3])  /* only convex Quadrilaterals */
@@ -131,7 +131,7 @@ float area_tri_v3(const float v1[3], const float v2[3], const float v3[3])  /* T
        return (len/2.0f);
 }
 
-float area_poly_v3(int nr, float verts[][3], float *normal)
+float area_poly_v3(int nr, float verts[][3], const float normal[3])
 {
        float x, y, z, area, max;
        float *cur, *prev;
@@ -165,7 +165,7 @@ float area_poly_v3(int nr, float verts[][3], float *normal)
 
 /* distance v1 to line v2-v3 */
 /* using Hesse formula, NO LINE PIECE! */
-float dist_to_line_v2(float *v1, float *v2, float *v3)
+float dist_to_line_v2(const float v1[2], const float v2[2], const float v3[2])
 {
        float a[2],deler;
 
@@ -179,7 +179,7 @@ float dist_to_line_v2(float *v1, float *v2, float *v3)
 }
 
 /* distance v1 to line-piece v2-v3 */
-float dist_to_line_segment_v2(float *v1, float *v2, float *v3) 
+float dist_to_line_segment_v2(const float v1[2], const float v2[2], const float v3[2])
 {
        float labda, rc[2], pt[2], len;
        
@@ -208,11 +208,11 @@ float dist_to_line_segment_v2(float *v1, float *v2, float *v3)
 
        rc[0]= pt[0]-v1[0];
        rc[1]= pt[1]-v1[1];
-       return (float)sqrt(rc[0]*rc[0]+ rc[1]*rc[1]);
+       return sqrtf(rc[0]*rc[0]+ rc[1]*rc[1]);
 }
 
 /* point closest to v1 on line v2-v3 in 3D */
-void closest_to_line_segment_v3(float *closest, float v1[3], float v2[3], float v3[3])
+void closest_to_line_segment_v3(float closest[3], const float v1[3], const float v2[3], const float v3[3])
 {
        float lambda, cp[3];
 
@@ -227,7 +227,7 @@ void closest_to_line_segment_v3(float *closest, float v1[3], float v2[3], float
 }
 
 /* distance v1 to line-piece v2-v3 in 3D */
-float dist_to_line_segment_v3(float *v1, float *v2, float *v3) 
+float dist_to_line_segment_v3(const float v1[3], const float v2[3], const float v3[3])
 {
        float closest[3];
 
@@ -239,7 +239,7 @@ float dist_to_line_segment_v3(float *v1, float *v2, float *v3)
 /******************************* Intersection ********************************/
 
 /* intersect Line-Line, shorts */
-int isect_line_line_v2_short(const short *v1, const short *v2, const short *v3, const short *v4)
+int isect_line_line_v2_short(const short v1[2], const short v2[2], const short v3[2], const short v4[2])
 {
        float div, labda, mu;
        
@@ -258,7 +258,7 @@ int isect_line_line_v2_short(const short *v1, const short *v2, const short *v3,
 }
 
 /* intersect Line-Line, floats */
-int isect_line_line_v2(const float *v1, const float *v2, const float *v3, const float *v4)
+int isect_line_line_v2(const float v1[2], const float v2[2], const float v3[2], const float v4[2])
 {
        float div, labda, mu;
        
@@ -277,9 +277,9 @@ int isect_line_line_v2(const float *v1, const float *v2, const float *v3, const
 }
 
 /* get intersection point of two 2D segments and return intersection type:
-    -1: colliniar or out-of-segment intersection
+    -1: colliniar
      1: intersection */
-int isect_seg_seg_v2_point(const float *v1, const float *v2, const float *v3, const float *v4, float vi[2])
+int isect_seg_seg_v2_point(const float v1[2], const float v2[2], const float v3[2], const float v4[2], float vi[2])
 {
        float a1, a2, b1, b2, c1, c2, d;
        float u, v;
@@ -354,8 +354,8 @@ int isect_seg_seg_v2_point(const float *v1, const float *v2, const float *v3, co
  1: intersection
 
 */
-static short IsectLLPt2Df(float x0,float y0,float x1,float y1,
-                                        float x2,float y2,float x3,float y3, float *xi,float *yi)
+static short IsectLLPt2Df(const float x0, const float y0, const float x1, const float y1,
+                                        const float x2, const float y2, const float x3, const float y3, float *xi,float *yi)
 
 {
        /*
@@ -405,7 +405,7 @@ static short IsectLLPt2Df(float x0,float y0,float x1,float y1,
 
 /* point in tri */
 
-int isect_point_tri_v2(float pt[2], float v1[2], float v2[2], float v3[2])
+int isect_point_tri_v2(const float pt[2], const float v1[2], const float v2[2], const float v3[2])
 {
        if (line_point_side_v2(v1,v2,pt)>=0.0f) {
                if (line_point_side_v2(v2,v3,pt)>=0.0f) {
@@ -424,7 +424,7 @@ int isect_point_tri_v2(float pt[2], float v1[2], float v2[2], float v3[2])
        return 0;
 }
 /* point in quad - only convex quads */
-int isect_point_quad_v2(float pt[2], float v1[2], float v2[2], float v3[2], float v4[2])
+int isect_point_quad_v2(const float pt[2], const float v1[2], const float v2[2], const float v3[2], const float v4[2])
 {
        if (line_point_side_v2(v1,v2,pt)>=0.0f) {
                if (line_point_side_v2(v2,v3,pt)>=0.0f) {
@@ -451,7 +451,7 @@ int isect_point_quad_v2(float pt[2], float v1[2], float v2[2], float v3[2], floa
    test if the line starting at p1 ending at p2 intersects the triangle v0..v2
    return non zero if it does 
 */
-int isect_line_tri_v3(float p1[3], float p2[3], float v0[3], float v1[3], float v2[3], float *lambda, float *uv)
+int isect_line_tri_v3(const float p1[3], const float p2[3], const float v0[3], const float v1[3], const float v2[3], float *lambda, float uv[2])
 {
 
        float p[3], s[3], d[3], e1[3], e2[3], q[3];
@@ -473,7 +473,7 @@ int isect_line_tri_v3(float p1[3], float p2[3], float v0[3], float v1[3], float
        
        cross_v3_v3v3(q, s, e1);
        
-        v = f * dot_v3v3(d, q);
+       v = f * dot_v3v3(d, q);
        if ((v < 0.0f)||((u + v) > 1.0f)) return 0;
 
        *lambda = f * dot_v3v3(e2, q);
@@ -491,7 +491,7 @@ int isect_line_tri_v3(float p1[3], float p2[3], float v0[3], float v1[3], float
    test if the ray starting at p1 going in d direction intersects the triangle v0..v2
    return non zero if it does 
 */
-int isect_ray_tri_v3(float p1[3], float d[3], float v0[3], float v1[3], float v2[3], float *lambda, float *uv)
+int isect_ray_tri_v3(const float p1[3], const float d[3], const float v0[3], const float v1[3], const float v2[3], float *lambda, float uv[2])
 {
        float p[3], s[3], e1[3], e2[3], q[3];
        float a, f, u, v;
@@ -519,7 +519,7 @@ int isect_ray_tri_v3(float p1[3], float d[3], float v0[3], float v1[3], float v2
        *lambda = f * dot_v3v3(e2, q);
        if ((*lambda < 0.0f)) return 0;
 
-        if(uv) {
+       if(uv) {
                uv[0]= u;
                uv[1]= v;
        }
@@ -527,41 +527,41 @@ int isect_ray_tri_v3(float p1[3], float d[3], float v0[3], float v1[3], float v2
        return 1;
 }
 
-int isect_ray_tri_epsilon_v3(float p1[3], float d[3], float v0[3], float v1[3], float v2[3], float *lambda, float *uv, float epsilon)
+int isect_ray_tri_epsilon_v3(const float p1[3], const float d[3], const float v0[3], const float v1[3], const float v2[3], float *lambda, float uv[2], const float epsilon)
 {
-    float p[3], s[3], e1[3], e2[3], q[3];
-    float a, f, u, v;
+       float p[3], s[3], e1[3], e2[3], q[3];
+       float a, f, u, v;
 
-    sub_v3_v3v3(e1, v1, v0);
-    sub_v3_v3v3(e2, v2, v0);
+       sub_v3_v3v3(e1, v1, v0);
+       sub_v3_v3v3(e2, v2, v0);
 
-    cross_v3_v3v3(p, d, e2);
-    a = dot_v3v3(e1, p);
-    if (a == 0.0f) return 0;
-    f = 1.0f/a;
+       cross_v3_v3v3(p, d, e2);
+       a = dot_v3v3(e1, p);
+       if (a == 0.0f) return 0;
+       f = 1.0f/a;
 
-    sub_v3_v3v3(s, p1, v0);
+       sub_v3_v3v3(s, p1, v0);
 
-    u = f * dot_v3v3(s, p);
-    if ((u < -epsilon)||(u > 1.0f+epsilon)) return 0;
+       u = f * dot_v3v3(s, p);
+       if ((u < -epsilon)||(u > 1.0f+epsilon)) return 0;
 
-    cross_v3_v3v3(q, s, e1);
+       cross_v3_v3v3(q, s, e1);
 
-    v = f * dot_v3v3(d, q);
-    if ((v < -epsilon)||((u + v) > 1.0f+epsilon)) return 0;
+       v = f * dot_v3v3(d, q);
+       if ((v < -epsilon)||((u + v) > 1.0f+epsilon)) return 0;
 
-    *lambda = f * dot_v3v3(e2, q);
-    if ((*lambda < 0.0f)) return 0;
+       *lambda = f * dot_v3v3(e2, q);
+       if ((*lambda < 0.0f)) return 0;
 
-    if(uv) {
-        uv[0]= u;
-        uv[1]= v;
-    }
+       if(uv) {
+               uv[0]= u;
+               uv[1]= v;
+       }
 
-    return 1;
+       return 1;
 }
 
-int isect_ray_tri_threshold_v3(float p1[3], float d[3], float v0[3], float v1[3], float v2[3], float *lambda, float *uv, float threshold)
+int isect_ray_tri_threshold_v3(const float p1[3], const float d[3], const float v0[3], const float v1[3], const float v2[3], float *lambda, float *uv, const float threshold)
 {
        float p[3], s[3], e1[3], e2[3], q[3];
        float a, f, u, v;
@@ -614,7 +614,7 @@ int isect_ray_tri_threshold_v3(float p1[3], float d[3], float v0[3], float v1[3]
 
 /* Adapted from the paper by Kasper Fauerby */
 /* "Improved Collision detection and Response" */
-static int getLowestRoot(float a, float b, float c, float maxR, float* root)
+static int getLowestRoot(const float a, const float b, const float c, const float maxR, float *root)
 {
        // Check if a solution exists
        float determinant = b*b - 4.0f*a*c;
@@ -651,7 +651,7 @@ static int getLowestRoot(float a, float b, float c, float maxR, float* root)
        return 0;
 }
 
-int isect_sweeping_sphere_tri_v3(float p1[3], float p2[3], float radius, float v0[3], float v1[3], float v2[3], float *lambda, float *ipoint)
+int isect_sweeping_sphere_tri_v3(const float p1[3], const float p2[3], const float radius, const float v0[3], const float v1[3], const float v2[3], float *lambda, float ipoint[3])
 {
        float e1[3], e2[3], e3[3], point[3], vel[3], /*dist[3],*/ nor[3], temp[3], bv[3];
        float a, b, c, d, e, x, y, z, radius2=radius*radius;
@@ -848,7 +848,7 @@ int isect_sweeping_sphere_tri_v3(float p1[3], float p2[3], float radius, float v
 
        return found_by_sweep;
 }
-int isect_axial_line_tri_v3(int axis, float p1[3], float p2[3], float v0[3], float v1[3], float v2[3], float *lambda)
+int isect_axial_line_tri_v3(const int axis, const float p1[3], const float p2[3], const float v0[3], const float v1[3], const float v2[3], float *lambda)
 {
        float p[3], e1[3], e2[3];
        float u, v, f;
@@ -897,7 +897,7 @@ int isect_axial_line_tri_v3(int axis, float p1[3], float p2[3], float v0[3], flo
  * 1 - lines are coplanar, i1 is set to intersection
  * 2 - i1 and i2 are the nearest points on line 1 (v1, v2) and line 2 (v3, v4) respectively 
  * */
-int isect_line_line_v3(float v1[3], float v2[3], float v3[3], float v4[3], float i1[3], float i2[3])
+int isect_line_line_v3(const float v1[3], const float v2[3], const float v3[3], const float v4[3], float i1[3], float i2[3])
 {
        float a[3], b[3], c[3], ab[3], cb[3], dir1[3], dir2[3];
        float d;
@@ -909,7 +909,7 @@ int isect_line_line_v3(float v1[3], float v2[3], float v3[3], float v4[3], float
        normalize_v3_v3(dir1, a);
        normalize_v3_v3(dir2, b);
        d = dot_v3v3(dir1, dir2);
-       if (d >= 1.0-FLT_EPSILON*10 || d <= -1.0 + FLT_EPSILON*10) {
+       if (d == 1.0f || d == -1.0f) {
                /* colinear */
                return 0;
        }
@@ -961,7 +961,7 @@ int isect_line_line_v3(float v1[3], float v2[3], float v3[3], float v4[3], float
 /* Intersection point strictly between the two lines
  * 0 when no intersection is found 
  * */
-int isect_line_line_strict_v3(float v1[3], float v2[3], float v3[3], float v4[3], float vi[3], float *lambda)
+int isect_line_line_strict_v3(const float v1[3], const float v2[3], const float v3[3], const float v4[3], float vi[3], float *lambda)
 {
        float a[3], b[3], c[3], ab[3], cb[3], ca[3], dir1[3], dir2[3];
        float d;
@@ -1014,7 +1014,7 @@ int isect_line_line_strict_v3(float v1[3], float v2[3], float v3[3], float v4[3]
        }
 } 
 
-int isect_aabb_aabb_v3(float min1[3], float max1[3], float min2[3], float max2[3])
+int isect_aabb_aabb_v3(const float min1[3], const float max1[3], const float min2[3], const float max2[3])
 {
        return (min1[0]<max2[0] && min1[1]<max2[1] && min1[2]<max2[2] &&
                        min2[0]<max1[0] && min2[1]<max1[1] && min2[2]<max1[2]);
@@ -1058,7 +1058,7 @@ static float lambda_cp_line(float p[3], float l1[3], float l2[3])
 #endif
 
 /* Similar to LineIntersectsTriangleUV, except it operates on a quad and in 2d, assumes point is in quad */
-void isect_point_quad_uv_v2(float v0[2], float v1[2], float v2[2], float v3[2], float pt[2], float *uv)
+void isect_point_quad_uv_v2(const float v0[2], const float v1[2], const float v2[2], const float v3[2], const float pt[2], float *uv)
 {
        float x0,y0, x1,y1, wtot, v2d[2], w1, w2;
        
@@ -1152,7 +1152,7 @@ void isect_point_quad_uv_v2(float v0[2], float v1[2], float v2[2], float v3[2],
 }
 
 /* same as above but does tri's and quads, tri's are a bit of a hack */
-void isect_point_face_uv_v2(int isquad, float v0[2], float v1[2], float v2[2], float v3[2], float pt[2], float *uv)
+void isect_point_face_uv_v2(const int isquad, const float v0[2], const float v1[2], const float v2[2], const float v3[2], const float pt[2], float *uv)
 {
        if (isquad) {
                isect_point_quad_uv_v2(v0, v1, v2, v3, pt, uv);
@@ -1238,7 +1238,7 @@ int isect_point_tri_v2(float v0[2], float v1[2], float v2[2], float pt[2])
        x1,y1-- x2,y1
 
 */
-int isect_point_tri_v2_int(int x1, int y1, int x2, int y2, int a, int b)
+int isect_point_tri_v2_int(const int x1, const int y1, const int x2, const int y2, const int a, const int b)
 {
        float v1[2], v2[2], v3[2], p[2];
        
@@ -1257,7 +1257,7 @@ int isect_point_tri_v2_int(int x1, int y1, int x2, int y2, int a, int b)
        return isect_point_tri_v2(p, v1, v2, v3);
 }
 
-static int point_in_slice(float p[3], float v1[3], float l1[3], float l2[3])
+static int point_in_slice(const float p[3], const float v1[3], const float l1[3], const float l2[3])
 {
 /* 
 what is a slice ?
@@ -1305,7 +1305,7 @@ static int point_in_slice_m(float p[3],float origin[3],float normal[3],float lns
 }
 #endif
 
-int isect_point_tri_prism_v3(float p[3], float v1[3], float v2[3], float v3[3])
+int isect_point_tri_prism_v3(const float p[3], const float v1[3], const float v2[3], const float v3[3])
 {
        if(!point_in_slice(p,v1,v2,v3)) return 0;
        if(!point_in_slice(p,v2,v3,v1)) return 0;
@@ -1313,7 +1313,7 @@ int isect_point_tri_prism_v3(float p[3], float v1[3], float v2[3], float v3[3])
        return 1;
 }
 
-int clip_line_plane(float p1[3], float p2[3], float plane[4])
+int clip_line_plane(float p1[3], float p2[3], const float plane[4])
 {
        float dp[3], n[3], div, t, pc[3];
 
@@ -1363,7 +1363,7 @@ int clip_line_plane(float p1[3], float p2[3], float plane[4])
 }
 
 
-void plot_line_v2v2i(int p1[2], int p2[2], int (*callback)(int, int, void *), void *userData)
+void plot_line_v2v2i(const int p1[2], const int p2[2], int (*callback)(int, int, void *), void *userData)
 {
        int x1= p1[0];
        int y1= p1[1];
@@ -1429,12 +1429,12 @@ void plot_line_v2v2i(int p1[2], int p2[2], int (*callback)(int, int, void *), vo
 
 /****************************** Interpolation ********************************/
 
-static float tri_signed_area(float *v1, float *v2, float *v3, int i, int j)
+static float tri_signed_area(const float v1[3], const float v2[3], const float v3[3], const int i, const int j)
 {
        return 0.5f*((v1[i]-v2[i])*(v2[j]-v3[j]) + (v1[j]-v2[j])*(v3[i]-v2[i]));
 }
 
-static int barycentric_weights(float *v1, float *v2, float *v3, float *co, float *n, float *w)
+static int barycentric_weights(const float v1[3], const float v2[3], const float v3[3], const float co[3], const float n[3], float w[3])
 {
        float xn, yn, zn, a1, a2, a3, asum;
        short i, j;
@@ -1468,7 +1468,7 @@ static int barycentric_weights(float *v1, float *v2, float *v3, float *co, float
        return 0;
 }
 
-void interp_weights_face_v3(float *w,float *v1, float *v2, float *v3, float *v4, float *co)
+void interp_weights_face_v3(float w[4], const float v1[3], const float v2[3], const float v3[3], const float v4[3], const float co[3])
 {
        float w2[3];
 
@@ -1524,22 +1524,22 @@ void interp_weights_face_v3(float *w,float *v1, float *v2, float *v3, float *v4,
  * note: using area_tri_signed_v2 means locations outside the triangle are correctly weighted */
 void barycentric_weights_v2(const float v1[2], const float v2[2], const float v3[2], const float co[2], float w[3])
 {
-   float wtot_inv, wtot;
+       float wtot_inv, wtot;
 
-   w[0] = area_tri_signed_v2(v2, v3, co);
-   w[1] = area_tri_signed_v2(v3, v1, co);
-   w[2] = area_tri_signed_v2(v1, v2, co);
-   wtot = w[0]+w[1]+w[2];
+       w[0] = area_tri_signed_v2(v2, v3, co);
+       w[1] = area_tri_signed_v2(v3, v1, co);
+       w[2] = area_tri_signed_v2(v1, v2, co);
+       wtot = w[0]+w[1]+w[2];
 
-   if (wtot != 0.0f) {
-          wtot_inv = 1.0f/wtot;
+       if (wtot != 0.0f) {
+               wtot_inv = 1.0f/wtot;
 
-          w[0] = w[0]*wtot_inv;
-          w[1] = w[1]*wtot_inv;
-          w[2] = w[2]*wtot_inv;
-   }
-   else /* dummy values for zero area face */
-          w[0] = w[1] = w[2] = 1.0f/3.0f;
+               w[0] = w[0]*wtot_inv;
+               w[1] = w[1]*wtot_inv;
+               w[2] = w[2]*wtot_inv;
+       }
+       else /* dummy values for zero area face */
+               w[0] = w[1] = w[2] = 1.0f/3.0f;
 }
 
 /* given 2 triangles in 3D space, and a point in relation to the first triangle.
@@ -1592,7 +1592,7 @@ void barycentric_transform(float pt_tar[3], float const pt_src[3],
 
 /* given an array with some invalid values this function interpolates valid values
  * replacing the invalid ones */
-int interp_sparse_array(float *array, int list_size, float skipval)
+int interp_sparse_array(float *array, int const list_size, const float skipval)
 {
        int found_invalid = 0;
        int found_valid = 0;
@@ -1672,7 +1672,7 @@ int interp_sparse_array(float *array, int list_size, float skipval)
 
 /* Mean value weights - smooth interpolation weights for polygons with
  * more than 3 vertices */
-static float mean_value_half_tan(float *v1, float *v2, float *v3)
+static float mean_value_half_tan(const float v1[3], const float v2[3], const float v3[3])
 {
        float d2[3], d3[3], cross[3], area, dot, len;
 
@@ -1690,7 +1690,7 @@ static float mean_value_half_tan(float *v1, float *v2, float *v3)
                return (len - dot)/area;
 }
 
-void interp_weights_poly_v3(float *w,float v[][3], int n, float *co)
+void interp_weights_poly_v3(float *w, float v[][3], const int n, const float co[3])
 {
        float totweight, t1, t2, len, *vmid, *vprev, *vnext;
        int i;
@@ -1706,7 +1706,7 @@ void interp_weights_poly_v3(float *w,float v[][3], int n, float *co)
                t2= mean_value_half_tan(co, vmid, vnext);
 
                len= len_v3v3(co, vmid);
-               w[i]= (t1+t2)/(len+FLT_EPSILON*2);
+               w[i]= (t1+t2)/len;
                totweight += w[i];
        }
 
@@ -1716,7 +1716,7 @@ void interp_weights_poly_v3(float *w,float v[][3], int n, float *co)
 }
 
 /* (x1,v1)(t1=0)------(x2,v2)(t2=1), 0<t<1 --> (x,v)(t) */
-void interp_cubic_v3(float *x, float *v,float *x1, float *v1, float *x2, float *v2, float t)
+void interp_cubic_v3(float x[3], float v[3], const float x1[3], const float v1[3], const float x2[3], const float v2[3], const float t)
 {
        float a[3],b[3];
        float t2= t*t;
@@ -1742,7 +1742,7 @@ void interp_cubic_v3(float *x, float *v,float *x1, float *v1, float *x2, float *
 
 /***************************** View & Projection *****************************/
 
-void orthographic_m4(float matrix[][4],float left, float right, float bottom, float top, float nearClip, float farClip)
+void orthographic_m4(float matrix[][4], const float left, const float right, const float bottom, const float top, const float nearClip, const float farClip)
 {
        float Xdelta, Ydelta, Zdelta;
  
@@ -1761,7 +1761,7 @@ void orthographic_m4(float matrix[][4],float left, float right, float bottom, fl
        matrix[3][2] = -(farClip + nearClip)/Zdelta;
 }
 
-void perspective_m4(float mat[][4],float left, float right, float bottom, float top, float nearClip, float farClip)
+void perspective_m4(float mat[][4],float left, const float right, const float bottom, const float top, const float nearClip, const float farClip)
 {
        float Xdelta, Ydelta, Zdelta;
 
@@ -1786,7 +1786,7 @@ void perspective_m4(float mat[][4],float left, float right, float bottom, float
 }
 
 /* translate a matrix created by orthographic_m4 or perspective_m4 in XY coords (used to jitter the view) */
-void window_translate_m4(float winmat[][4], float perspmat[][4], float x, float y)
+void window_translate_m4(float winmat[][4], float perspmat[][4], const float x, const float y)
 {
        if(winmat[2][3] == -1.0f) {
                /* in the case of a win-matrix, this means perspective always */
@@ -1890,7 +1890,7 @@ void lookat_m4(float mat[][4],float vx, float vy, float vz, float px, float py,
        translate_m4(mat,-vx,-vy,-vz);  /* translate viewpoint to origin */
 }
 
-int box_clip_bounds_m4(float boundbox[2][3], float bounds[4], float winmat[4][4])
+int box_clip_bounds_m4(float boundbox[2][3], const float bounds[4], float winmat[4][4])
 {
        float mat[4][4], vec[4];
        int a, fl, flag= -1;
@@ -1950,7 +1950,7 @@ void box_minmax_bounds_m4(float min[3], float max[3], float boundbox[2][3], floa
 
 /********************************** Mapping **********************************/
 
-void map_to_tube(float *u, float *v,float x, float y, float z)
+void map_to_tube(float *u, float *v, const float x, const float y, const float z)
 {
        float len;
        
@@ -1963,7 +1963,7 @@ void map_to_tube(float *u, float *v,float x, float y, float z)
                *v = *u = 0.0f; /* to avoid un-initialized variables */
 }
 
-void map_to_sphere(float *u, float *v,float x, float y, float z)
+void map_to_sphere(float *u, float *v, const float x, const float y, const float z)
 {
        float len;
        
@@ -1971,9 +1971,8 @@ void map_to_sphere(float *u, float *v,float x, float y, float z)
        if(len > 0.0f) {
                if(x==0.0f && y==0.0f) *u= 0.0f;        /* othwise domain error */
                else *u = (1.0f - atan2f(x,y) / (float)M_PI) / 2.0f;
-               
-               z/=len;
-               *v = 1.0f - (float)saacos(z)/(float)M_PI;
+
+               *v = 1.0f - (float)saacos(z/len)/(float)M_PI;
        } else {
                *v = *u = 0.0f; /* to avoid un-initialized variables */
        }
@@ -2033,7 +2032,7 @@ void accumulate_vertex_normals(float n1[3], float n2[3], float n3[3],
 /* from BKE_mesh.h */
 #define STD_UV_CONNECT_LIMIT   0.0001f
 
-void sum_or_add_vertex_tangent(void *arena, VertexTangent **vtang, float *tang, float *uv)
+void sum_or_add_vertex_tangent(void *arena, VertexTangent **vtang, const float tang[3], const float uv[2])
 {
        VertexTangent *vt;
 
@@ -2056,7 +2055,7 @@ void sum_or_add_vertex_tangent(void *arena, VertexTangent **vtang, float *tang,
        *vtang= vt;
 }
 
-float *find_vertex_tangent(VertexTangent *vtang, float *uv)
+float *find_vertex_tangent(VertexTangent *vtang, const float uv[2])
 {
        VertexTangent *vt;
        static float nulltang[3] = {0.0f, 0.0f, 0.0f};
@@ -2068,7 +2067,7 @@ float *find_vertex_tangent(VertexTangent *vtang, float *uv)
        return nulltang;        /* shouldn't happen, except for nan or so */
 }
 
-void tangent_from_uv(float *uv1, float *uv2, float *uv3, float *co1, float *co2, float *co3, float *n, float *tang)
+void tangent_from_uv(float uv1[2], float uv2[2], float uv3[3], float co1[3], float co2[3], float co3[3], float n[3], float tang[3])
 {
        float s1= uv2[0] - uv1[0];
        float s2= uv3[0] - uv1[0];
@@ -2262,14 +2261,14 @@ void vcloud_estimate_transform(int list_size, float (*pos)[3], float *weight,flo
 
 /******************************* Form Factor *********************************/
 
-static void vec_add_dir(float r[3], float v1[3], float v2[3], float fac)
+static void vec_add_dir(float r[3], const float v1[3], const float v2[3], const float fac)
 {
        r[0]= v1[0] + fac*(v2[0] - v1[0]);
        r[1]= v1[1] + fac*(v2[1] - v1[1]);
        r[2]= v1[2] + fac*(v2[2] - v1[2]);
 }
 
-static int ff_visible_quad(float p[3], float n[3], float v0[3], float v1[3], float v2[3], float q0[3], float q1[3], float q2[3], float q3[3])
+static int ff_visible_quad(const float p[3], const float n[3], const float v0[3], const float v1[3], const float v2[3], float q0[3], float q1[3], float q2[3], float q3[3])
 {
        static const float epsilon = 1e-6f;
        float c, sd[3];
@@ -2605,7 +2604,7 @@ static float ff_quad_form_factor(float *p, float *n, float *q0, float *q1, float
        aresult = (_mm_set_ps1(n[0])*gx + _mm_set_ps1(n[1])*gy + _mm_set_ps1(n[2])*gz)*angle;
 
        /* sum together */
-    result= (fresult[0] + fresult[1] + fresult[2] + fresult[3])*(0.5f/(float)M_PI);
+       result= (fresult[0] + fresult[1] + fresult[2] + fresult[3])*(0.5f/(float)M_PI);
        result= MAX2(result, 0.0f);
 
        return result;
@@ -2628,7 +2627,7 @@ static void ff_normalize(float n[3])
        } 
 }
 
-static float ff_quad_form_factor(float *p, float *n, float *q0, float *q1, float *q2, float *q3)
+static float ff_quad_form_factor(const float p[3], const float n[3], const float q0[3], const float q1[3], const float q2[3], const float q3[3])
 {
        float r0[3], r1[3], r2[3], r3[3], g0[3], g1[3], g2[3], g3[3];
        float a1, a2, a3, a4, dot1, dot2, dot3, dot4, result;
@@ -2680,7 +2679,7 @@ float form_factor_hemi_poly(float p[3], float n[3], float v1[3], float v2[3], fl
 }
 
 /* evaluate if entire quad is a proper convex quad */
- int is_quad_convex_v3(float *v1, float *v2, float *v3, float *v4)
+ int is_quad_convex_v3(const float *v1, const float *v2, const float *v3, const float *v4)
  {
        float nor[3], nor1[3], nor2[3], vec[4][2];
        
index 9bd4f00668fb9dc3495649aee00782246591a4f8..a80712884fc836d2c516f4fb683b78b3ff6b9089 100644 (file)
@@ -34,10 +34,10 @@ typedef struct EdgeTag {
 
 void calc_corner_co(BMesh *bm, BMLoop *l, float *co, float fac)
 {
-       float  no[3], tan[3], vec1[3], vec2[3], v1[3], v2[3], v3[3], v4[3];
-       float p1[3], p2[3], w[3];
-       float l1, l2;
-       int ret, inv=0;
+       float  no[3], /*tan[3]*,*/ vec1[3], vec2[3], v1[3], v2[3], v3[3], v4[3];
+       /*float p1[3], p2[3], w[3];
+       float l1, l2;*/
+       int /*ret,*/ inv=0;
        
        if (l->f->len > 2) {
                copy_v3_v3(v1, l->prev->v->co);
index 5241bbc4ee9c074ac2e0d697372bf3c4b86ecffc..fa7bfee8ee55405e9935fddc0aac4c1669bde540 100644 (file)
@@ -106,17 +106,9 @@ if(WITH_BUILDINFO)
        add_definitions(-DNAN_BUILDINFO)
 endif()
 
-<<<<<<< .working
-IF(WITH_BUILDINFO)
-       ADD_DEFINITIONS(-DNAN_BUILDINFO)
-ENDIF(WITH_BUILDINFO)
-
-BLENDERLIB(bf_collada "${SRC}" "${INC}")
-=======
 if(CMAKE_COMPILER_IS_GNUCXX)
        # COLLADAFWArray.h gives error with gcc 4.5
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fpermissive")
 endif()
 
 blender_add_lib(bf_collada "${SRC}" "${INC}")
->>>>>>> .merge-right.r35190
index e497a13258f36444f90972c3186e6e5fbcf46cca..00daac6028182d5ec270791dd8e295b940a0db57 100644 (file)
@@ -295,446 +295,6 @@ public:
        }
 };
 
-<<<<<<< .working
-class ImagesExporter: COLLADASW::LibraryImages
-{
-       const char *mfilename;
-       std::vector<std::string> mImages; // contains list of written images, to avoid duplicates
-public:
-       ImagesExporter(COLLADASW::StreamWriter *sw, const char* filename) : COLLADASW::LibraryImages(sw), mfilename(filename)
-       {}
-       
-       void exportImages(Scene *sce)
-       {
-               openLibrary();
-
-               forEachMaterialInScene(sce, *this);
-
-               closeLibrary();
-       }
-
-       void operator()(Material *ma, Object *ob)
-       {
-               int a;
-               for (a = 0; a < MAX_MTEX; a++) {
-                       MTex *mtex = ma->mtex[a];
-                       if (mtex && mtex->tex && mtex->tex->ima) {
-
-                               Image *image = mtex->tex->ima;
-                               std::string name(id_name(image));
-                               name = translate_id(name);
-                               char rel[FILE_MAX];
-                               char abs[FILE_MAX];
-                               char src[FILE_MAX];
-                               char dir[FILE_MAX];
-                               
-                               BLI_split_dirfile(mfilename, dir, NULL);
-
-                               BKE_rebase_path(abs, sizeof(abs), rel, sizeof(rel), G.sce, image->name, dir);
-
-                               if (abs[0] != '\0') {
-
-                                       // make absolute source path
-                                       BLI_strncpy(src, image->name, sizeof(src));
-                                       BLI_path_abs(src, G.sce);
-
-                                       // make dest directory if it doesn't exist
-                                       BLI_make_existing_file(abs);
-                               
-                                       if (BLI_copy_fileops(src, abs) != 0) {
-                                               fprintf(stderr, "Cannot copy image to file's directory. \n");
-                                       }
-                               } 
-                               
-                               if (find(mImages.begin(), mImages.end(), name) == mImages.end()) {
-                                       COLLADASW::Image img(COLLADABU::URI(COLLADABU::URI::nativePathToUri(rel)), name);
-                                       img.add(mSW);
-
-                                       mImages.push_back(name);
-                               }
-                       }
-               }
-       }
-};
-
-class EffectsExporter: COLLADASW::LibraryEffects
-{
-public:
-       EffectsExporter(COLLADASW::StreamWriter *sw) : COLLADASW::LibraryEffects(sw){}
-       void exportEffects(Scene *sce)
-       {
-               openLibrary();
-
-               forEachMaterialInScene(sce, *this);
-
-               closeLibrary();
-       }
-
-       void operator()(Material *ma, Object *ob)
-       {
-               // create a list of indices to textures of type TEX_IMAGE
-               std::vector<int> tex_indices;
-               createTextureIndices(ma, tex_indices);
-
-               openEffect(translate_id(id_name(ma)) + "-effect");
-               
-               COLLADASW::EffectProfile ep(mSW);
-               ep.setProfileType(COLLADASW::EffectProfile::COMMON);
-               ep.openProfile();
-               // set shader type - one of three blinn, phong or lambert
-               if (ma->spec_shader == MA_SPEC_BLINN) {
-                       ep.setShaderType(COLLADASW::EffectProfile::BLINN);
-                       // shininess
-                       ep.setShininess(ma->spec);
-               }
-               else if (ma->spec_shader == MA_SPEC_PHONG) {
-                       ep.setShaderType(COLLADASW::EffectProfile::PHONG);
-                       // shininess
-                       // XXX not sure, stolen this from previous Collada plugin
-                       ep.setShininess(ma->har / 4);
-               }
-               else {
-                       // XXX write warning "Current shader type is not supported" 
-                       ep.setShaderType(COLLADASW::EffectProfile::LAMBERT);
-               }
-               // index of refraction
-               if (ma->mode & MA_RAYTRANSP) {
-                       ep.setIndexOfRefraction(ma->ang);
-               }
-               else {
-                       ep.setIndexOfRefraction(1.0f);
-               }
-       
-               COLLADASW::ColorOrTexture cot;
-
-               // transparency
-               // Tod: because we are in A_ONE mode transparency is calculated like this:
-               ep.setTransparency(1.0f);
-               cot = getcol(0.0f, 0.0f, 0.0f, ma->alpha);
-               ep.setTransparent(cot);
-
-               // emission
-               cot=getcol(ma->emit, ma->emit, ma->emit, 1.0f);
-               ep.setEmission(cot);
-
-               // diffuse 
-               cot = getcol(ma->r, ma->g, ma->b, 1.0f);
-               ep.setDiffuse(cot);
-
-               // ambient
-               cot = getcol(ma->ambr, ma->ambg, ma->ambb, 1.0f);
-               ep.setAmbient(cot);
-
-               // reflective, reflectivity
-               if (ma->mode & MA_RAYMIRROR) {
-                       cot = getcol(ma->mirr, ma->mirg, ma->mirb, 1.0f);
-                       ep.setReflective(cot);
-                       ep.setReflectivity(ma->ray_mirror);
-               }
-               else {
-                       cot = getcol(ma->specr, ma->specg, ma->specb, 1.0f);
-                       ep.setReflective(cot);
-                       ep.setReflectivity(ma->spec);
-               }
-
-               // specular
-               if (ep.getShaderType() != COLLADASW::EffectProfile::LAMBERT) {
-                       cot = getcol(ma->specr, ma->specg, ma->specb, 1.0f);
-                       ep.setSpecular(cot);
-               }       
-
-               // XXX make this more readable if possible
-
-               // create <sampler> and <surface> for each image
-               COLLADASW::Sampler samplers[MAX_MTEX];
-               //COLLADASW::Surface surfaces[MAX_MTEX];
-               //void *samp_surf[MAX_MTEX][2];
-               void *samp_surf[MAX_MTEX][1];
-               
-               // image to index to samp_surf map
-               // samp_surf[index] stores 2 pointers, sampler and surface
-               std::map<std::string, int> im_samp_map;
-
-               unsigned int a, b;
-               for (a = 0, b = 0; a < tex_indices.size(); a++) {
-                       MTex *t = ma->mtex[tex_indices[a]];
-                       Image *ima = t->tex->ima;
-                       
-                       std::string key(id_name(ima));
-                       key = translate_id(key);
-
-                       // create only one <sampler>/<surface> pair for each unique image
-                       if (im_samp_map.find(key) == im_samp_map.end()) {
-                               //<newparam> <surface> <init_from>
-                       //      COLLADASW::Surface surface(COLLADASW::Surface::SURFACE_TYPE_2D,
-//                                                                                key + COLLADASW::Surface::SURFACE_SID_SUFFIX);
-//                             COLLADASW::SurfaceInitOption sio(COLLADASW::SurfaceInitOption::INIT_FROM);
-//                             sio.setImageReference(key);
-//                             surface.setInitOption(sio);
-                               
-                               //<newparam> <sampler> <source>
-                               COLLADASW::Sampler sampler(COLLADASW::Sampler::SAMPLER_TYPE_2D,
-                                                                                  key + COLLADASW::Sampler::SAMPLER_SID_SUFFIX,
-                                                                                  key + COLLADASW::Sampler::SURFACE_SID_SUFFIX);
-                               sampler.setImageId(key);
-                               // copy values to arrays since they will live longer
-                               samplers[a] = sampler;
-                               //surfaces[a] = surface;
-                               
-                               // store pointers so they can be used later when we create <texture>s
-                               samp_surf[b][0] = &samplers[a];
-                               //samp_surf[b][1] = &surfaces[a];
-                               
-                               im_samp_map[key] = b;
-                               b++;
-                       }
-               }
-
-               // used as fallback when MTex->uvname is "" (this is pretty common)
-               // it is indeed the correct value to use in that case
-               std::string active_uv(getActiveUVLayerName(ob));
-
-               // write textures
-               // XXX very slow
-               for (a = 0; a < tex_indices.size(); a++) {
-                       MTex *t = ma->mtex[tex_indices[a]];
-                       Image *ima = t->tex->ima;
-
-                       // we assume map input is always TEXCO_UV
-
-                       std::string key(id_name(ima));
-                       key = translate_id(key);
-                       int i = im_samp_map[key];
-                       COLLADASW::Sampler *sampler = (COLLADASW::Sampler*)samp_surf[i][0];
-                       //COLLADASW::Surface *surface = (COLLADASW::Surface*)samp_surf[i][1];
-
-                       std::string uvname = strlen(t->uvname) ? t->uvname : active_uv;
-
-                       // color
-                       if (t->mapto & MAP_COL) {
-                               ep.setDiffuse(createTexture(ima, uvname, sampler));
-                       }
-                       // ambient
-                       if (t->mapto & MAP_AMB) {
-                               ep.setAmbient(createTexture(ima, uvname, sampler));
-                       }
-                       // specular
-                       if (t->mapto & MAP_SPEC) {
-                               ep.setSpecular(createTexture(ima, uvname, sampler));
-                       }
-                       // emission
-                       if (t->mapto & MAP_EMIT) {
-                               ep.setEmission(createTexture(ima, uvname, sampler));
-                       }
-                       // reflective
-                       if (t->mapto & MAP_REF) {
-                               ep.setReflective(createTexture(ima, uvname, sampler));
-                       }
-                       // alpha
-                       if (t->mapto & MAP_ALPHA) {
-                               ep.setTransparent(createTexture(ima, uvname, sampler));
-                       }
-                       // extension:
-                       // Normal map --> Must be stored with <extra> tag as different technique, 
-                       // since COLLADA doesn't support normal maps, even in current COLLADA 1.5.
-                       if (t->mapto & MAP_NORM) {
-                               COLLADASW::Texture texture(key);
-                               texture.setTexcoord(uvname);
-                               texture.setSampler(*sampler);
-                               // technique FCOLLADA, with the <bump> tag, is most likely the best understood,
-                               // most widespread de-facto standard.
-                               texture.setProfileName("FCOLLADA");
-                               texture.setChildElementName("bump");                            
-                               ep.addExtraTechniqueColorOrTexture(COLLADASW::ColorOrTexture(texture));
-                       }
-               }
-               // performs the actual writing
-               ep.addProfileElements();
-               bool twoSided = false;
-               if (ob->type == OB_MESH && ob->data) {
-                       Mesh *me = (Mesh*)ob->data;
-                       if (me->flag & ME_TWOSIDED)
-                               twoSided = true;
-               }
-               if (twoSided)
-                       ep.addExtraTechniqueParameter("GOOGLEEARTH", "show_double_sided", 1);
-               ep.addExtraTechniques(mSW);
-
-               ep.closeProfile();
-               if (twoSided)
-                       mSW->appendTextBlock("<extra><technique profile=\"MAX3D\"><double_sided>1</double_sided></technique></extra>");
-               closeEffect();  
-       }
-       
-       COLLADASW::ColorOrTexture createTexture(Image *ima,
-                                                                                       std::string& uv_layer_name,
-                                                                                       COLLADASW::Sampler *sampler
-                                                                                       /*COLLADASW::Surface *surface*/)
-       {
-               
-               COLLADASW::Texture texture(translate_id(id_name(ima)));
-               texture.setTexcoord(uv_layer_name);
-               //texture.setSurface(*surface);
-               texture.setSampler(*sampler);
-               
-               COLLADASW::ColorOrTexture cot(texture);
-               return cot;
-       }
-       
-       COLLADASW::ColorOrTexture getcol(float r, float g, float b, float a)
-       {
-               COLLADASW::Color color(r,g,b,a);
-               COLLADASW::ColorOrTexture cot(color);
-               return cot;
-       }
-       
-       //returns the array of mtex indices which have image 
-       //need this for exporting textures
-       void createTextureIndices(Material *ma, std::vector<int> &indices)
-       {
-               indices.clear();
-
-               for (int a = 0; a < MAX_MTEX; a++) {
-                       if (ma->mtex[a] &&
-                               ma->mtex[a]->tex &&
-                               ma->mtex[a]->tex->type == TEX_IMAGE &&
-                               ma->mtex[a]->texco == TEXCO_UV){
-                               indices.push_back(a);
-                       }
-               }
-       }
-};
-
-class MaterialsExporter: COLLADASW::LibraryMaterials
-{
-public:
-       MaterialsExporter(COLLADASW::StreamWriter *sw): COLLADASW::LibraryMaterials(sw){}
-       void exportMaterials(Scene *sce)
-       {
-               openLibrary();
-
-               forEachMaterialInScene(sce, *this);
-
-               closeLibrary();
-       }
-
-       void operator()(Material *ma, Object *ob)
-       {
-               std::string name(id_name(ma));
-
-               openMaterial(translate_id(name), name);
-
-               std::string efid = translate_id(name) + "-effect";
-               addInstanceEffect(COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, efid));
-
-               closeMaterial();
-       }
-};
-
-class CamerasExporter: COLLADASW::LibraryCameras
-{
-public:
-       CamerasExporter(COLLADASW::StreamWriter *sw): COLLADASW::LibraryCameras(sw){}
-       void exportCameras(Scene *sce)
-       {
-               openLibrary();
-               
-               forEachCameraObjectInScene(sce, *this);
-               
-               closeLibrary();
-       }
-       void operator()(Object *ob, Scene *sce)
-       {
-               // XXX add other params later
-               Camera *cam = (Camera*)ob->data;
-               std::string cam_id(get_camera_id(ob));
-               std::string cam_name(id_name(cam));
-               
-               if (cam->type == CAM_PERSP) {
-                       COLLADASW::PerspectiveOptic persp(mSW);
-                       persp.setXFov(1.0);
-                       persp.setAspectRatio(0.1);
-                       persp.setZFar(cam->clipend);
-                       persp.setZNear(cam->clipsta);
-                       COLLADASW::Camera ccam(mSW, &persp, cam_id, cam_name);
-                       addCamera(ccam);
-               }
-               else {
-                       COLLADASW::OrthographicOptic ortho(mSW);
-                       ortho.setXMag(1.0);
-                       ortho.setAspectRatio(0.1);
-                       ortho.setZFar(cam->clipend);
-                       ortho.setZNear(cam->clipsta);
-                       COLLADASW::Camera ccam(mSW, &ortho, cam_id, cam_name);
-                       addCamera(ccam);
-               }
-       }       
-};
-
-class LightsExporter: COLLADASW::LibraryLights
-{
-public:
-       LightsExporter(COLLADASW::StreamWriter *sw): COLLADASW::LibraryLights(sw){}
-       void exportLights(Scene *sce)
-       {
-               openLibrary();
-               
-               forEachLampObjectInScene(sce, *this);
-               
-               closeLibrary();
-       }
-       void operator()(Object *ob)
-       {
-               Lamp *la = (Lamp*)ob->data;
-               std::string la_id(get_light_id(ob));
-               std::string la_name(id_name(la));
-               COLLADASW::Color col(la->r, la->g, la->b);
-               float e = la->energy;
-               
-               // sun
-               if (la->type == LA_SUN) {
-                       COLLADASW::DirectionalLight cla(mSW, la_id, la_name, e);
-                       cla.setColor(col);
-                       addLight(cla);
-               }
-               // hemi
-               else if (la->type == LA_HEMI) {
-                       COLLADASW::AmbientLight cla(mSW, la_id, la_name, e);
-                       cla.setColor(col);
-                       addLight(cla);
-               }
-               // spot
-               else if (la->type == LA_SPOT) {
-                       COLLADASW::SpotLight cla(mSW, la_id, la_name, e);
-                       cla.setColor(col);
-                       cla.setFallOffAngle(la->spotsize);
-                       cla.setFallOffExponent(la->spotblend);
-                       cla.setLinearAttenuation(la->att1);
-                       cla.setQuadraticAttenuation(la->att2);
-                       addLight(cla);
-               }
-               // lamp
-               else if (la->type == LA_LOCAL) {
-                       COLLADASW::PointLight cla(mSW, la_id, la_name, e);
-                       cla.setColor(col);
-                       cla.setLinearAttenuation(la->att1);
-                       cla.setQuadraticAttenuation(la->att2);
-                       addLight(cla);
-               }
-               // area lamp is not supported
-               // it will be exported as a local lamp
-               else {
-                       COLLADASW::PointLight cla(mSW, la_id, la_name, e);
-                       cla.setColor(col);
-                       cla.setLinearAttenuation(la->att1);
-                       cla.setQuadraticAttenuation(la->att2);
-                       addLight(cla);
-               }
-       }
-};
-
-=======
->>>>>>> .merge-right.r35190
 // TODO: it would be better to instantiate animations rather than create a new one per object
 // COLLADA allows this through multiple <channel>s in <animation>.
 // For this to work, we need to know objects that use a certain action.
@@ -1432,17 +992,6 @@ void DocumentExporter::exportCurrentScene(Scene *sce, const char* filename)
 
        asset.setUnit(unitname, linearmeasure);
        asset.setUpAxisType(COLLADASW::Asset::Z_UP);
-<<<<<<< .working
-       // TODO: need an Author field in userpref
-       asset.getContributor().mAuthor = "Blender User";
-#ifdef NAN_BUILDINFO
-       char version_buf[128];
-       sprintf(version_buf, "Blender %d.%02d.%d r%s", BLENDER_VERSION/100, BLENDER_VERSION%100, BLENDER_SUBVERSION, build_rev);
-       asset.getContributor().mAuthoringTool = version_buf;
-#else
-       asset.getContributor().mAuthoringTool = "Blender 2.5x";
-#endif
-=======
        // TODO: need an Author field in userpref
        if(strlen(U.author) > 0) {
                asset.getContributor().mAuthor = U.author;
@@ -1457,7 +1006,6 @@ void DocumentExporter::exportCurrentScene(Scene *sce, const char* filename)
 #else
        asset.getContributor().mAuthoringTool = "Blender 2.5x";
 #endif
->>>>>>> .merge-right.r35190
        asset.add();
        
        // <library_cameras>
index 18276a5c8257667803b5f3bf7fc93189c65a7d85..e937417c857d368118a32f083059009452651c50 100644 (file)
@@ -951,7 +951,7 @@ static void calc_shapeKeys(Object *obedit)
                                                                                ++i;
                                                                        }
 
-                                                                       fp+= 3; curofp+= 3;     /* alphas */
+                                                                       fp+= 3; /* alphas */
                                                                } else {
                                                                        for (j= 0; j < 3; ++j, ++i) {
                                                                                VECCOPY(fp, bezt->vec[j]);
@@ -1234,7 +1234,6 @@ void make_editNurb(Object *obedit)
        Nurb *nu, *newnu, *nu_act= NULL;
        KeyBlock *actkey;
 
-       if(obedit==NULL) return;
 
        set_actNurb(obedit, NULL);
 
@@ -1591,7 +1590,7 @@ static int deleteflagNurb(bContext *C, wmOperator *UNUSED(op), int flag)
        BPoint *bp, *bpn, *newbp;
        int a, b, newu, newv, sel;
 
-       if(obedit && obedit->type==OB_SURF);
+       if(obedit->type==OB_SURF);
        else return OPERATOR_CANCELLED;
 
        cu->lastsel= NULL;
@@ -2855,7 +2854,7 @@ static void subdividenurb(Object *obedit, int number_cuts)
        int a, b, sel, amount, *usel, *vsel, i;
        float factor;
 
-   // printf("*** subdivideNurb: entering subdivide\n");
+       // printf("*** subdivideNurb: entering subdivide\n");
 
        for(nu= editnurb->nurbs.first; nu; nu= nu->next) {
                amount= 0;
@@ -3031,7 +3030,7 @@ static void subdividenurb(Object *obedit, int number_cuts)
                /* This is a very strange test ... */
                /** 
                   Subdivide NURB surfaces - nzc 30-5-'00 -
-           
+
                         Subdivision of a NURB curve can be effected by adding a 
                   control point (insertion of a knot), or by raising the
                   degree of the functions used to build the NURB. The
@@ -3231,8 +3230,7 @@ static void subdividenurb(Object *obedit, int number_cuts)
                                                MEM_freeN(nu->bp);
                                                nu->bp= bpnew;
                                                nu->pntsu+= sel;
-                                               nurbs_knot_calc_u(nu); /* shift knots
-                                                                                                        forward */
+                                               nurbs_knot_calc_u(nu); /* shift knots forward */
                                        }
                                }
                        }
@@ -3581,7 +3579,7 @@ void CURVE_OT_spline_type_set(wmOperatorType *ot)
 
        /* identifiers */
        ot->name= "Set Spline Type";
-       ot->description = "Set type of actibe spline";
+       ot->description = "Set type of active spline";
        ot->idname= "CURVE_OT_spline_type_set";
        
        /* api callbacks */
@@ -4171,7 +4169,7 @@ void CURVE_OT_make_segment(wmOperatorType *ot)
 
 /***************** pick select from 3d view **********************/
 
-int mouse_nurb(bContext *C, short mval[2], int extend)
+int mouse_nurb(bContext *C, const short mval[2], int extend)
 {
        Object *obedit= CTX_data_edit_object(C); 
        Curve *cu= obedit->data;
@@ -4413,11 +4411,10 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
        Nurb *nu, *newnu= NULL;
        BezTriple *bezt, *newbezt = NULL;
        BPoint *bp, *newbp = NULL;
-       float mat[3][3],imat[3][3], temp[3];
+       float imat[4][4], temp[3];
        int ok= 0;
 
-       copy_m3_m4(mat, obedit->obmat);
-       invert_m3_m3(imat,mat);
+       invert_m4_m4(imat, obedit->obmat);
 
        findselectedNurbvert(&editnurb->nurbs, &nu, &bezt, &bp);
 
@@ -4451,10 +4448,14 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
                                temp[0] = 1;
                                temp[1] = 0;
                                temp[2] = 0;
+
                                copy_v3_v3(newbezt->vec[1], location);
-                               sub_v3_v3(newbezt->vec[1], obedit->obmat[3]);
-                               sub_v3_v3v3(newbezt->vec[0], newbezt->vec[1],temp);
-                               add_v3_v3v3(newbezt->vec[2], newbezt->vec[1],temp);
+                               sub_v3_v3v3(newbezt->vec[0], newbezt->vec[1], temp);
+                               add_v3_v3v3(newbezt->vec[2], newbezt->vec[1], temp);
+
+                               mul_m4_v3(imat, newbezt->vec[0]);
+                               mul_m4_v3(imat, newbezt->vec[1]);
+                               mul_m4_v3(imat, newbezt->vec[2]);
 
                                ok= 1;
                                nu= newnu;
@@ -4473,9 +4474,7 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
                                newnu->orderu= 2;
                                newnu->pntsu= 1;
 
-                               copy_v3_v3(newbp->vec, location);
-                               sub_v3_v3(newbp->vec, obedit->obmat[3]);
-                               mul_m3_v3(imat,newbp->vec);
+                               mul_v3_m4v3(newbp->vec, imat, location);
                                newbp->vec[3]= 1.0;
 
                                newnu->knotsu= newnu->knotsv= NULL;
@@ -4555,9 +4554,7 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
                                copy_v3_v3(newbezt->vec[2], bezt->vec[2]);
                        }
                        else {
-                               copy_v3_v3(newbezt->vec[1], location);
-                               sub_v3_v3(newbezt->vec[1], obedit->obmat[3]);
-                               mul_m3_v3(imat,newbezt->vec[1]);
+                               mul_v3_m4v3(newbezt->vec[1], imat, location);
                                sub_v3_v3v3(temp, newbezt->vec[1],temp);
                                add_v3_v3v3(newbezt->vec[0], bezt->vec[0],temp);
                                add_v3_v3v3(newbezt->vec[2], bezt->vec[2],temp);
@@ -4622,9 +4619,7 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
                                copy_v3_v3(newbp->vec, bp->vec);
                        }
                        else {
-                               copy_v3_v3(newbp->vec, location);
-                               sub_v3_v3(newbp->vec, obedit->obmat[3]);
-                               mul_m3_v3(imat,newbp->vec);
+                               mul_v3_m4v3(newbp->vec, imat, location);
                                newbp->vec[3]= 1.0;
 
                                if(!newnu && nu->orderu<4 && nu->orderu<=nu->pntsu)
@@ -4666,13 +4661,33 @@ static int add_vertex_exec(bContext *C, wmOperator *op)
 static int add_vertex_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
        RegionView3D *rv3d= CTX_wm_region_view3d(C);
-       ViewContext vc;
-       float location[3] = {0.0f, 0.0f, 0.0f};
-       short mval[2];
 
        if(rv3d && !RNA_property_is_set(op->ptr, "location")) {
+               Curve *cu;
+               ViewContext vc;
+               float location[3];
+               short mval[2];
+
+               Nurb *nu;
+               BezTriple *bezt;
+               BPoint *bp;
+
                view3d_set_viewcontext(C, &vc);
 
+               cu= vc.obedit->data;
+
+               findselectedNurbvert(&cu->editnurb->nurbs, &nu, &bezt, &bp);
+
+               if(bezt) {
+                       mul_v3_m4v3(location, vc.obedit->obmat, bezt->vec[1]);
+               }
+               else if (bp) {
+                       mul_v3_m4v3(location, vc.obedit->obmat, bp->vec);
+               }
+               else {
+                       copy_v3_v3(location, give_cursor(vc.scene, vc.v3d));
+               }
+
                mval[0]= event->x - vc.ar->winrct.xmin;
                mval[1]= event->y - vc.ar->winrct.ymin;
                
@@ -4980,8 +4995,8 @@ static int select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *event
        int a, location[2], deselect;
 
        deselect= RNA_boolean_get(op->ptr, "deselect");
-       location[0]= event->x - ar->winrct.xmin;
-       location[1]= event->y - ar->winrct.ymin;
+       location[0]= event->x - ar->winrct.xmin;
+       location[1]= event->y - ar->winrct.ymin;
 
        view3d_operator_needs_opengl(C);
        view3d_set_viewcontext(C, &vc);
@@ -5622,7 +5637,7 @@ static int duplicate_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 void CURVE_OT_duplicate(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Duplicate";
+       ot->name= "Duplicate Curve";
        ot->description = "Duplicate selected control points and segments between them";
        ot->idname= "CURVE_OT_duplicate";
        
@@ -5646,7 +5661,7 @@ static int delete_exec(bContext *C, wmOperator *op)
        Curve *cu= obedit->data;
        EditNurb *editnurb= cu->editnurb;
        ListBase *nubase= &editnurb->nurbs;
-       Nurb *nu, *next, *nu1;
+       Nurb *nu, *nu1;
        BezTriple *bezt, *bezt1, *bezt2;
        BPoint *bp, *bp1, *bp2;
        int a, cut= 0, type= RNA_enum_get(op->ptr, "type");
@@ -5671,6 +5686,7 @@ static int delete_exec(bContext *C, wmOperator *op)
 
        if(type==0) {
                /* first loop, can we remove entire pieces? */
+               Nurb *next;
                nu= nubase->first;
                while(nu) {
                        next= nu->next;
@@ -5799,7 +5815,6 @@ static int delete_exec(bContext *C, wmOperator *op)
                nu1= NULL;
                nuindex= 0;
                for(nu= nubase->first; nu; nu= nu->next) {
-                       next= nu->next;
                        if(nu->type == CU_BEZIER) {
                                bezt= nu->bezt;
                                for(a=0; a<nu->pntsu-1; a++) {
@@ -6542,12 +6557,12 @@ static int curvesurf_prim_add(bContext *C, wmOperator *op, int type, int isSurf)
        ListBase *editnurb;
        Nurb *nu;
        int newob= 0;
-       int enter_editmode;
+       int enter_editmode, is_aligned;
        unsigned int layer;
        float loc[3], rot[3];
        float mat[4][4];
 
-       if(!ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer, NULL))
+       if(!ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer, &is_aligned))
                return OPERATOR_CANCELLED;
 
        if (!isSurf) { /* adding curve */
@@ -6647,7 +6662,7 @@ static int add_primitive_bezier_circle_exec(bContext *C, wmOperator *op)
 void CURVE_OT_primitive_bezier_circle_add(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Add Circle";
+       ot->name= "Add Bezier Circle";
        ot->description= "Construct a Bezier Circle";
        ot->idname= "CURVE_OT_primitive_bezier_circle_add";
        
@@ -6940,7 +6955,7 @@ static void *undo_check_lastsel(void *lastsel, Nurb *nu, Nurb *newnu)
        return NULL;
 }
 
-static void undoCurve_to_editCurve(void *ucu, void *obe, void *obdata)
+static void undoCurve_to_editCurve(void *ucu, void *edata, void *obe)
 {
        Object *obedit= obe;
        Curve *cu= (Curve*)obedit->data;
@@ -6990,7 +7005,7 @@ static void undoCurve_to_editCurve(void *ucu, void *obe, void *obdata)
        ED_curve_updateAnimPaths(obedit);
 }
 
-static void *editCurve_to_undoCurve(void *obe, void *cue)
+static void *editCurve_to_undoCurve(void *edata, void *obe)
 {
        Object *obedit= obe;
        Curve *cu= (Curve*)obedit->data;
index 37cc135a6a83846547cde49d3667498f693d77a4..f5b9ed396640d68d22a261edd4f7d09910ac44b2 100644 (file)
@@ -1769,7 +1769,7 @@ void FONT_OT_unlink(wmOperatorType *ot)
 
 /* **************** undo for font object ************** */
 
-static void undoFont_to_editFont(void *strv, void *ecu, void *obdata)
+static void undoFont_to_editFont(void *strv, void *ecu, void *UNUSED(obdata))
 {
        Curve *cu= (Curve *)ecu;
        EditFont *ef= cu->editfont;
@@ -1786,7 +1786,7 @@ static void undoFont_to_editFont(void *strv, void *ecu, void *obdata)
        update_string(cu);
 }
 
-static void *editFont_to_undoFont(void *ecu, void *obdata)
+static void *editFont_to_undoFont(void *ecu, void *UNUSED(obdata))
 {
        Curve *cu= (Curve *)ecu;
        EditFont *ef= cu->editfont;
index 598c0e5fa263f60c56c850a5bd13cb54db023a15..1a9ef4be70fa17bead51b05deb28a97bbc16f0b4 100644 (file)
 /* ----- General Defines ------ */
 
 /* flags for sflag */
-enum {
+typedef enum eDrawStrokeFlags {
        GP_DRAWDATA_NOSTATUS    = (1<<0),       /* don't draw status info */
        GP_DRAWDATA_ONLY3D              = (1<<1),       /* only draw 3d-strokes */
        GP_DRAWDATA_ONLYV2D             = (1<<2),       /* only draw 'canvas' strokes */
        GP_DRAWDATA_ONLYI2D             = (1<<3),       /* only draw 'image' strokes */
        GP_DRAWDATA_IEDITHACK   = (1<<4),       /* special hack for drawing strokes in Image Editor (weird coordinates) */
        GP_DRAWDATA_NO_XRAY             = (1<<5),       /* dont draw xray in 3D view (which is default) */
-};
+} eDrawStrokeFlags;
+
+
 
 /* thickness above which we should use special drawing */
 #define GP_DRAWTHICKNESS_SPECIAL       3
@@ -152,7 +154,7 @@ static void gp_draw_stroke_buffer (tGPspoint *points, int totpoints, short thick
 /* ----- Existing Strokes Drawing (3D and Point) ------ */
 
 /* draw a given stroke - just a single dot (only one point) */
-static void gp_draw_stroke_point (bGPDspoint *points, short thickness, short sflag, int offsx, int offsy, int winx, int winy)
+static void gp_draw_stroke_point (bGPDspoint *points, short thickness, short dflag, short sflag, int offsx, int offsy, int winx, int winy)
 {
        /* draw point */
        if (sflag & GP_STROKE_3DSPACE) {
@@ -161,7 +163,6 @@ static void gp_draw_stroke_point (bGPDspoint *points, short thickness, short sfl
                glEnd();
        }
        else {
-               // int spacetype= 0; // XXX make local gpencil state var?
                float co[2];
                
                /* get coordinates of point */
@@ -181,12 +182,8 @@ static void gp_draw_stroke_point (bGPDspoint *points, short thickness, short sfl
                /* if thickness is less than GP_DRAWTHICKNESS_SPECIAL, simple dot looks ok
                 *      - also mandatory in if Image Editor 'image-based' dot
                 */
-#if 0
                if ( (thickness < GP_DRAWTHICKNESS_SPECIAL) ||
-                        ((spacetype==SPACE_IMAGE) && (sflag & GP_STROKE_2DSPACE)) )
-#else
-               if(1) /* when spacetype is back uncomment the check above */
-#endif
+                        ((dflag & GP_DRAWDATA_IEDITHACK) && (sflag & GP_STROKE_2DSPACE)) )
                {
                        glBegin(GL_POINTS);
                                glVertex2fv(co);
@@ -510,15 +507,16 @@ static void gp_draw_strokes (bGPDframe *gpf, int offsx, int offsy, int winx, int
                
                /* check which stroke-drawer to use */
                if (gps->totpoints == 1)
-                       gp_draw_stroke_point(gps->points, lthick, gps->flag, offsx, offsy, winx, winy);
+                       gp_draw_stroke_point(gps->points, lthick, dflag, gps->flag, offsx, offsy, winx, winy);
                else if (dflag & GP_DRAWDATA_ONLY3D) {
                        const int no_xray= (dflag & GP_DRAWDATA_NO_XRAY);
-                       int mask_orig;
-                       if(no_xray) {
+                       int mask_orig = 0;
+                       
+                       if (no_xray) {
                                glGetIntegerv(GL_DEPTH_WRITEMASK, &mask_orig);
                                glDepthMask(0);
                                glEnable(GL_DEPTH_TEST);
-
+                               
                                /* first arg is normally rv3d->dist, but this isnt available here and seems to work quite well without */
                                bglPolygonOffset(1.0f, 1.0f);
                                /*
@@ -526,13 +524,13 @@ static void gp_draw_strokes (bGPDframe *gpf, int offsx, int offsy, int winx, int
                                glPolygonOffset(-1.0f, -1.0f);
                                */
                        }
-
+                       
                        gp_draw_stroke_3d(gps->points, gps->totpoints, lthick, debug);
-
-                       if(no_xray) {
+                       
+                       if (no_xray) {
                                glDepthMask(mask_orig);
                                glDisable(GL_DEPTH_TEST);
-
+                               
                                bglPolygonOffset(0.0, 0.0);
                                /*
                                glDisable(GL_POLYGON_OFFSET_LINE);
@@ -549,7 +547,6 @@ static void gp_draw_strokes (bGPDframe *gpf, int offsx, int offsy, int winx, int
 static void gp_draw_data (bGPdata *gpd, int offsx, int offsy, int winx, int winy, int cfra, int dflag)
 {
        bGPDlayer *gpl;
-       // bGPDlayer *actlay=NULL; // UNUSED
        
        /* reset line drawing style (in case previous user didn't reset) */
        setlinestyle(0);
@@ -573,10 +570,6 @@ static void gp_draw_data (bGPdata *gpd, int offsx, int offsy, int winx, int winy
                if (gpl->flag & GP_LAYER_HIDE) 
                        continue;
                
-               /* if layer is active one, store pointer to it */
-               // if (gpl->flag & GP_LAYER_ACTIVE)
-               //      actlay= gpl;
-               
                /* get frame to draw */
                gpf= gpencil_layer_getframe(gpl, cfra, 0);
                if (gpf == NULL) 
@@ -588,11 +581,11 @@ static void gp_draw_data (bGPdata *gpd, int offsx, int offsy, int winx, int winy
                QUATCOPY(tcolor, gpl->color); // additional copy of color (for ghosting)
                glColor4f(color[0], color[1], color[2], color[3]);
                glPointSize((float)(gpl->thickness + 2));
-
+               
                /* apply xray layer setting */
-               if(gpl->flag & GP_LAYER_NO_XRAY)        dflag |=  GP_DRAWDATA_NO_XRAY;
+               if (gpl->flag & GP_LAYER_NO_XRAY)       dflag |=  GP_DRAWDATA_NO_XRAY;
                else                                                            dflag &= ~GP_DRAWDATA_NO_XRAY;
-
+               
                /* draw 'onionskins' (frame left + right) */
                if (gpl->flag & GP_LAYER_ONIONSKIN) {
                        /* drawing method - only immediately surrounding (gstep = 0), or within a frame range on either side (gstep > 0)*/                      
@@ -791,11 +784,11 @@ void draw_gpencil_view3d_ext (Scene *scene, View3D *v3d, ARegion *ar, short only
 
        /* check that we have grease-pencil stuff to draw */
        gpd= gpencil_data_get_active_v3d(scene); // XXX
-       if(gpd == NULL) return;
+       if (gpd == NULL) return;
 
        /* when rendering to the offscreen buffer we dont want to
         * deal with the camera border, otherwise map the coords to the camera border. */
-       if(rv3d->persp == RV3D_CAMOB && !(G.f & G_RENDER_OGL)) {
+       if ((rv3d->persp == RV3D_CAMOB) && !(G.f & G_RENDER_OGL)) {
                rctf rectf;
                view3d_calc_camera_border(scene, ar, rv3d, v3d, &rectf, -1); /* negative shift */
                BLI_copy_rcti_rctf(&rect, &rectf);
index 96e7cedf18a762c9a81ddf3c57d42adb70ad6bdc..17e7c0c221b4600e7571f349affbf726ec8a3e95 100644 (file)
@@ -933,8 +933,8 @@ static tGPsdata *gp_session_initpaint (bContext *C)
                /* supported views first */
                case SPACE_VIEW3D:
                {
-                       View3D *v3d= curarea->spacedata.first;
-                       RegionView3D *rv3d= ar->regiondata;
+                       // View3D *v3d= curarea->spacedata.first;
+                       // RegionView3D *rv3d= ar->regiondata;
                        
                        /* set current area 
                         *      - must verify that region data is 3D-view (and not something else)
@@ -949,12 +949,6 @@ static tGPsdata *gp_session_initpaint (bContext *C)
                                return p;
                        }
 
-                       /* for camera view set the subrect */
-                       if(rv3d->persp == RV3D_CAMOB) {
-                               view3d_calc_camera_border(p->scene, p->ar, NULL, v3d, &p->subrect_data, 1);
-                               p->subrect= &p->subrect_data;
-                       }
-
 #if 0 // XXX will this sort of antiquated stuff be restored?
                        /* check that gpencil data is allowed to be drawn */
                        if ((v3d->flag2 & V3D_DISPGP)==0) {
index 08a63a470c13ac55fbd37f8686e4e6fd4f021f81..cfafd38ed15a1c4c261eb9a0ac288735d7dd1686 100644 (file)
@@ -66,7 +66,7 @@ void  free_editNurb   (struct Object *obedit);
 
 void   free_curve_editNurb     (struct Curve *cu);
 
-int    mouse_nurb              (struct bContext *C, short mval[2], int extend);
+int    mouse_nurb              (struct bContext *C, const short mval[2], int extend);
 
 struct Nurb *add_nurbs_primitive(struct bContext *C, float mat[4][4], int type, int newob);
 
index 7be089fdf32b0b72d8c836e856ec55c80ee60c87..2e4106b3c046d3b92a23b39f3e49e5484531d471 100644 (file)
@@ -153,10 +153,16 @@ void uiStyleFontDrawExt(uiFontStyle *fs, rcti *rect, const char *str,
        height= BLF_height(fs->uifont_id, "2"); /* correct offset is on baseline, the j is below that */
        yofs= floor( 0.5f*(rect->ymax - rect->ymin - height));
 
-       if(fs->align==UI_STYLE_TEXT_CENTER)
+       if(fs->align==UI_STYLE_TEXT_CENTER) {
                xofs= floor( 0.5f*(rect->xmax - rect->xmin - BLF_width(fs->uifont_id, str)));
-       else if(fs->align==UI_STYLE_TEXT_RIGHT)
+               /* don't center text if it chops off the start of the text, 2 gives some margin */
+               if(xofs < 2) {
+                       xofs= 2;
+               }
+       }
+       else if(fs->align==UI_STYLE_TEXT_RIGHT) {
                xofs= rect->xmax - rect->xmin - BLF_width(fs->uifont_id, str) - 1;
+       }
        
        /* clip is very strict, so we give it some space */
        BLF_clipping(fs->uifont_id, rect->xmin-1, rect->ymin-4, rect->xmax+1, rect->ymax+4);
index 0c7ca31a152e5a33b23e4dbeb80edf8f9323799e..20474e2fba0b913f35ce1d47e06d0114c526c59d 100644 (file)
@@ -120,7 +120,6 @@ void EDBM_select_mirrored(Object *obedit, BMEditMesh *em)
 void EDBM_automerge(Scene *scene, Object *obedit, int update)
 {
        BMEditMesh *em;
-       int len;
        
        if ((scene->toolsettings->automerge) &&
            (obedit && obedit->type==OB_MESH) &&
@@ -453,7 +452,7 @@ float labda_PdistVL2Dfl( float *v1, float *v2, float *v3)
 }
 
 /* note; uses v3d, so needs active 3d window */
-static void findnearestedge__doClosest(void *userData, BMEdge *eed, int x0, int y0, int x1, int y1, int index)
+static void findnearestedge__doClosest(void *userData, BMEdge *eed, int x0, int y0, int x1, int y1, int UNUSED(index))
 {
        struct { ViewContext vc; float mval[2]; int dist; BMEdge *closest; } *data = userData;
        float v1[2], v2[2];
@@ -525,7 +524,7 @@ BMEdge *EDBM_findnearestedge(ViewContext *vc, int *dist)
        }
 }
 
-static void findnearestface__getDistance(void *userData, BMFace *efa, int x, int y, int index)
+static void findnearestface__getDistance(void *userData, BMFace *efa, int x, int y, int UNUSED(index))
 {
        struct { short mval[2]; int dist; BMFace *toFace; } *data = userData;
 
@@ -690,7 +689,6 @@ static EnumPropertyItem prop_similar_types[] = {
 
 static int similar_face_select_exec(bContext *C, wmOperator *op)
 {
-       Scene *scene = CTX_data_scene(C);
        Object *ob = CTX_data_edit_object(C);
        BMEditMesh *em = ((Mesh*)ob->data)->edit_btmesh;
        BMOperator bmop;
@@ -731,7 +729,6 @@ static int similar_face_select_exec(bContext *C, wmOperator *op)
 /* wrap the above function but do selection flushing edge to face */
 static int similar_edge_select_exec(bContext *C, wmOperator *op)
 {
-       Scene *scene = CTX_data_scene(C);
        Object *ob = CTX_data_edit_object(C);
        BMEditMesh *em = ((Mesh*)ob->data)->edit_btmesh;
        BMOperator bmop;
@@ -778,7 +775,6 @@ VERT GROUP
 
 static int similar_vert_select_exec(bContext *C, wmOperator *op)
 {
-       Scene *scene = CTX_data_scene(C);
        Object *ob = CTX_data_edit_object(C);
        BMEditMesh *em = ((Mesh*)ob->data)->edit_btmesh;
        BMOperator bmop;
@@ -824,7 +820,7 @@ static int select_similar_exec(bContext *C, wmOperator *op)
                return similar_face_select_exec(C, op);
 }
 
-static EnumPropertyItem *select_similar_type_itemf(bContext *C, PointerRNA *ptr, int *free)
+static EnumPropertyItem *select_similar_type_itemf(bContext *C, PointerRNA *UNUSED(ptr), int *free)
 {
        Object *obedit = CTX_data_edit_object(C);
        EnumPropertyItem *item= NULL;
@@ -899,7 +895,7 @@ static void walker_select(BMEditMesh *em, int walkercode, void *start, int selec
        BMW_End(&walker);
 }
 
-static int loop_multiselect(bContext *C, wmOperator *op)
+static int loop_multiselect(bContext *UNUSED(C), wmOperator *UNUSED(op))
 {
 #if 0 //BMESH_TODO
        Object *obedit= CTX_data_edit_object(C);
@@ -1056,7 +1052,7 @@ void MESH_OT_loop_select(wmOperatorType *ot)
 /* ******************* mesh shortest path select, uses prev-selected edge ****************** */
 
 /* since you want to create paths with multiple selects, it doesn't have extend option */
-static void mouse_mesh_shortest_path(bContext *C, short mval[2])
+static void mouse_mesh_shortest_path(bContext *UNUSED(C), short UNUSED(mval[2]))
 {
 #if 0 //BMESH_TODO
        ViewContext vc;
@@ -1125,7 +1121,7 @@ static void mouse_mesh_shortest_path(bContext *C, short mval[2])
 }
 
 
-static int mesh_shortest_path_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
+static int mesh_shortest_path_select_invoke(bContext *C, wmOperator *UNUSED(op), wmEvent *event)
 {
        
        view3d_operator_needs_opengl(C);
@@ -1306,7 +1302,6 @@ void EDBM_selectmode_set(BMEditMesh *em)
 
 void EDBM_convertsel(BMEditMesh *em, short oldmode, short selectmode)
 {
-       BMVert *eve;
        BMEdge *eed;
        BMFace *efa;
        BMIter iter;
@@ -1392,7 +1387,7 @@ void EDBM_select_swap(BMEditMesh *em) /* exported for UV */
 //     if (EM_texFaceCheck())
 }
 
-static int select_inverse_mesh_exec(bContext *C, wmOperator *op)
+static int select_inverse_mesh_exec(bContext *C, wmOperator *UNUSED(op))
 {
        Object *obedit= CTX_data_edit_object(C);
        BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
@@ -1429,9 +1424,7 @@ static int select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *event
        BMVert *eve;
        BMEdge *e, *eed;
        BMFace *efa;
-       short done=1, toggle=0;
        int sel= !RNA_boolean_get(op->ptr, "deselect");
-       int limit= RNA_boolean_get(op->ptr, "limit");
        
        /* unified_finednearest needs ogl */
        view3d_operator_needs_opengl(C);
@@ -1501,7 +1494,7 @@ void MESH_OT_select_linked_pick(wmOperatorType *ot)
 }
 
 
-static int select_linked_exec(bContext *C, wmOperator *op)
+static int select_linked_exec(bContext *C, wmOperator *UNUSED(op))
 {
        Object *obedit= CTX_data_edit_object(C);
        BMEditMesh *em= ((Mesh*)obedit->data)->edit_btmesh;
@@ -1875,9 +1868,9 @@ void em_deselect_nth_vert(EditMesh *em, int nth, EditVert *eve_act)
 }
 #endif
 
-int EM_deselect_nth(EditMesh *em, int nth)
+int EM_deselect_nth(BMEditMesh *em, int nth)
 {
-#if 0
+#if 0 //BMESH_TODO
        EditSelection *ese;
        ese = ((EditSelection*)em->selected.last);
        if(ese) {
@@ -1933,7 +1926,6 @@ static int select_sharp_edges_exec(bContext *C, wmOperator *op)
        BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
        BMIter iter;
        BMEdge *e;
-       BLI_array_declare(stack);
        BMLoop *l1, *l2;
        float sharp = RNA_float_get(op->ptr, "sharpness"), angle;
 
@@ -2170,7 +2162,7 @@ void MESH_OT_select_random(wmOperatorType *ot)
        RNA_def_boolean(ot->srna, "extend", 0, "Extend Selection", "Extend selection instead of deselecting everything first.");
 }
 
-static int select_next_loop(bContext *C, wmOperator *op)
+static int select_next_loop(bContext *C, wmOperator *UNUSED(op))
 {
        Object *obedit= CTX_data_edit_object(C);
        BMEditMesh *em= (((Mesh *)obedit->data))->edit_btmesh;
@@ -2220,7 +2212,7 @@ void MESH_OT_select_next_loop(wmOperatorType *ot)
 }
 
 
-static int region_to_loop(bContext *C, wmOperator *op)
+static int region_to_loop(bContext *C, wmOperator *UNUSED(op))
 {
        Object *obedit = CTX_data_edit_object(C);
        BMEditMesh *em = ((Mesh*)obedit->data)->edit_btmesh;
index ec8b5ffa47a2096263be5b25e20dbd812e5d36fa..ee829ac473c87d32719febf0a8048289ee473636 100644 (file)
@@ -377,7 +377,7 @@ short EDBM_Extrude_edges_indiv(BMEditMesh *em, short flag, float *nor)
 #endif
 
 /* extrudes individual vertices */
-short EDBM_Extrude_verts_indiv(BMEditMesh *em, wmOperator *op, short flag, float *nor
+short EDBM_Extrude_verts_indiv(BMEditMesh *em, wmOperator *op, short flag, float *UNUSED(nor)
 {
        BMOperator bmop;
 
@@ -3806,12 +3806,14 @@ static int mesh_separate_selected(Main *bmain, Scene *scene, Base *editbase, wmO
        return 1;
 }
 
-static int mesh_separate_material(Main *bmain, Scene *scene, Base *editbase, wmOperator *wmop)
+//BMESH_TODO
+static int mesh_separate_material(Main *UNUSED(bmain), Scene *UNUSED(scene), Base *UNUSED(editbase), wmOperator *UNUSED(wmop))
 {
        return 0;
 }
 
-static int mesh_separate_loose(Main *bmain, Scene *scene, Base *editbase, wmOperator *wmop)
+//BMESH_TODO
+static int mesh_separate_loose(Main *UNUSED(bmain), Scene *UNUSED(scene), Base *UNUSED(editbase), wmOperator *UNUSED(wmop))
 {
        return 0;
 }
@@ -4010,7 +4012,7 @@ void MESH_OT_tris_convert_to_quads(wmOperatorType *ot)
 
 }
 
-static int edge_flip_exec(bContext *C, wmOperator *op)
+static int edge_flip_exec(bContext *UNUSED(C), wmOperator *UNUSED(op))
 {
 #if 0
        Object *obedit= CTX_data_edit_object(C);
@@ -4040,7 +4042,8 @@ void MESH_OT_edge_flip(wmOperatorType *ot)
        ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
-static int split_mesh(bContext *C, wmOperator *op)
+//BMESH_TODO
+static int split_mesh(bContext *UNUSED(C), wmOperator *UNUSED(op))
 {
 #if 0
        Object *obedit= CTX_data_edit_object(C);
@@ -4079,7 +4082,7 @@ void MESH_OT_split(wmOperatorType *ot)
 }
 
 
-static int spin_mesh(bContext *C, wmOperator *op, float *dvec, int steps, float degr, int dupli )
+static int spin_mesh(bContext *UNUSED(C), wmOperator *UNUSED(op), float *UNUSED(dvec), int UNUSED(steps), float UNUSED(degr), int UNUSED(dupli) )
 {
 #if 0
        Object *obedit= CTX_data_edit_object(C);
@@ -4164,7 +4167,7 @@ static int spin_mesh(bContext *C, wmOperator *op, float *dvec, int steps, float
        return OPERATOR_CANCELLED;
 }
 
-static int spin_mesh_exec(bContext *C, wmOperator *op)
+static int spin_mesh_exec(bContext *UNUSED(C), wmOperator *UNUSED(op))
 {
 #if 0
        Object *obedit= CTX_data_edit_object(C);
@@ -4183,7 +4186,7 @@ static int spin_mesh_exec(bContext *C, wmOperator *op)
 }
 
 /* get center and axis, in global coords */
-static int spin_mesh_invoke(bContext *C, wmOperator *op, wmEvent *event)
+static int spin_mesh_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 {
 #if 0
        Scene *scene = CTX_data_scene(C);
@@ -4221,7 +4224,7 @@ void MESH_OT_spin(wmOperatorType *ot)
 
 }
 
-static int screw_mesh_exec(bContext *C, wmOperator *op)
+static int screw_mesh_exec(bContext *UNUSED(C), wmOperator *UNUSED(op))
 {
 #if 0
        Object *obedit= CTX_data_edit_object(C);
@@ -4295,7 +4298,7 @@ static int screw_mesh_exec(bContext *C, wmOperator *op)
 }
 
 /* get center and axis, in global coords */
-static int screw_mesh_invoke(bContext *C, wmOperator *op, wmEvent *event)
+static int screw_mesh_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 {
 #if 0
        Scene *scene = CTX_data_scene(C);
@@ -4330,7 +4333,7 @@ void MESH_OT_screw(wmOperatorType *ot)
        RNA_def_float_vector(ot->srna, "axis", 3, NULL, -1.0f, 1.0f, "Axis", "Axis in global view space", -FLT_MAX, FLT_MAX);
 }
 
-int select_by_number_vertices_exec(bContext *C, wmOperator *op)
+int select_by_number_vertices_exec(bContext *UNUSED(C), wmOperator *UNUSED(op))
 {
 #if 0
        Object *obedit= CTX_data_edit_object(C);
@@ -4490,7 +4493,7 @@ static void xsortvert_flag__doSetX(void *userData, EditVert *UNUSED(eve), int x,
 }
 
 /* all verts with (flag & 'flag') are sorted */
-static void xsortvert_flag(bContext *C, int flag)
+static void xsortvert_flag(bContext *UNUSED(C), int UNUSED(flag))
 {
 #if 0 //hrm, geometry isn't in linked lists anymore. . .
        ViewContext vc;
@@ -4814,7 +4817,7 @@ static int mesh_export_obj_exec(bContext *C, wmOperator *op)
        MPoly *mpoly, *mp;
        MTexPoly *mtexpoly;
        MLoopUV *luv, *mloopuv;
-       MLoopCol *lcol, *mloopcol;
+       MLoopCol *mloopcol;
        FILE *file, *matfile;
        int *face_mat_group;
        struct {Material *mat; MTexPoly poly; int end;} **matlists;
index 853903f9a444c89017f98e73a2cbb08bd2eea7c6..06ebf1e9df08eac241cd1c9d5746e5c0ef8ee7a3 100644 (file)
@@ -146,7 +146,7 @@ int EDBM_InitOpf(BMEditMesh *em, BMOperator *bmop, wmOperator *op, const char *f
 
 /*returns 0 on error, 1 on success.  executes and finishes a bmesh operator*/
 int EDBM_FinishOp(BMEditMesh *em, BMOperator *bmop, wmOperator *op, int report) {
-       char *errmsg;
+       const char *errmsg;
        
        BMO_Finish_Op(em->bm, bmop);
 
@@ -262,10 +262,9 @@ void EDBM_selectmode_to_scene(Scene *scene, Object *obedit)
        scene->toolsettings->selectmode = em->selectmode;
 }
 
-void EDBM_MakeEditBMesh(ToolSettings *ts, Scene *scene, Object *ob)
+void EDBM_MakeEditBMesh(ToolSettings *ts, Scene *UNUSED(scene), Object *ob)
 {
        Mesh *me = ob->data;
-       EditMesh *em;
        BMesh *bm;
 
        if (!me->mpoly && me->totface) {
@@ -418,7 +417,7 @@ void EDBM_select_flush(BMEditMesh *em, int selectmode)
 }
 
 /*BMESH_TODO*/
-void EDBM_deselect_flush(BMEditMesh *em)
+void EDBM_deselect_flush(BMEditMesh *UNUSED(em))
 {
 }
 
@@ -588,7 +587,7 @@ static void *editbtMesh_to_undoMesh(void *emv, void *obdata)
        return me;
 }
 
-static void undoMesh_to_editbtMesh(void *umv, void *emv, void *obdata)
+static void undoMesh_to_editbtMesh(void *umv, void *emv, void *UNUSED(obdata))
 {
        BMEditMesh *em = emv, *em2;
        Object *ob;
@@ -823,8 +822,8 @@ void EDBM_CacheMirrorVerts(BMEditMesh *em)
                em->mirr_free_arrays = 1;
        }
 
-       if (!CustomData_get_layer_named(&em->bm->vdata, CD_PROP_INT, "__mirror_index")) {
-               BM_add_data_layer_named(em->bm, &em->bm->vdata, CD_PROP_INT, "__mirror_index");
+       if (!CustomData_get_layer_named(&em->bm->vdata, CD_PROP_INT, (char*)"__mirror_index")) {
+               BM_add_data_layer_named(em->bm, &em->bm->vdata, CD_PROP_INT, (char*)"__mirror_index");
        }
 
        li = CustomData_get_named_layer_index(&em->bm->vdata, CD_PROP_INT, "__mirror_index");
index 7d44fd17c3aa1342325f452804278d738a5ee965..dfb242d714422fd975d8952df3ea8a3c7d724757 100644 (file)
@@ -300,7 +300,7 @@ void MESH_OT_primitive_circle_add(wmOperatorType *ot)
        /* props */
        RNA_def_int(ot->srna, "vertices", 32, INT_MIN, INT_MAX, "Vertices", "", 3, 500);
        RNA_def_float(ot->srna, "radius", 1.0f, 0.0, FLT_MAX, "Radius", "", 0.001, 100.00);
-       RNA_def_enum(ot->srna, "fill_type", &fill_type_items, 0, "Fill Type", "");
+       RNA_def_enum(ot->srna, "fill_type", fill_type_items, 0, "Fill Type", "");
 
        ED_object_add_generic_props(ot, TRUE);
 }
@@ -355,7 +355,7 @@ void MESH_OT_primitive_cylinder_add(wmOperatorType *ot)
        RNA_def_int(ot->srna, "vertices", 32, INT_MIN, INT_MAX, "Vertices", "", 2, 500);
        RNA_def_float(ot->srna, "radius", 1.0f, 0.0, FLT_MAX, "Radius", "", 0.001, 100.00);
        RNA_def_float(ot->srna, "depth", 1.0f, 0.0, FLT_MAX, "Depth", "", 0.001, 100.00);
-       RNA_def_enum(ot->srna, "end_fill_type", &fill_type_items, 1, "Cap Fill Type", "");
+       RNA_def_enum(ot->srna, "end_fill_type", fill_type_items, 1, "Cap Fill Type", "");
 
        ED_object_add_generic_props(ot, TRUE);
 }
@@ -411,7 +411,7 @@ void MESH_OT_primitive_cone_add(wmOperatorType *ot)
        RNA_def_float(ot->srna, "radius1", 1.0f, 0.0, FLT_MAX, "Radius 1", "", 0.001, 100.00);
        RNA_def_float(ot->srna, "radius2", 0.0f, 0.0, FLT_MAX, "Radius 2", "", 0.001, 100.00);
        RNA_def_float(ot->srna, "depth", 1.0f, 0.0, FLT_MAX, "Depth", "", 0.001, 100.00);
-       RNA_def_enum(ot->srna, "end_fill_type", &fill_type_items, 1, "Base Fill Type", "");
+       RNA_def_enum(ot->srna, "end_fill_type", fill_type_items, 1, "Base Fill Type", "");
        
        ED_object_add_generic_props(ot, TRUE);
 }
index ada81617084f0b4d85938f12acc257ff1d096a27..d7ab294d8770bef8cd2af1e1c3e2a5f98405b78e 100644 (file)
@@ -663,7 +663,6 @@ void scale_point(float *c1, float *p, float s)
 int BMBVH_EdgeVisible(BMBVHTree *tree, BMEdge *e, ARegion *ar, View3D *v3d, Object *obedit)
 {
        BMFace *f;
-       RegionView3D *rv3d = ar->regiondata;
        float co1[3], co2[3], co3[3], dir1[4], dir2[4], dir3[4];
        float origin[3], invmat[4][4];
        float epsilon = 0.01f; 
index 640fcd55d3a9dd600b9e25c0b00f2558cc3a068c..96512600dda5a45f3065b3372cf9cb2e94fcadb1 100644 (file)
@@ -249,7 +249,7 @@ int ED_mesh_uv_texture_remove(bContext *C, Object *ob, Mesh *me)
        return 1;
 }
 
-int ED_mesh_color_add(bContext *C, Scene *scene, Object *ob, Mesh *me, const char *name, int active_set)
+int ED_mesh_color_add(bContext *C, Scene *UNUSED(scene), Object *UNUSED(ob), Mesh *me, const char *name, int active_set)
 {
        BMEditMesh *em;
        MLoopCol *mcol;
index c766f05cac97093676c39910e5025cef81ebbad7..e8b4f0a1bdc29b53f00463f8041eb0184630258f 100644 (file)
@@ -556,7 +556,7 @@ static void freeMetaElemlist(ListBase *lb)
 }
 
 
-static void undoMball_to_editMball(void *lbu, void *lbe, void *obdata)
+static void undoMball_to_editMball(void *lbu, void *lbe, void *obe)
 {
        ListBase *lb= lbu;
        ListBase *editelems= lbe;
@@ -574,7 +574,7 @@ static void undoMball_to_editMball(void *lbu, void *lbe, void *obdata)
        
 }
 
-static void *editMball_to_undoMball(void *lbe, void *obdata)
+static void *editMball_to_undoMball(void *lbe, void *obe)
 {
        ListBase *editelems= lbe;
        ListBase *lb;
index 2467140bde4f514eeb6a150927f703f291d69b77..39da86b196249a2c212cdce9090c5d82eb062ef6 100644 (file)
@@ -1455,8 +1455,8 @@ void ED_screen_set_scene(bContext *C, Scene *scene)
 
                                                                                if(rv3d->persp==RV3D_CAMOB)
                                                                                        rv3d->persp= RV3D_PERSP;
-                                               }
-                                       }
+                                                                       }
+                                                               }
                                                        }
                                                }
                                        }
index 98bf1e9877f192ce4c763a22455d932dc7609547..e68e1657096dc1933becab684752ee70b1af0811 100644 (file)
@@ -1319,36 +1319,36 @@ static void pchan_draw_IK_root_lines(bPoseChannel *pchan, short only_temp)
                switch (con->type) {
                        case CONSTRAINT_TYPE_KINEMATIC:
                        {
-                       bKinematicConstraint *data = (bKinematicConstraint*)con->data;
-                       int segcount= 0;
-                       
-                       /* if only_temp, only draw if it is a temporary ik-chain */
-                       if ((only_temp) && !(data->flag & CONSTRAINT_IK_TEMP))
-                               continue;
-                       
-                       setlinestyle(3);
-                       glBegin(GL_LINES);
-                       
-                       /* exclude tip from chain? */
-                       if ((data->flag & CONSTRAINT_IK_TIP)==0)
-                               parchan= pchan->parent;
-                       else
-                               parchan= pchan;
-                       
-                       glVertex3fv(parchan->pose_tail);
-                       
-                       /* Find the chain's root */
-                       while (parchan->parent) {
-                               segcount++;
-                               if(segcount==data->rootbone || segcount>255) break; // 255 is weak
-                               parchan= parchan->parent;
+                               bKinematicConstraint *data = (bKinematicConstraint*)con->data;
+                               int segcount= 0;
+                               
+                               /* if only_temp, only draw if it is a temporary ik-chain */
+                               if ((only_temp) && !(data->flag & CONSTRAINT_IK_TEMP))
+                                       continue;
+                               
+                               setlinestyle(3);
+                               glBegin(GL_LINES);
+                               
+                               /* exclude tip from chain? */
+                               if ((data->flag & CONSTRAINT_IK_TIP)==0)
+                                       parchan= pchan->parent;
+                               else
+                                       parchan= pchan;
+                               
+                               glVertex3fv(parchan->pose_tail);
+                               
+                               /* Find the chain's root */
+                               while (parchan->parent) {
+                                       segcount++;
+                                       if(segcount==data->rootbone || segcount>255) break; // 255 is weak
+                                       parchan= parchan->parent;
+                               }
+                               if (parchan)
+                                       glVertex3fv(parchan->pose_head);
+                               
+                               glEnd();
+                               setlinestyle(0);
                        }
-                       if (parchan)
-                               glVertex3fv(parchan->pose_head);
-                       
-                       glEnd();
-                       setlinestyle(0);
-               }
                                break;
                        case CONSTRAINT_TYPE_SPLINEIK: 
                        {
@@ -1367,7 +1367,7 @@ static void pchan_draw_IK_root_lines(bPoseChannel *pchan, short only_temp)
                                        // FIXME: revise the breaking conditions
                                        if(segcount==data->chainlen || segcount>255) break; // 255 is weak
                                        parchan= parchan->parent;
-       }
+                               }
                                if (parchan) // XXX revise the breaking conditions to only stop at the tail?
                                        glVertex3fv(parchan->pose_head);
                                
@@ -1826,9 +1826,9 @@ static void draw_pose_bones(Scene *scene, View3D *v3d, ARegion *ar, Base *base,
                                                                        
                                                                        glLoadName(index & 0xFFFF);
                                                                        pchan_draw_IK_root_lines(pchan, !(do_dashed & 2));
-                                               }
+                                                               }
                                                        }       
-                                       }
+                                               }
                                        }
                                        
                                        glPushMatrix();
index d0661cea8bc672d1c9de9b978367a63262fa4b0f..62f14d4b8fe00b5b3cb3fc738870fe375cd81e8b 100644 (file)
@@ -311,7 +311,6 @@ enum {
        MOD_DISP_DIR_Z,
        MOD_DISP_DIR_NOR,
        MOD_DISP_DIR_RGB_XYZ,
-       MOD_DISP_TANGENT,
 };
 
 /* DisplaceModifierData->texmapping */
index fb04e001cad404cb5185c1e0930f875c4c04bbb3..bca9800d5ad798f821f565a3ebb924b660e2e943 100644 (file)
@@ -131,7 +131,7 @@ typedef struct Object {
 
        /* materials */
        struct Material **mat;  /* material slots */
-       char *matbits;  /* a bitfield, with each bit 1 if corrusponding material linked to object */
+       char *matbits;  /* a boolean field, with each byte 1 if corrusponding material is linked to object */
        int totcol;                             /* copy of mesh or curve or meta */
        int actcol;                             /* currently selected material in the UI */
        
index a60bb61d6b130188e049d628ea31738ec32ff43d..06770803db5998ff07e988d7a46cadc515377cf2 100644 (file)
-<<<<<<< .working
- NOTE * CLASS.FROM -> TO:   TYPE  "DESCRIPTION"
-#+ * ActionGroup.channels -> channels:   collection,  "(read-only)    F-Curves in this group"
-#+ * ActionGroup.custom_color -> custom_color:   int  "Index of custom color set"
-#+ * ActionGroup.lock -> lock:   boolean  "Action Group is locked"
-#+ * ActionGroup.name -> name:   string  "NO DESCRIPTION"
-#+ * ActionGroup.select -> select:   boolean  "Action Group is selected"
-#ActionGroup.show_expanded -> show_expanded:   boolean  "Action Group is expanded"
-#+ * Actuator.name -> name:   string  "NO DESCRIPTION"
-#Actuator.pin -> pin:   boolean  "Display when not linked to a visible states controller"
-#Actuator.show_expanded -> show_expanded:   boolean  "Set actuator expanded in the user interface"
-#+ * Actuator.type -> type:   enum  "NO DESCRIPTION"
-#+ * Actuator|ActionActuator.action -> action:   pointer  "NO DESCRIPTION"
-#Actuator|ActionActuator.frame_blend_in -> frame_blend_in:   int  "Number of frames of motion blending"
-#+ * Actuator|ActionActuator.frame_end -> frame_end:   int  "NO DESCRIPTION"
-#+ * Actuator|ActionActuator.frame_property -> frame_property:   string  "Assign the actions current frame number to this property"
-#+ * Actuator|ActionActuator.frame_start -> frame_start:   int  "NO DESCRIPTION"
-#Actuator|ActionActuator.play_mode -> play_mode:   enum  "Action playback type"
-#+ * Actuator|ActionActuator.priority -> priority:   int  "Execution priority - lower numbers will override actions with higher numbers. With 2 or more actions at once, the overriding channels must be lower in the stack"
-#+ * Actuator|ActionActuator.property -> property:   string  "Use this property to define the Action position"
-#Actuator|ActionActuator.use_continue_last_frame -> use_continue_last_frame:   boolean  "Restore last frame when switching on/off, otherwise play from the start each time"
-#+ * Actuator|ArmatureActuator.bone -> bone:   string  "Bone on which the constraint is defined"
-#+ * Actuator|ArmatureActuator.constraint -> constraint:   string  "Name of the constraint you want to control"
-#+ * Actuator|ArmatureActuator.mode -> mode:   enum  "NO DESCRIPTION"
-#+ * Actuator|ArmatureActuator.secondary_target -> secondary_target:   pointer  "Set weight of this constraint"
-#+ * Actuator|ArmatureActuator.target -> target:   pointer  "Set this object as the target of the constraint"
-#+ * Actuator|ArmatureActuator.weight -> weight:   float  "Set weight of this constraint"
-#+ * Actuator|CameraActuator.axis -> axis:   enum  "Specify the axis the Camera will try to get behind"
-#+ * Actuator|CameraActuator.height -> height:   float  "NO DESCRIPTION"
-#+ * Actuator|CameraActuator.max -> max:   float  "NO DESCRIPTION"
-#+ * Actuator|CameraActuator.min -> min:   float  "NO DESCRIPTION"
-#+ * Actuator|CameraActuator.object -> object:   pointer  "Look at this Object"
-#Actuator|ConstraintActuator.angle_max -> angle_max:   float  "Maximum angle (in degree) allowed with target direction. No correction is done if angle with target direction is between min and max"
-#Actuator|ConstraintActuator.angle_min -> angle_min:   float  "Minimum angle (in degree) to maintain with target direction. No correction is done if angle with target direction is between min and max"
-#+ * Actuator|ConstraintActuator.damping -> damping:   int  "Damping factor: time constant (in frame) of low pass filter"
-#+ * Actuator|ConstraintActuator.damping_rotation -> damping_rotation:   int  "Use a different damping for orientation"
-#+ * Actuator|ConstraintActuator.direction -> direction:   enum  "Set the direction of the ray"
-#+ * Actuator|ConstraintActuator.direction_axis -> direction_axis:   enum  "Select the axis to be aligned along the reference direction"
-#+ * Actuator|ConstraintActuator.distance -> distance:   float  "Set the maximum length of ray"
-#+ * Actuator|ConstraintActuator.fh_damping -> fh_damping:   float  "Damping factor of the Fh spring force"
-#+ * Actuator|ConstraintActuator.fh_height -> fh_height:   float  "Height of the Fh area"
-#+ * Actuator|ConstraintActuator.limit -> limit:   enum  "NO DESCRIPTION"
-#+ * Actuator|ConstraintActuator.limit_max -> limit_max:   float  "NO DESCRIPTION"
-#+ * Actuator|ConstraintActuator.limit_min -> limit_min:   float  "NO DESCRIPTION"
-#+ * Actuator|ConstraintActuator.material -> material:   string  "Ray detects only Objects with this material"
-#+ * Actuator|ConstraintActuator.mode -> mode:   enum  "The type of the constraint"
-#+ * Actuator|ConstraintActuator.property -> property:   string  "Ray detect only Objects with this property"
-#+ * Actuator|ConstraintActuator.range -> range:   float  "Set the maximum length of ray"
-#Actuator|ConstraintActuator.rotation_max -> rotation_max:   float[3]  "Reference Direction"
-#+ * Actuator|ConstraintActuator.spring -> spring:   float  "Spring force within the Fh area"
-#+ * Actuator|ConstraintActuator.time -> time:   int  "Maximum activation time in frame, 0 for unlimited"
-#Actuator|ConstraintActuator.use_fh_normal -> use_fh_normal:   boolean  "Add a horizontal spring force on slopes"
-#Actuator|ConstraintActuator.use_fh_paralel_axis -> use_fh_paralel_axis:   boolean  "Keep object axis parallel to normal"
-#Actuator|ConstraintActuator.use_force_distance -> use_force_distance:   boolean  "Force distance of object to point of impact of ray"
-#Actuator|ConstraintActuator.use_local -> use_local:   boolean  "Set ray along objects axis or global axis"
-#Actuator|ConstraintActuator.use_material_detect -> use_material_detect:   boolean  "Detect material instead of property"
-#Actuator|ConstraintActuator.use_normal -> use_normal:   boolean  "Set object axis along (local axis) or parallel (global axis) to the normal at hit position"
-#Actuator|ConstraintActuator.use_persistent -> use_persistent:   boolean  "Persistent actuator: stays active even if ray does not reach target"
-#+ * Actuator|EditObjectActuator.angular_velocity -> angular_velocity:   float[3]  "Angular velocity upon creation"
-#+ * Actuator|EditObjectActuator.dynamic_operation -> dynamic_operation:   enum  "NO DESCRIPTION"
-#+ * Actuator|EditObjectActuator.linear_velocity -> linear_velocity:   float[3]  "Velocity upon creation"
-#+ * Actuator|EditObjectActuator.mass -> mass:   float  "The mass of the object"
-#+ * Actuator|EditObjectActuator.mesh -> mesh:   pointer  "Replace the existing, when left blank Phys will remake the existing physics mesh"
-#+ * Actuator|EditObjectActuator.mode -> mode:   enum  "The mode of the actuator"
-#+ * Actuator|EditObjectActuator.object -> object:   pointer  "Add this Object and all its children (cant be on an visible layer)"
-#+ * Actuator|EditObjectActuator.time -> time:   int  "Duration the new Object lives or the track takes"
-#+ * Actuator|EditObjectActuator.track_object -> track_object:   pointer  "Track to this Object"
-#Actuator|EditObjectActuator.use_3d_tracking -> use_3d_tracking:   boolean  "Enable 3D tracking"
-#Actuator|EditObjectActuator.use_local_angular_velocity -> use_local_angular_velocity:   boolean  "Apply the rotation locally"
-#Actuator|EditObjectActuator.use_local_linear_velocity -> use_local_linear_velocity:   boolean  "Apply the transformation locally"
-#Actuator|EditObjectActuator.use_replace_display_mesh -> use_replace_display_mesh:   boolean  "Replace the display mesh"
-#Actuator|EditObjectActuator.use_replace_physics_mesh -> use_replace_physics_mesh:   boolean  "Replace the physics mesh (triangle bounds only - compound shapes not supported)"
-#Actuator|FCurveActuator.apply_to_children -> apply_to_children:   boolean  "Update F-Curve on all children Objects as well"
-#Actuator|FCurveActuator.frame_end -> frame_end:   int  "NO DESCRIPTION"
-#Actuator|FCurveActuator.frame_property -> frame_property:   string  "Assign the actions current frame number to this property"
-#Actuator|FCurveActuator.frame_start -> frame_start:   int  "NO DESCRIPTION"
-#Actuator|FCurveActuator.play_type -> play_type:   enum  "Specify the way you want to play the animation"
-#Actuator|FCurveActuator.property -> property:   string  "Use this property to define the F-Curve position"
-#Actuator|FCurveActuator.use_additive -> use_additive:   boolean  "F-Curve is added to the current loc/rot/scale in global or local coordinate according to Local flag"
-#Actuator|FCurveActuator.use_force -> use_force:   boolean  "Apply F-Curve as a global or local force depending on the local option (dynamic objects only)"
-#Actuator|FCurveActuator.use_local -> use_local:   boolean  "Let the F-Curve act in local coordinates, used in Force and Add mode"
-#+ * Actuator|Filter2DActuator.filter_pass -> filter_pass:   int  "Set filter order"
-#+ * Actuator|Filter2DActuator.glsl_shader -> glsl_shader:   pointer  "NO DESCRIPTION"
-#+ * Actuator|Filter2DActuator.mode -> mode:   enum  "NO DESCRIPTION"
-#+ * Actuator|Filter2DActuator.motion_blur_factor -> motion_blur_factor:   float  "Set motion blur factor"
-#Actuator|Filter2DActuator.use_motion_blur -> use_motion_blur:   boolean  "Enable/Disable Motion Blur"
-#+ * Actuator|GameActuator.filename -> filename:   string  "Load this blend file, use the // prefix for a path relative to the current blend file"
-#+ * Actuator|GameActuator.mode -> mode:   enum  "NO DESCRIPTION"
-#+ * Actuator|MessageActuator.body_message -> body_message:   string  "Optional message body Text"
-#+ * Actuator|MessageActuator.body_property -> body_property:   string  "The message body will be set by the Property Value"
-#+ * Actuator|MessageActuator.body_type -> body_type:   enum  "Toggle message type: either Text or a PropertyName"
-#+ * Actuator|MessageActuator.subject -> subject:   string  "Optional message subject. This is what can be filtered on"
-#+ * Actuator|MessageActuator.to_property -> to_property:   string  "Optional send message to objects with this name only, or empty to broadcast"
-#+ * Actuator|ObjectActuator.angular_velocity -> angular_velocity:   float[3]  "Sets the angular velocity"
-#+ * Actuator|ObjectActuator.damping -> damping:   int  "Number of frames to reach the target velocity"
-#+ * Actuator|ObjectActuator.derivate_coefficient -> derivate_coefficient:   float  "Not required, high values can cause instability"
-#+ * Actuator|ObjectActuator.force -> force:   float[3]  "Sets the force"
-#+ * Actuator|ObjectActuator.force_max_x -> force_max_x:   float  "Set the upper limit for force"
-#+ * Actuator|ObjectActuator.force_max_y -> force_max_y:   float  "Set the upper limit for force"
-#+ * Actuator|ObjectActuator.force_max_z -> force_max_z:   float  "Set the upper limit for force"
-#+ * Actuator|ObjectActuator.force_min_x -> force_min_x:   float  "Set the lower limit for force"
-#+ * Actuator|ObjectActuator.force_min_y -> force_min_y:   float  "Set the lower limit for force"
-#+ * Actuator|ObjectActuator.force_min_z -> force_min_z:   float  "Set the lower limit for force"
-#+ * Actuator|ObjectActuator.integral_coefficient -> integral_coefficient:   float  "Low value (0.01) for slow response, high value (0.5) for fast response"
-#+ * Actuator|ObjectActuator.linear_velocity -> linear_velocity:   float[3]  "Sets the linear velocity (in Servo mode it sets the target relative linear velocity, it will be achieved by automatic application of force. Null velocity is a valid target)"
-#+ * Actuator|ObjectActuator.mode -> mode:   enum  "Specify the motion system"
-#Actuator|ObjectActuator.offset_location -> offset_location:   float[3]  "Sets the location"
-#Actuator|ObjectActuator.offset_rotation -> offset_rotation:   float[3]  "Sets the rotation"
-#+ * Actuator|ObjectActuator.proportional_coefficient -> proportional_coefficient:   float  "Typical value is 60x integral coefficient"
-#+ * Actuator|ObjectActuator.reference_object -> reference_object:   pointer  "Reference object for velocity calculation, leave empty for world reference"
-#+ * Actuator|ObjectActuator.torque -> torque:   float[3]  "Sets the torque"
-#Actuator|ObjectActuator.use_add_linear_velocity -> use_add_linear_velocity:   boolean  "Toggles between ADD and SET linV"
-#Actuator|ObjectActuator.use_local_angular_velocity -> use_local_angular_velocity:   boolean  "Angular velocity is defined in local coordinates"
-#Actuator|ObjectActuator.use_local_force -> use_local_force:   boolean  "Force is defined in local coordinates"
-#Actuator|ObjectActuator.use_local_linear_velocity -> use_local_linear_velocity:   boolean  "Velocity is defined in local coordinates"
-#Actuator|ObjectActuator.use_local_location -> use_local_location:   boolean  "Location is defined in local coordinates"
-#Actuator|ObjectActuator.use_local_rotation -> use_local_rotation:   boolean  "Rotation is defined in local coordinates"
-#Actuator|ObjectActuator.use_local_torque -> use_local_torque:   boolean  "Torque is defined in local coordinates"
-#Actuator|ObjectActuator.use_servo_limit_x -> use_servo_limit_x:   boolean  "Set limit to force along the X axis"
-#Actuator|ObjectActuator.use_servo_limit_y -> use_servo_limit_y:   boolean  "Set limit to force along the Y axis"
-#Actuator|ObjectActuator.use_servo_limit_z -> use_servo_limit_z:   boolean  "Set limit to force along the Z axis"
-#+ * Actuator|ParentActuator.mode -> mode:   enum  "NO DESCRIPTION"
-#+ * Actuator|ParentActuator.object -> object:   pointer  "Set this object as parent"
-#Actuator|ParentActuator.use_compound -> use_compound:   boolean  "Add this object shape to the parent shape (only if the parent shape is already compound)"
-#Actuator|ParentActuator.use_ghost -> use_ghost:   boolean  "Make this object ghost while parented (only if not compound)"
-#+ * Actuator|PropertyActuator.mode -> mode:   enum  "NO DESCRIPTION"
-#+ * Actuator|PropertyActuator.object -> object:   pointer  "Copy from this Object"
-#+ * Actuator|PropertyActuator.object_property -> object_property:   string  "Copy this property"
-#+ * Actuator|PropertyActuator.property -> property:   string  "The name of the property"
-#+ * Actuator|PropertyActuator.value -> value:   string  "The value to use, use  around strings"
-#+ * Actuator|RandomActuator.chance -> chance:   float  "Pick a number between 0 and 1. Success if you stay below this value"
-#+ * Actuator|RandomActuator.distribution -> distribution:   enum  "Choose the type of distribution"
-#+ * Actuator|RandomActuator.float_max -> float_max:   float  "Choose a number from a range. Upper boundary of the range"
-#+ * Actuator|RandomActuator.float_mean -> float_mean:   float  "A normal distribution. Mean of the distribution"
-#+ * Actuator|RandomActuator.float_min -> float_min:   float  "Choose a number from a range. Lower boundary of the range"
-#+ * Actuator|RandomActuator.float_value -> float_value:   float  "Always return this number"
-#+ * Actuator|RandomActuator.half_life_time -> half_life_time:   float  "Negative exponential dropoff"
-#+ * Actuator|RandomActuator.int_max -> int_max:   int  "Choose a number from a range. Upper boundary of the range"
-#+ * Actuator|RandomActuator.int_mean -> int_mean:   float  "Expected mean value of the distribution"
-#+ * Actuator|RandomActuator.int_min -> int_min:   int  "Choose a number from a range. Lower boundary of the range"
-#+ * Actuator|RandomActuator.int_value -> int_value:   int  "Always return this number"
-#+ * Actuator|RandomActuator.property -> property:   string  "Assign the random value to this property"
-#+ * Actuator|RandomActuator.seed -> seed:   int  "Initial seed of the random generator. Use Python for more freedom (choose 0 for not random)"
-#+ * Actuator|RandomActuator.standard_derivation -> standard_derivation:   float  "A normal distribution. Standard deviation of the distribution"
-#Actuator|RandomActuator.use_always_true -> use_always_true:   boolean  "Always false or always true"
-#+ * Actuator|SceneActuator.camera -> camera:   pointer  "Set this Camera. Leave empty to refer to self object"
-#+ * Actuator|SceneActuator.mode -> mode:   enum  "NO DESCRIPTION"
-#+ * Actuator|SceneActuator.scene -> scene:   pointer  "Set the Scene to be added/removed/paused/resumed"
-#+ * Actuator|ShapeActionActuator.action -> action:   pointer  "NO DESCRIPTION"
-#Actuator|ShapeActionActuator.frame_blend_in -> frame_blend_in:   int  "Number of frames of motion blending"
-#+ * Actuator|ShapeActionActuator.frame_end -> frame_end:   int  "NO DESCRIPTION"
-#+ * Actuator|ShapeActionActuator.frame_property -> frame_property:   string  "Assign the actions current frame number to this property"
-#+ * Actuator|ShapeActionActuator.frame_start -> frame_start:   int  "NO DESCRIPTION"
-#+ * Actuator|ShapeActionActuator.mode -> mode:   enum  "Action playback type"
-#+ * Actuator|ShapeActionActuator.priority -> priority:   int  "Execution priority - lower numbers will override actions with higher numbers. With 2 or more actions at once, the overriding channels must be lower in the stack"
-#+ * Actuator|ShapeActionActuator.property -> property:   string  "Use this property to define the Action position"
-#Actuator|ShapeActionActuator.use_continue_last_frame -> use_continue_last_frame:   boolean  "Restore last frame when switching on/off, otherwise play from the start each time"
-#+ * Actuator|SoundActuator.cone_inner_angle_3d -> cone_inner_angle_3d:   float  "The angle of the inner cone"
-#+ * Actuator|SoundActuator.cone_outer_angle_3d -> cone_outer_angle_3d:   float  "The angle of the outer cone"
-#+ * Actuator|SoundActuator.cone_outer_gain_3d -> cone_outer_gain_3d:   float  "The gain outside the outer cone. The gain in the outer cone will be interpolated between this value and the normal gain in the inner cone"
-#Actuator|SoundActuator.distance_3d_max -> distance_3d_max:   float  "The maximum distance at which you can hear the sound"
-#Actuator|SoundActuator.distance_3d_reference -> distance_3d_reference:   float  "The distance where the sound has a gain of 1.0"
-#Actuator|SoundActuator.gain_3d_max -> gain_3d_max:   float  "The maximum gain of the sound, no matter how near it is"
-#Actuator|SoundActuator.gain_3d_min -> gain_3d_min:   float  "The minimum gain of the sound, no matter how far it is away"
-#+ * Actuator|SoundActuator.mode -> mode:   enum  "NO DESCRIPTION"
-#+ * Actuator|SoundActuator.pitch -> pitch:   float  "Sets the pitch of the sound"
-#+ * Actuator|SoundActuator.rolloff_factor_3d -> rolloff_factor_3d:   float  "The influence factor on volume depending on distance"
-#+ * Actuator|SoundActuator.sound -> sound:   pointer  "NO DESCRIPTION"
-#Actuator|SoundActuator.use_sound_3d -> use_sound_3d:   boolean  "Enable/Disable 3D Sound"
-#+ * Actuator|SoundActuator.volume -> volume:   float  "Sets the initial volume of the sound"
-#+ * Actuator|StateActuator.operation -> operation:   enum  "Select the bit operation on object state mask"
-#Actuator|StateActuator.states -> states:   boolean[30]  "NO DESCRIPTION"
-#Actuator|VisibilityActuator.apply_to_children -> apply_to_children:   boolean  "Set all the children of this object to the same visibility/occlusion recursively"
-#Actuator|VisibilityActuator.use_occlusion -> use_occlusion:   boolean  "Set the object to occlude objects behind it. Initialized from the object type in physics button"
-#Actuator|VisibilityActuator.use_visible -> use_visible:   boolean  "Set the objects visible. Initialized from the objects render restriction toggle (access in the outliner)"
-#+ * Addon.module -> module:   string  "Module name"
-#+ * AnimData.action -> action:   pointer  "Active Action for this datablock"
-#AnimData.action_blend_type -> action_blend_type:   enum  "Method used for combining Active Actions result with result of NLA stack"
-#+ * AnimData.action_extrapolation -> action_extrapolation:   enum  "Action to take for gaps past the Active Actions range (when evaluating with NLA)"
-#+ * AnimData.action_influence -> action_influence:   float  "Amount the Active Action contributes to the result of the NLA stack"
-#+ * AnimData.drivers -> drivers:   collection,  "(read-only)    The Drivers/Expressions for this datablock"
-#+ * AnimData.nla_tracks -> nla_tracks:   collection,  "(read-only)    NLA Tracks (i.e. Animation Layers)"
-#AnimData.use_nla -> use_nla:   boolean  "NLA stack is evaluated when evaluating this block"
-#AnimViz.motion_path -> motion_path:   pointer,  "(read-only)    Motion Path settings for visualisation"
-#AnimViz.onion_skin_frames -> onion_skin_frames:   pointer,  "(read-only)    Onion Skinning (ghosting) settings for visualisation"
-#+ * AnimVizMotionPaths.bake_location -> bake_location:   enum  "When calculating Bone Paths, use Head or Tips"
-#AnimVizMotionPaths.frame_after -> frame_after:   int  "Number of frames to show after the current frame (only for Around Current Frame Onion-skinning method)"
-#AnimVizMotionPaths.frame_before -> frame_before:   int  "Number of frames to show before the current frame (only for Around Current Frame Onion-skinning method)"
-#+ * AnimVizMotionPaths.frame_end -> frame_end:   int  "End frame of range of paths to display/calculate (not for Around Current Frame Onion-skinning method)"
-#+ * AnimVizMotionPaths.frame_start -> frame_start:   int  "Starting frame of range of paths to display/calculate (not for Around Current Frame Onion-skinning method)"
-#+ * AnimVizMotionPaths.frame_step -> frame_step:   int  "Number of frames between paths shown (not for On Keyframes Onion-skinning method)"
-#+ * AnimVizMotionPaths.show_frame_numbers -> show_frame_numbers:   boolean  "Show frame numbers on Motion Paths"
-#AnimVizMotionPaths.show_keyframe_action_all -> show_keyframe_action_all:   boolean  "For bone motion paths, search whole Action for keyframes instead of in group with matching name only (is slower)"
-#AnimVizMotionPaths.show_keyframe_highlight -> show_keyframe_highlight:   boolean  "Emphasize position of keyframes on Motion Paths"
-#+ * AnimVizMotionPaths.show_keyframe_numbers -> show_keyframe_numbers:   boolean  "Show frame numbers of Keyframes on Motion Paths"
-#+ * AnimVizMotionPaths.type -> type:   enum  "Type of range to show for Motion Paths"
-#AnimVizOnionSkinning.frame_after -> frame_after:   int  "Number of frames to show after the current frame (only for Around Current Frame Onion-skinning method)"
-#AnimVizOnionSkinning.frame_before -> frame_before:   int  "Number of frames to show before the current frame (only for Around Current Frame Onion-skinning method)"
-#+ * AnimVizOnionSkinning.frame_end -> frame_end:   int  "End frame of range of Ghosts to display (not for Around Current Frame Onion-skinning method)"
-#+ * AnimVizOnionSkinning.frame_start -> frame_start:   int  "Starting frame of range of Ghosts to display (not for Around Current Frame Onion-skinning method)"
-#+ * AnimVizOnionSkinning.frame_step -> frame_step:   int  "Number of frames between ghosts shown (not for On Keyframes Onion-skinning method)"
-#AnimVizOnionSkinning.show_only_selected -> show_only_selected:   boolean  "For Pose-Mode drawing, only draw ghosts for selected bones"
-#+ * AnimVizOnionSkinning.type -> type:   enum  "Method used for determining what ghosts get drawn"
-#MAKE PROPERTY OF A COLLECTION * Area.active_space -> active_space:   pointer,  "(read-only)    Space currently being displayed in this area"
-#+ * Area.regions -> regions:   collection,  "(read-only)    Regions this area is subdivided in"
-#+ * Area.show_menus -> show_menus:   boolean  "Show menus in the header"
-#+ * Area.spaces -> spaces:   collection,  "(read-only)    Spaces contained in this area, the first space is active"
-#+ * Area.type -> type:   enum  "Space type"
-#+ * ArmatureBones.active -> active:   pointer  "Armatures active bone"
-#+ * ArmatureEditBones.active -> active:   pointer  "Armatures active edit bone"
-#+ * BackgroundImage.image -> image:   pointer  "Image displayed and edited in this space"
-#+ * BackgroundImage.image_user -> image_user:   pointer,  "(read-only)    Parameters defining which layer, pass and frame of the image is displayed"
-#+ * BackgroundImage.offset_x -> offset_x:   float  "Offsets image horizontally from the world origin"
-#+ * BackgroundImage.offset_y -> offset_y:   float  "Offsets image vertically from the world origin"
-#+ * BackgroundImage.show_expanded -> show_expanded:   boolean  "Show the expanded in the user interface"
-#+ * BackgroundImage.size -> size:   float  "Scaling factor for the background image"
-#+ * BackgroundImage.transparency -> transparency:   float  "Amount to blend the image against the background color"
-#+ * BackgroundImage.view_axis -> view_axis:   enum  "The axis to display the image on"
-#+ * BezierSplinePoint.co -> co:   float[3]  "Coordinates of the control point"
-#BezierSplinePoint.handle_left -> handle_left:   float[3]  "Coordinates of the first handle"
-#BezierSplinePoint.handle_left_type -> handle_left_type:   enum  "Handle types"
-#BezierSplinePoint.handle_right -> handle_right:   float[3]  "Coordinates of the second handle"
-#BezierSplinePoint.handle_right_type -> handle_right_type:   enum  "Handle types"
-#+ * BezierSplinePoint.hide -> hide:   boolean  "Visibility status"
-#+ * BezierSplinePoint.radius -> radius:   float,  "(read-only)    Radius for bevelling"
-#+ * BezierSplinePoint.select_control_point -> select_control_point:   boolean  "Control point selection status"
-#+ * BezierSplinePoint.select_left_handle -> select_left_handle:   boolean  "Handle 1 selection status"
-#+ * BezierSplinePoint.select_right_handle -> select_right_handle:   boolean  "Handle 2 selection status"
-#+ * BezierSplinePoint.tilt -> tilt:   float  "Tilt in 3D View"
-#+ * BezierSplinePoint.weight -> weight:   float  "Softbody goal weight"
-#+ * BlenderRNA.structs -> structs:   collection,  "(read-only)"
-#+ * BoidRule.name -> name:   string  "Boid rule name"
-#+ * BoidRule.type -> type:   enum,  "(read-only)"
-#BoidRule.use_in_air -> use_in_air:   boolean  "Use rule when boid is flying"
-#BoidRule.use_on_land -> use_on_land:   boolean  "Use rule when boid is on land"
-#+ * BoidRule|BoidRuleAverageSpeed.level -> level:   float  "How much velocitys z-component is kept constant"
-#+ * BoidRule|BoidRuleAverageSpeed.speed -> speed:   float  "Percentage of maximum speed"
-#+ * BoidRule|BoidRuleAverageSpeed.wander -> wander:   float  "How fast velocitys direction is randomized"
-#+ * BoidRule|BoidRuleAvoid.fear_factor -> fear_factor:   float  "Avoid object if danger from it is above this threshold"
-#+ * BoidRule|BoidRuleAvoid.object -> object:   pointer  "Object to avoid"
-#BoidRule|BoidRuleAvoid.use_predict -> use_predict:   boolean  "Predict target movement"
-#+ * BoidRule|BoidRuleAvoidCollision.look_ahead -> look_ahead:   float  "Time to look ahead in seconds"
-#BoidRule|BoidRuleAvoidCollision.use_avoid -> use_avoid:   boolean  "Avoid collision with other boids"
-#BoidRule|BoidRuleAvoidCollision.use_avoid_collision -> use_avoid_collision:   boolean  "Avoid collision with deflector objects"
-#+ * BoidRule|BoidRuleFight.distance -> distance:   float  "Attack boids at max this distance"
-#+ * BoidRule|BoidRuleFight.flee_distance -> flee_distance:   float  "Flee to this distance"
-#+ * BoidRule|BoidRuleFollowLeader.distance -> distance:   float  "Distance behind leader to follow"
-#+ * BoidRule|BoidRuleFollowLeader.object -> object:   pointer  "Follow this object instead of a boid"
-#BoidRule|BoidRuleFollowLeader.queue_count -> queue_count:   int  "How many boids in a line"
-#BoidRule|BoidRuleFollowLeader.use_line -> use_line:   boolean  "Follow leader in a line"
-#+ * BoidRule|BoidRuleGoal.object -> object:   pointer  "Goal object"
-#BoidRule|BoidRuleGoal.use_predict -> use_predict:   boolean  "Predict target movement"
-#+ * BoidSettings.accuracy -> accuracy:   float  "Accuracy of attack"
-#+ * BoidSettings.active_boid_state -> active_boid_state:   pointer,  "(read-only)"
-#+ * BoidSettings.active_boid_state_index -> active_boid_state_index:   int  "NO DESCRIPTION"
-#+ * BoidSettings.aggression -> aggression:   float  "Boid will fight this times stronger enemy"
-#BoidSettings.air_acc_max -> air_acc_max:   float  "Maximum acceleration in air (relative to maximum speed)"
-#BoidSettings.air_ave_max -> air_ave_max:   float  "Maximum angular velocity in air (relative to 180 degrees)"
-#+ * BoidSettings.air_personal_space -> air_personal_space:   float  "Radius of boids personal space in air (% of particle size)"
-#BoidSettings.air_speed_max -> air_speed_max:   float  "Maximum speed in air"
-#BoidSettings.air_speed_min -> air_speed_min:   float  "Minimum speed in air (relative to maximum speed)"
-#BoidSettings.bank -> bank:   float  "Amount of rotation around velocity vector on turns"
-#+ * BoidSettings.health -> health:   float  "Initial boid health when born"
-#+ * BoidSettings.height -> height:   float  "Boid height relative to particle size"
-#BoidSettings.land_acc_max -> land_acc_max:   float  "Maximum acceleration on land (relative to maximum speed)"
-#BoidSettings.land_ave_max -> land_ave_max:   float  "Maximum angular velocity on land (relative to 180 degrees)"
-#+ * BoidSettings.land_jump_speed -> land_jump_speed:   float  "Maximum speed for jumping"
-#+ * BoidSettings.land_personal_space -> land_personal_space:   float  "Radius of boids personal space on land (% of particle size)"
-#BoidSettings.land_smooth -> land_smooth:   float  "How smoothly the boids land"
-#BoidSettings.land_speed_max -> land_speed_max:   float  "Maximum speed on land"
-#+ * BoidSettings.land_stick_force -> land_stick_force:   float  "How strong a force must be to start effecting a boid on land"
-#+ * BoidSettings.range -> range:   float  "The maximum distance from which a boid can attack"
-#+ * BoidSettings.states -> states:   collection,  "(read-only)"
-#+ * BoidSettings.strength -> strength:   float  "Maximum caused damage on attack per second"
-#BoidSettings.use_climb -> use_climb:   boolean  "Allow boids to climb goal objects"
-#BoidSettings.use_flight -> use_flight:   boolean  "Allow boids to move in air"
-#BoidSettings.use_land -> use_land:   boolean  "Allow boids to move on land"
-#+ * BoidState.active_boid_rule -> active_boid_rule:   pointer,  "(read-only)"
-#+ * BoidState.active_boid_rule_index -> active_boid_rule_index:   int  "NO DESCRIPTION"
-#+ * BoidState.falloff -> falloff:   float  "NO DESCRIPTION"
-#+ * BoidState.name -> name:   string  "Boid state name"
-#BoidState.rule_fuzzy -> rule_fuzzy:   float  "NO DESCRIPTION"
-#+ * BoidState.rules -> rules:   collection,  "(read-only)"
-#+ * BoidState.ruleset_type -> ruleset_type:   enum  "How the rules in the list are evaluated"
-#+ * BoidState.volume -> volume:   float  "NO DESCRIPTION"
-#+ * Bone.bbone_in -> bbone_in:   float  "Length of first Bezier Handle (for B-Bones only)"
-#+ * Bone.bbone_out -> bbone_out:   float  "Length of second Bezier Handle (for B-Bones only)"
-#+ * Bone.bbone_segments -> bbone_segments:   int  "Number of subdivisions of bone (for B-Bones only)"
-#+ * Bone.children -> children:   collection,  "(read-only)    Bones which are children of this bone"
-#+ * Bone.envelope_distance -> envelope_distance:   float  "Bone deformation distance (for Envelope deform only)"
-#+ * Bone.envelope_weight -> envelope_weight:   float  "Bone deformation weight (for Envelope deform only)"
-#+ * Bone.head -> head:   float[3]  "Location of head end of the bone relative to its parent"
-#+ * Bone.head_local -> head_local:   float[3]  "Location of head end of the bone relative to armature"
-#+ * Bone.head_radius -> head_radius:   float  "Radius of head of bone (for Envelope deform only)"
-#+ * Bone.hide -> hide:   boolean  "Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)"
-#+ * Bone.hide_select -> hide_select:   boolean  "Bone is able to be selected"
-#Bone.layers -> layers:   boolean[32]  "Layers bone exists in"
-#+ * Bone.matrix -> matrix:   float[9]  "3x3 bone matrix"
-#+ * Bone.matrix_local -> matrix_local:   float[16]  "4x4 bone matrix relative to armature"
-#+ * Bone.name -> name:   string  "NO DESCRIPTION"
-#+ * Bone.parent -> parent:   pointer,  "(read-only)    Parent bone (in same Armature)"
-#+ * Bone.select -> select:   boolean  "NO DESCRIPTION"
-#Bone.show_wire -> show_wire:   boolean  "Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes"
-#+ * Bone.tail -> tail:   float[3]  "Location of tail end of the bone"
-#+ * Bone.tail_local -> tail_local:   float[3]  "Location of tail end of the bone relative to armature"
-#+ * Bone.tail_radius -> tail_radius:   float  "Radius of tail of bone (for Envelope deform only)"
-#Bone.use_connect -> use_connect:   boolean,  "(read-only)    When bone has a parent, bones head is struck to the parents tail"
-#Bone.use_cyclic_offset -> use_cyclic_offset:   boolean  "When bone doesnt have a parent, it receives cyclic offset effects"
-#Bone.use_deform -> use_deform:   boolean  "Bone does not deform any geometry"
-#Bone.use_envelope_multiply -> use_envelope_multiply:   boolean  "When deforming bone, multiply effects of Vertex Group weights with Envelope influence"
-#Bone.use_hinge -> use_hinge:   boolean  "Bone inherits rotation or scale from parent bone"
-#Bone.use_inherit_scale -> use_inherit_scale:   boolean  "Bone inherits scaling from parent bone"
-#Bone.use_local_location -> use_local_location:   boolean  "Bone location is set in local space"
-#+ * BoneGroup.color_set -> color_set:   enum  "Custom color set to use"
-#+ * BoneGroup.colors -> colors:   pointer,  "(read-only)    Copy of the colors associated with the groups color set"
-#+ * BoneGroup.name -> name:   string  "NO DESCRIPTION"
-#BoneGroups.active -> active:   pointer  "Active bone group for this pose"
-#+ * ClothCollisionSettings.collision_quality -> collision_quality:   int  "How many collision iterations should be done. (higher is better quality but slower)"
-#ClothCollisionSettings.distance_min -> distance_min:   float  "Minimum distance between collision objects before collision response takes in"
-#+ * ClothCollisionSettings.friction -> friction:   float  "Friction force if a collision happened. (higher = less movement)"
-#+ * ClothCollisionSettings.group -> group:   pointer  "Limit colliders to this Group"
-#+ * ClothCollisionSettings.self_collision_quality -> self_collision_quality:   int  "How many self collision iterations should be done. (higher is better quality but slower)"
-#ClothCollisionSettings.self_distance_min -> self_distance_min:   float  "0.5 means no distance at all, 1.0 is maximum distance"
-#+ * ClothCollisionSettings.self_friction -> self_friction:   float  "Friction/damping with self contact"
-#ClothCollisionSettings.use_collision -> use_collision:   boolean  "Enable collisions with other objects"
-#ClothCollisionSettings.use_self_collision -> use_self_collision:   boolean  "Enable self collisions"
-#+ * ClothSettings.air_damping -> air_damping:   float  "Air has normally some thickness which slows falling things down"
-#+ * ClothSettings.bending_stiffness -> bending_stiffness:   float  "Wrinkle coefficient. (higher = less smaller but more big wrinkles)"
-#+ * ClothSettings.bending_stiffness_max -> bending_stiffness_max:   float  "Maximum bending stiffness value"
-#+ * ClothSettings.bending_vertex_group -> bending_vertex_group:   string  "Vertex group for fine control over bending stiffness"
-#+ * ClothSettings.collider_friction -> collider_friction:   float  "NO DESCRIPTION"
-#+ * ClothSettings.effector_weights -> effector_weights:   pointer,  "(read-only)"
-#+ * ClothSettings.goal_default -> goal_default:   float  "Default Goal (vertex target position) value, when no Vertex Group used"
-#+ * ClothSettings.goal_friction -> goal_friction:   float  "Goal (vertex target position) friction"
-#+ * ClothSettings.goal_max -> goal_max:   float  "Goal maximum, vertex group weights are scaled to match this range"
-#+ * ClothSettings.goal_min -> goal_min:   float  "Goal minimum, vertex group weights are scaled to match this range"
-#+ * ClothSettings.goal_spring -> goal_spring:   float  "Goal (vertex target position) spring stiffness"
-#+ * ClothSettings.gravity -> gravity:   float[3]  "Gravity or external force vector"
-#+ * ClothSettings.internal_friction -> internal_friction:   float  "NO DESCRIPTION"
-#+ * ClothSettings.mass -> mass:   float  "Mass of cloth material"
-#+ * ClothSettings.mass_vertex_group -> mass_vertex_group:   string  "Vertex Group for pinning of vertices"
-#+ * ClothSettings.pin_stiffness -> pin_stiffness:   float  "Pin (vertex target position) spring stiffness"
-#+ * ClothSettings.pre_roll -> pre_roll:   int  "Simulation starts on this frame"
-#+ * ClothSettings.quality -> quality:   int  "Quality of the simulation in steps per frame. (higher is better quality but slower)"
-#+ * ClothSettings.rest_shape_key -> rest_shape_key:   pointer  "Shape key to use the rest spring lengths from"
-#+ * ClothSettings.spring_damping -> spring_damping:   float  "Damping of cloth velocity. (higher = more smooth, less jiggling)"
-#+ * ClothSettings.structural_stiffness -> structural_stiffness:   float  "Overall stiffness of structure"
-#+ * ClothSettings.structural_stiffness_max -> structural_stiffness_max:   float  "Maximum structural stiffness value"
-#+ * ClothSettings.structural_stiffness_vertex_group -> structural_stiffness_vertex_group:   string  "Vertex group for fine control over structural stiffness"
-#ClothSettings.use_pin_cloth -> use_pin_cloth:   boolean  "Enable pinning of cloth vertices to other objects/positions"
-#ClothSettings.use_stiffness_scale -> use_stiffness_scale:   boolean  "If enabled, stiffness can be scaled along a weight painted vertex group"
-#+ * CollisionSettings.absorption -> absorption:   float  "How much of effector force gets lost during collision with this object (in percent)"
-#+ * CollisionSettings.damping -> damping:   float  "Amount of damping during collision"
-#+ * CollisionSettings.damping_factor -> damping_factor:   float  "Amount of damping during particle collision"
-#CollisionSettings.damping_random -> damping_random:   float  "Random variation of damping"
-#+ * CollisionSettings.friction_factor -> friction_factor:   float  "Amount of friction during particle collision"
-#CollisionSettings.friction_random -> friction_random:   float  "Random variation of friction"
-#+ * CollisionSettings.permeability -> permeability:   float  "Chance that the particle will pass through the mesh"
-#+ * CollisionSettings.stickness -> stickness:   float  "Amount of stickness to surface collision"
-#CollisionSettings.thickness_inner -> thickness_inner:   float  "Inner face thickness"
-#CollisionSettings.thickness_outer -> thickness_outer:   float  "Outer face thickness"
-#+ * CollisionSettings.use -> use:   boolean  "Enable this objects as a collider for physics systems"
-#CollisionSettings.use_particle_kill -> use_particle_kill:   boolean  "Kill collided particles"
-#+ * ColorRamp.elements -> elements:   collection,  "(read-only)"
-#+ * ColorRamp.interpolation -> interpolation:   enum  "NO DESCRIPTION"
-#+ * ColorRampElement.color -> color:   float[4]  "NO DESCRIPTION"
-#+ * ColorRampElement.position -> position:   float  "NO DESCRIPTION"
-#ConsoleLine.body -> body:   string  "Text in the line"
-#+ * ConsoleLine.current_character -> current_character:   int  "NO DESCRIPTION"
-#+ * Constraint.active -> active:   boolean  "Constraint is the one being edited"
-#Constraint.error_location -> error_location:   float,  "(read-only)    Amount of residual error in Blender space unit for constraints that work on position"
-#Constraint.error_rotation -> error_rotation:   float,  "(read-only)    Amount of residual error in radiant for constraints that work on orientation"
-#+ * Constraint.influence -> influence:   float  "Amount of influence constraint will have on the final solution"
-#Constraint.is_proxy_local -> is_proxy_local:   boolean  "Constraint was added in this proxy instance (i.e. did not belong to source Armature)"
-#Constraint.is_valid -> is_valid:   boolean,  "(read-only)    Constraint has invalid settings and will not be evaluated"
-#+ * Constraint.mute -> mute:   boolean  "Enable/Disable Constraint"
-#+ * Constraint.name -> name:   string  "Constraint name"
-#+ * Constraint.owner_space -> owner_space:   enum  "Space that owner is evaluated in"
-#Constraint.show_expanded -> show_expanded:   boolean  "Constraints panel is expanded in UI"
-#+ * Constraint.target_space -> target_space:   enum  "Space that target is evaluated in"
-#+ * Constraint.type -> type:   enum,  "(read-only)"
-#+ * ConstraintTarget.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * ConstraintTarget.target -> target:   pointer  "Target Object"
-#+ * Constraint|ActionConstraint.action -> action:   pointer  "NO DESCRIPTION"
-#+ * Constraint|ActionConstraint.frame_end -> frame_end:   int  "Last frame of the Action to use"
-#+ * Constraint|ActionConstraint.frame_start -> frame_start:   int  "First frame of the Action to use"
-#Constraint|ActionConstraint.max -> max:   float  "Maximum value for target channel range"
-#Constraint|ActionConstraint.min -> min:   float  "Minimum value for target channel range"
-#+ * Constraint|ActionConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|ActionConstraint.target -> target:   pointer  "Target Object"
-#+ * Constraint|ActionConstraint.transform_channel -> transform_channel:   enum  "Transformation channel from the target that is used to key the Action"
-#+ * Constraint|ChildOfConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|ChildOfConstraint.target -> target:   pointer  "Target Object"
-#+ * Constraint|ChildOfConstraint.use_location_x -> use_location_x:   boolean  "Use X Location of Parent"
-#+ * Constraint|ChildOfConstraint.use_location_y -> use_location_y:   boolean  "Use Y Location of Parent"
-#+ * Constraint|ChildOfConstraint.use_location_z -> use_location_z:   boolean  "Use Z Location of Parent"
-#+ * Constraint|ChildOfConstraint.use_rotation_x -> use_rotation_x:   boolean  "Use X Rotation of Parent"
-#+ * Constraint|ChildOfConstraint.use_rotation_y -> use_rotation_y:   boolean  "Use Y Rotation of Parent"
-#+ * Constraint|ChildOfConstraint.use_rotation_z -> use_rotation_z:   boolean  "Use Z Rotation of Parent"
-#+ * Constraint|ChildOfConstraint.use_scale_x -> use_scale_x:   boolean  "Use X Scale of Parent"
-#+ * Constraint|ChildOfConstraint.use_scale_y -> use_scale_y:   boolean  "Use Y Scale of Parent"
-#+ * Constraint|ChildOfConstraint.use_scale_z -> use_scale_z:   boolean  "Use Z Scale of Parent"
-#+ * Constraint|ClampToConstraint.main_axis -> main_axis:   enum  "Main axis of movement"
-#+ * Constraint|ClampToConstraint.target -> target:   pointer  "Target Object"
-#Constraint|ClampToConstraint.use_cyclic -> use_cyclic:   boolean  "Treat curve as cyclic curve (no clamping to curve bounding box"
-#+ * Constraint|CopyLocationConstraint.head_tail -> head_tail:   float  "Target along length of bone: Head=0, Tail=1"
-#+ * Constraint|CopyLocationConstraint.invert_x -> invert_x:   boolean  "Invert the X location"
-#+ * Constraint|CopyLocationConstraint.invert_y -> invert_y:   boolean  "Invert the Y location"
-#+ * Constraint|CopyLocationConstraint.invert_z -> invert_z:   boolean  "Invert the Z location"
-#+ * Constraint|CopyLocationConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|CopyLocationConstraint.target -> target:   pointer  "Target Object"
-#+ * Constraint|CopyLocationConstraint.use_offset -> use_offset:   boolean  "Add original location into copied location"
-#+ * Constraint|CopyLocationConstraint.use_x -> use_x:   boolean  "Copy the targets X location"
-#+ * Constraint|CopyLocationConstraint.use_y -> use_y:   boolean  "Copy the targets Y location"
-#+ * Constraint|CopyLocationConstraint.use_z -> use_z:   boolean  "Copy the targets Z location"
-#+ * Constraint|CopyRotationConstraint.invert_x -> invert_x:   boolean  "Invert the X rotation"
-#+ * Constraint|CopyRotationConstraint.invert_y -> invert_y:   boolean  "Invert the Y rotation"
-#+ * Constraint|CopyRotationConstraint.invert_z -> invert_z:   boolean  "Invert the Z rotation"
-#+ * Constraint|CopyRotationConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|CopyRotationConstraint.target -> target:   pointer  "Target Object"
-#+ * Constraint|CopyRotationConstraint.use_offset -> use_offset:   boolean  "Add original rotation into copied rotation"
-#+ * Constraint|CopyRotationConstraint.use_x -> use_x:   boolean  "Copy the targets X rotation"
-#+ * Constraint|CopyRotationConstraint.use_y -> use_y:   boolean  "Copy the targets Y rotation"
-#+ * Constraint|CopyRotationConstraint.use_z -> use_z:   boolean  "Copy the targets Z rotation"
-#+ * Constraint|CopyScaleConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|CopyScaleConstraint.target -> target:   pointer  "Target Object"
-#+ * Constraint|CopyScaleConstraint.use_offset -> use_offset:   boolean  "Add original scale into copied scale"
-#+ * Constraint|CopyScaleConstraint.use_x -> use_x:   boolean  "Copy the targets X scale"
-#+ * Constraint|CopyScaleConstraint.use_y -> use_y:   boolean  "Copy the targets Y scale"
-#+ * Constraint|CopyScaleConstraint.use_z -> use_z:   boolean  "Copy the targets Z scale"
-#+ * Constraint|CopyTransformsConstraint.head_tail -> head_tail:   float  "Target along length of bone: Head=0, Tail=1"
-#+ * Constraint|CopyTransformsConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|CopyTransformsConstraint.target -> target:   pointer  "Target Object"
-#+ * Constraint|DampedTrackConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|DampedTrackConstraint.target -> target:   pointer  "Target Object"
-#Constraint|DampedTrackConstraint.track_axis -> track_axis:   enum  "Axis that points to the target object"
-#+ * Constraint|FloorConstraint.floor_location -> floor_location:   enum  "Location of target that object will not pass through"
-#+ * Constraint|FloorConstraint.offset -> offset:   float  "Offset of floor from object origin"
-#+ * Constraint|FloorConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|FloorConstraint.target -> target:   pointer  "Target Object"
-#+ * Constraint|FloorConstraint.use_rotation -> use_rotation:   boolean  "Use the targets rotation to determine floor"
-#Constraint|FloorConstraint.use_sticky -> use_sticky:   boolean  "Immobilize object while constrained"
-#Constraint|FollowPathConstraint.forward_axis -> forward_axis:   enum  "Axis that points forward along the path"
-#+ * Constraint|FollowPathConstraint.offset -> offset:   int  "Offset from the position corresponding to the time frame"
-#+ * Constraint|FollowPathConstraint.offset_factor -> offset_factor:   float  "Percentage value defining target position along length of bone"
-#+ * Constraint|FollowPathConstraint.target -> target:   pointer  "Target Object"
-#Constraint|FollowPathConstraint.up_axis -> up_axis:   enum  "Axis that points upward"
-#+ * Constraint|FollowPathConstraint.use_curve_follow -> use_curve_follow:   boolean  "Object will follow the heading and banking of the curve"
-#+ * Constraint|FollowPathConstraint.use_curve_radius -> use_curve_radius:   boolean  "Objects scale by the curve radius"
-#Constraint|FollowPathConstraint.use_fixed_location -> use_fixed_location:   boolean  "Object will stay locked to a single point somewhere along the length of the curve regardless of time"
-#Constraint|KinematicConstraint.chain_count -> chain_count:   int  "How many bones are included in the IK effect - 0 uses all bones"
-#+ * Constraint|KinematicConstraint.distance -> distance:   float  "Radius of limiting sphere"
-#+ * Constraint|KinematicConstraint.ik_type -> ik_type:   enum  "NO DESCRIPTION"
-#+ * Constraint|KinematicConstraint.iterations -> iterations:   int  "Maximum number of solving iterations"
-#+ * Constraint|KinematicConstraint.limit_mode -> limit_mode:   enum  "Distances in relation to sphere of influence to allow"
-#Constraint|KinematicConstraint.lock_location_x -> lock_location_x:   boolean  "Constraint position along X axis"
-#Constraint|KinematicConstraint.lock_location_y -> lock_location_y:   boolean  "Constraint position along Y axis"
-#Constraint|KinematicConstraint.lock_location_z -> lock_location_z:   boolean  "Constraint position along Z axis"
-#Constraint|KinematicConstraint.lock_rotation_x -> lock_rotation_x:   boolean  "Constraint rotation along X axis"
-#Constraint|KinematicConstraint.lock_rotation_y -> lock_rotation_y:   boolean  "Constraint rotation along Y axis"
-#Constraint|KinematicConstraint.lock_rotation_z -> lock_rotation_z:   boolean  "Constraint rotation along Z axis"
-#+ * Constraint|KinematicConstraint.orient_weight -> orient_weight:   float  "For Tree-IK: Weight of orientation control for this target"
-#+ * Constraint|KinematicConstraint.pole_angle -> pole_angle:   float  "Pole rotation offset"
-#+ * Constraint|KinematicConstraint.pole_subtarget -> pole_subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|KinematicConstraint.pole_target -> pole_target:   pointer  "Object for pole rotation"
-#Constraint|KinematicConstraint.reference_axis -> reference_axis:   enum  "Constraint axis Lock options relative to Bone or Target reference"
-#+ * Constraint|KinematicConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|KinematicConstraint.target -> target:   pointer  "Target Object"
-#Constraint|KinematicConstraint.use_location -> use_location:   boolean  "Chain follows position of target"
-#+ * Constraint|KinematicConstraint.use_rotation -> use_rotation:   boolean  "Chain follows rotation of target"
-#+ * Constraint|KinematicConstraint.use_stretch -> use_stretch:   boolean  "Enable IK Stretching"
-#+ * Constraint|KinematicConstraint.use_tail -> use_tail:   boolean  "Include bones tail as last element in chain"
-#+ * Constraint|KinematicConstraint.use_target -> use_target:   boolean  "Disable for targetless IK"
-#+ * Constraint|KinematicConstraint.weight -> weight:   float  "For Tree-IK: Weight of position control for this target"
-#+ * Constraint|LimitDistanceConstraint.distance -> distance:   float  "Radius of limiting sphere"
-#+ * Constraint|LimitDistanceConstraint.limit_mode -> limit_mode:   enum  "Distances in relation to sphere of influence to allow"
-#+ * Constraint|LimitDistanceConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|LimitDistanceConstraint.target -> target:   pointer  "Target Object"
-#Constraint|LimitLocationConstraint.max_x -> max_x:   float  "Highest X value to allow"
-#Constraint|LimitLocationConstraint.max_y -> max_y:   float  "Highest Y value to allow"
-#Constraint|LimitLocationConstraint.max_z -> max_z:   float  "Highest Z value to allow"
-#Constraint|LimitLocationConstraint.min_x -> min_x:   float  "Lowest X value to allow"
-#Constraint|LimitLocationConstraint.min_y -> min_y:   float  "Lowest Y value to allow"
-#Constraint|LimitLocationConstraint.min_z -> min_z:   float  "Lowest Z value to allow"
-#Constraint|LimitLocationConstraint.use_max_x -> use_max_x:   boolean  "Use the maximum X value"
-#Constraint|LimitLocationConstraint.use_max_y -> use_max_y:   boolean  "Use the maximum Y value"
-#Constraint|LimitLocationConstraint.use_max_z -> use_max_z:   boolean  "Use the maximum Z value"
-#Constraint|LimitLocationConstraint.use_min_x -> use_min_x:   boolean  "Use the minimum X value"
-#Constraint|LimitLocationConstraint.use_min_y -> use_min_y:   boolean  "Use the minimum Y value"
-#Constraint|LimitLocationConstraint.use_min_z -> use_min_z:   boolean  "Use the minimum Z value"
-#Constraint|LimitLocationConstraint.use_transform_limit -> use_transform_limit:   boolean  "Transforms are affected by this constraint as well"
-#Constraint|LimitRotationConstraint.max_x -> max_x:   float  "Highest X value to allow"
-#Constraint|LimitRotationConstraint.max_y -> max_y:   float  "Highest Y value to allow"
-#Constraint|LimitRotationConstraint.max_z -> max_z:   float  "Highest Z value to allow"
-#Constraint|LimitRotationConstraint.min_x -> min_x:   float  "Lowest X value to allow"
-#Constraint|LimitRotationConstraint.min_y -> min_y:   float  "Lowest Y value to allow"
-#Constraint|LimitRotationConstraint.min_z -> min_z:   float  "Lowest Z value to allow"
-#+ * Constraint|LimitRotationConstraint.use_limit_x -> use_limit_x:   boolean  "Use the minimum X value"
-#+ * Constraint|LimitRotationConstraint.use_limit_y -> use_limit_y:   boolean  "Use the minimum Y value"
-#+ * Constraint|LimitRotationConstraint.use_limit_z -> use_limit_z:   boolean  "Use the minimum Z value"
-#Constraint|LimitRotationConstraint.use_transform_limit -> use_transform_limit:   boolean  "Transforms are affected by this constraint as well"
-#Constraint|LimitScaleConstraint.max_x -> max_x:   float  "Highest X value to allow"
-#Constraint|LimitScaleConstraint.max_y -> max_y:   float  "Highest Y value to allow"
-#Constraint|LimitScaleConstraint.max_z -> max_z:   float  "Highest Z value to allow"
-#Constraint|LimitScaleConstraint.min_x -> min_x:   float  "Lowest X value to allow"
-#Constraint|LimitScaleConstraint.min_y -> min_y:   float  "Lowest Y value to allow"
-#Constraint|LimitScaleConstraint.min_z -> min_z:   float  "Lowest Z value to allow"
-#Constraint|LimitScaleConstraint.use_max_x -> use_max_x:   boolean  "Use the maximum X value"
-#Constraint|LimitScaleConstraint.use_max_y -> use_max_y:   boolean  "Use the maximum Y value"
-#Constraint|LimitScaleConstraint.use_max_z -> use_max_z:   boolean  "Use the maximum Z value"
-#Constraint|LimitScaleConstraint.use_min_x -> use_min_x:   boolean  "Use the minimum X value"
-#Constraint|LimitScaleConstraint.use_min_y -> use_min_y:   boolean  "Use the minimum Y value"
-#Constraint|LimitScaleConstraint.use_min_z -> use_min_z:   boolean  "Use the minimum Z value"
-#Constraint|LimitScaleConstraint.use_transform_limit -> use_transform_limit:   boolean  "Transforms are affected by this constraint as well"
-#Constraint|LockedTrackConstraint.lock_axis -> lock_axis:   enum  "Axis that points upward"
-#+ * Constraint|LockedTrackConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|LockedTrackConstraint.target -> target:   pointer  "Target Object"
-#Constraint|LockedTrackConstraint.track_axis -> track_axis:   enum  "Axis that points to the target object"
-#Constraint|MaintainVolumeConstraint.free_axis -> free_axis:   enum  "The free scaling axis of the object"
-#+ * Constraint|MaintainVolumeConstraint.volume -> volume:   float  "Volume of the bone at rest"
-#+ * Constraint|PivotConstraint.head_tail -> head_tail:   float  "Target along length of bone: Head=0, Tail=1"
-#+ * Constraint|PivotConstraint.offset -> offset:   float[3]  "Offset of pivot from target (when set), or from owners location (when Fixed Position is off), or the absolute pivot point"
-#Constraint|PivotConstraint.rotation_range -> rotation_range:   enum  "Rotation range on which pivoting should occur"
-#+ * Constraint|PivotConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|PivotConstraint.target -> target:   pointer  "Target Object, defining the position of the pivot when defined"
-#Constraint|PivotConstraint.use_relative_location -> use_relative_location:   boolean  "Offset will be an absolute point in space instead of relative to the target"
-#Constraint|PythonConstraint.has_script_error -> has_script_error:   boolean,  "(read-only)    The linked Python script has thrown an error"
-#Constraint|PythonConstraint.target_count -> target_count:   int  "Usually only 1-3 are needed"
-#+ * Constraint|PythonConstraint.targets -> targets:   collection,  "(read-only)    Target Objects"
-#+ * Constraint|PythonConstraint.text -> text:   pointer  "The text object that contains the Python script"
-#+ * Constraint|PythonConstraint.use_targets -> use_targets:   boolean  "Use the targets indicated in the constraint panel"
-#+ * Constraint|RigidBodyJointConstraint.axis_x -> axis_x:   float  "Rotate pivot on X axis in degrees"
-#+ * Constraint|RigidBodyJointConstraint.axis_y -> axis_y:   float  "Rotate pivot on Y axis in degrees"
-#+ * Constraint|RigidBodyJointConstraint.axis_z -> axis_z:   float  "Rotate pivot on Z axis in degrees"
-#+ * Constraint|RigidBodyJointConstraint.child -> child:   pointer  "Child object"
-#+ * Constraint|RigidBodyJointConstraint.pivot_type -> pivot_type:   enum  "NO DESCRIPTION"
-#+ * Constraint|RigidBodyJointConstraint.pivot_x -> pivot_x:   float  "Offset pivot on X"
-#+ * Constraint|RigidBodyJointConstraint.pivot_y -> pivot_y:   float  "Offset pivot on Y"
-#+ * Constraint|RigidBodyJointConstraint.pivot_z -> pivot_z:   float  "Offset pivot on Z"
-#Constraint|RigidBodyJointConstraint.show_pivot -> show_pivot:   boolean  "Display the pivot point and rotation in 3D view"
-#+ * Constraint|RigidBodyJointConstraint.target -> target:   pointer  "Target Object"
-#Constraint|RigidBodyJointConstraint.use_linked_collision -> use_linked_collision:   boolean  "Disable collision between linked bodies"
-#+ * Constraint|ShrinkwrapConstraint.distance -> distance:   float  "Distance to Target"
-#+ * Constraint|ShrinkwrapConstraint.shrinkwrap_type -> shrinkwrap_type:   enum  "Selects type of shrinkwrap algorithm for target position"
-#+ * Constraint|ShrinkwrapConstraint.target -> target:   pointer  "Target Object"
-#+ * Constraint|ShrinkwrapConstraint.use_x -> use_x:   boolean  "Projection over X Axis"
-#+ * Constraint|ShrinkwrapConstraint.use_y -> use_y:   boolean  "Projection over Y Axis"
-#+ * Constraint|ShrinkwrapConstraint.use_z -> use_z:   boolean  "Projection over Z Axis"
-#Constraint|SplineIKConstraint.chain_count -> chain_count:   int  "How many bones are included in the chain"
-#+ * Constraint|SplineIKConstraint.joint_bindings -> joint_bindings:   float[32]  "(EXPERIENCED USERS ONLY) The relative positions of the joints along the chain as percentages"
-#+ * Constraint|SplineIKConstraint.target -> target:   pointer  "Curve that controls this relationship"
-#Constraint|SplineIKConstraint.use_chain_offset -> use_chain_offset:   boolean  "Offset the entire chain relative to the root joint"
-#+ * Constraint|SplineIKConstraint.use_curve_radius -> use_curve_radius:   boolean  "Average radius of the endpoints is used to tweak the X and Z Scaling of the bones, on top of XZ Scale mode"
-#Constraint|SplineIKConstraint.use_even_divisions -> use_even_divisions:   boolean  "Ignore the relative lengths of the bones when fitting to the curve"
-#Constraint|SplineIKConstraint.use_y_stretch -> use_y_stretch:   boolean  "Stretch the Y axis of the bones to fit the curve"
-#Constraint|SplineIKConstraint.xz_scale_mode -> xz_scale_mode:   enum  "Method used for determining the scaling of the X and Z axes of the bones"
-#+ * Constraint|StretchToConstraint.bulge -> bulge:   float  "Factor between volume variation and stretching"
-#+ * Constraint|StretchToConstraint.head_tail -> head_tail:   float  "Target along length of bone: Head=0, Tail=1"
-#+ * Constraint|StretchToConstraint.keep_axis -> keep_axis:   enum  "Axis to maintain during stretch"
-#Constraint|StretchToConstraint.rest_length -> rest_length:   float  "Length at rest position"
-#+ * Constraint|StretchToConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|StretchToConstraint.target -> target:   pointer  "Target Object"
-#+ * Constraint|StretchToConstraint.volume -> volume:   enum  "Maintain the objects volume as it stretches"
-#+ * Constraint|TrackToConstraint.head_tail -> head_tail:   float  "Target along length of bone: Head=0, Tail=1"
-#+ * Constraint|TrackToConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|TrackToConstraint.target -> target:   pointer  "Target Object"
-#Constraint|TrackToConstraint.track_axis -> track_axis:   enum  "Axis that points to the target object"
-#Constraint|TrackToConstraint.up_axis -> up_axis:   enum  "Axis that points upward"
-#Constraint|TrackToConstraint.use_target_z -> use_target_z:   boolean  "Targets Z axis, not World Z axis, will constraint the Up direction"
-#+ * Constraint|TransformConstraint.from_max_x -> from_max_x:   float  "Top range of X axis source motion"
-#+ * Constraint|TransformConstraint.from_max_y -> from_max_y:   float  "Top range of Y axis source motion"
-#+ * Constraint|TransformConstraint.from_max_z -> from_max_z:   float  "Top range of Z axis source motion"
-#+ * Constraint|TransformConstraint.from_min_x -> from_min_x:   float  "Bottom range of X axis source motion"
-#+ * Constraint|TransformConstraint.from_min_y -> from_min_y:   float  "Bottom range of Y axis source motion"
-#+ * Constraint|TransformConstraint.from_min_z -> from_min_z:   float  "Bottom range of Z axis source motion"
-#+ * Constraint|TransformConstraint.map_from -> map_from:   enum  "The transformation type to use from the target"
-#+ * Constraint|TransformConstraint.map_to -> map_to:   enum  "The transformation type to affect of the constrained object"
-#+ * Constraint|TransformConstraint.map_to_x_from -> map_to_x_from:   enum  "The source axis constrained objects X axis uses"
-#+ * Constraint|TransformConstraint.map_to_y_from -> map_to_y_from:   enum  "The source axis constrained objects Y axis uses"
-#+ * Constraint|TransformConstraint.map_to_z_from -> map_to_z_from:   enum  "The source axis constrained objects Z axis uses"
-#+ * Constraint|TransformConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
-#+ * Constraint|TransformConstraint.target -> target:   pointer  "Target Object"
-#+ * Constraint|TransformConstraint.to_max_x -> to_max_x:   float  "Top range of X axis destination motion"
-#+ * Constraint|TransformConstraint.to_max_y -> to_max_y:   float  "Top range of Y axis destination motion"
-#+ * Constraint|TransformConstraint.to_max_z -> to_max_z:   float  "Top range of Z axis destination motion"
-#+ * Constraint|TransformConstraint.to_min_x -> to_min_x:   float  "Bottom range of X axis destination motion"
-#+ * Constraint|TransformConstraint.to_min_y -> to_min_y:   float  "Bottom range of Y axis destination motion"
-#+ * Constraint|TransformConstraint.to_min_z -> to_min_z:   float  "Bottom range of Z axis destination motion"
-#Constraint|TransformConstraint.use_motion_extrapolate -> use_motion_extrapolate:   boolean  "Extrapolate ranges"
-#+ * Context.area -> area:   pointer,  "(read-only)"
-#+ * Context.main -> main:   pointer,  "(read-only)"
-#+ * Context.mode -> mode:   enum,  "(read-only)"
-#+ * Context.region -> region:   pointer,  "(read-only)"
-#+ * Context.region_data -> region_data:   pointer,  "(read-only)"
-#+ * Context.scene -> scene:   pointer,  "(read-only)"
-#+ * Context.screen -> screen:   pointer,  "(read-only)"
-#+ * Context.space_data -> space_data:   pointer,  "(read-only)"
-#+ * Context.tool_settings -> tool_settings:   pointer,  "(read-only)"
-#+ * Context.user_preferences -> user_preferences:   pointer,  "(read-only)"
-#+ * Context.window -> window:   pointer,  "(read-only)"
- + * Context.manager -> wm:   pointer,  "(read-only)"
-#+ * Controller.name -> name:   string  "NO DESCRIPTION"
-#Controller.show_expanded -> show_expanded:   boolean  "Set controller expanded in the user interface"
-#Controller.states -> states:   int  "Set Controller state index (1 to 30)"
-#+ * Controller.type -> type:   enum  "NO DESCRIPTION"
-#Controller.use_priority -> use_priority:   boolean  "Mark controller for execution before all non-marked controllers (good for startup scripts)"
-#+ * Controller|ExpressionController.expression -> expression:   string  "NO DESCRIPTION"
-#+ * Controller|PythonController.mode -> mode:   enum  "Python script type (textblock or module - faster)"
-#+ * Controller|PythonController.module -> module:   string  "Module name and function to run e.g. someModule.main. Internal texts and external python files can be used"
-#+ * Controller|PythonController.text -> text:   pointer  "Text datablock with the python script"
-#Controller|PythonController.use_debug -> use_debug:   boolean  "Continuously reload the module from disk for editing external modules without restarting"
-#+ * CurveMap.extend -> extend:   enum,  "(read-only)    Extrapolate the curve or extend it horizontally"
-#+ * CurveMap.points -> points:   collection,  "(read-only)"
-#+ * CurveMapPoint.handle_type -> handle_type:   enum,  "(read-only)    Curve interpolation at this point: bezier or vector"
-#+ * CurveMapPoint.location -> location:   float[2],  "(read-only)    X/Y coordinates of the curve point"
-#+ * CurveMapPoint.select -> select:   boolean  "Selection state of the curve point"
-#+ * CurveMapping.black_level -> black_level:   float[3]  "For RGB curves, the color that black is mapped to"
-#+ * CurveMapping.clip_max_x -> clip_max_x:   float  "NO DESCRIPTION"
-#+ * CurveMapping.clip_max_y -> clip_max_y:   float  "NO DESCRIPTION"
-#+ * CurveMapping.clip_min_x -> clip_min_x:   float  "NO DESCRIPTION"
-#+ * CurveMapping.clip_min_y -> clip_min_y:   float  "NO DESCRIPTION"
-#+ * CurveMapping.curves -> curves:   collection,  "(read-only)"
-#CurveMapping.use_clip -> use_clip:   boolean  "Force the curve view to fit a defined boundary"
-#+ * CurveMapping.white_level -> white_level:   float[3]  "For RGB curves, the color that white is mapped to"
-#+ * CurveSplines.active -> active:   pointer  "Active curve spline"
-#DopeSheet.filter_group -> filter_group:   pointer  "Group that included Object should be a member of"
-#DopeSheet.show_armatures -> show_armatures:   boolean  "Include visualization of Armature related Animation data"
-#DopeSheet.show_cameras -> show_cameras:   boolean  "Include visualization of Camera related Animation data"
-#DopeSheet.show_curves -> show_curves:   boolean  "Include visualization of Curve related Animation data"
-#DopeSheet.show_expanded_summary -> show_expanded_summary:   boolean  "Collapse summary when shown, so all other channels get hidden. (DopeSheet Editors Only)"
-#DopeSheet.show_hidden -> show_hidden:   boolean  "Include channels from objects/bone that arent visible"
-#DopeSheet.show_lamps -> show_lamps:   boolean  "Include visualization of Lamp related Animation data"
-#DopeSheet.show_materials -> show_materials:   boolean  "Include visualization of Material related Animation data"
-#DopeSheet.show_meshes -> show_meshes:   boolean  "Include visualization of Mesh related Animation data"
-#DopeSheet.show_metaballs -> show_metaballs:   boolean  "Include visualization of Metaball related Animation data"
-#DopeSheet.show_missing_nla -> show_missing_nla:   boolean  "Include Animation Data blocks with no NLA data. (NLA Editor only)"
-#DopeSheet.show_nodes -> show_nodes:   boolean  "Include visualization of Node related Animation data"
-#DopeSheet.show_only_group_objects -> show_only_group_objects:   boolean  "Only include channels from Objects in the specified Group"
-#DopeSheet.show_only_selected -> show_only_selected:   boolean  "Only include channels relating to selected objects and data"
-#DopeSheet.show_particles -> show_particles:   boolean  "Include visualization of Particle related Animation data"
-#DopeSheet.show_scenes -> show_scenes:   boolean  "Include visualization of Scene related Animation data"
-#DopeSheet.show_shapekeys -> show_shapekeys:   boolean  "Include visualization of ShapeKey related Animation data"
-#DopeSheet.show_summary -> show_summary:   boolean  "Display an additional summary line. (DopeSheet Editors only)"
-#DopeSheet.show_textures -> show_textures:   boolean  "Include visualization of Texture related Animation data"
-#DopeSheet.show_transforms -> show_transforms:   boolean  "Include visualization of Object-level Animation data (mostly Transforms)"
-#DopeSheet.show_worlds -> show_worlds:   boolean  "Include visualization of World related Animation data"
-#+ * DopeSheet.source -> source:   pointer,  "(read-only)    ID-Block representing source data, currently ID_SCE (for Dopesheet), and ID_SC (for Grease Pencil)"
-#+ * Driver.expression -> expression:   string  "Expression to use for Scripted Expression"
-#Driver.is_valid -> is_valid:   boolean  "Driver could not be evaluated in past, so should be skipped"
-#+ * Driver.show_debug_info -> show_debug_info:   boolean  "Show intermediate values for the driver calculations to allow debugging of drivers"
-#+ * Driver.type -> type:   enum  "Driver type"
-#+ * Driver.variables -> variables:   collection,  "(read-only)    Properties acting as inputs for this driver"
-#+ * DriverTarget.bone_target -> bone_target:   string  "Name of PoseBone to use as target"
-#+ * DriverTarget.data_path -> data_path:   string  "RNA Path (from ID-block) to property used"
-#+ * DriverTarget.id -> id:   pointer  "ID-block that the specific property used can be found from (id_type property must be set first)"
-#+ * DriverTarget.id_type -> id_type:   enum  "Type of ID-block that can be used"
-#+ * DriverTarget.transform_type -> transform_type:   enum  "Driver variable type"
-#DriverTarget.use_local_space_transform -> use_local_space_transform:   boolean  "Use transforms in Local Space (as opposed to the worldspace default)"
-#+ * DriverVariable.name -> name:   string  "Name to use in scripted expressions/functions. (No spaces or dots are allowed. Also, must not start with a symbol or digit)"
-#+ * DriverVariable.targets -> targets:   collection,  "(read-only)    Sources of input data for evaluating this variable"
-#+ * DriverVariable.type -> type:   enum  "Driver variable type"
-#+ * DupliObject.matrix -> matrix:   float[16]  "Object duplicate transformation matrix"
-#+ * DupliObject.matrix_original -> matrix_original:   float[16]  "The original matrix of this object before it was duplicated"
-#+ * DupliObject.object -> object:   pointer,  "(read-only)    Object being duplicated"
-#+ * EditBone.bbone_in -> bbone_in:   float  "Length of first Bezier Handle (for B-Bones only)"
-#+ * EditBone.bbone_out -> bbone_out:   float  "Length of second Bezier Handle (for B-Bones only)"
-#+ * EditBone.bbone_segments -> bbone_segments:   int  "Number of subdivisions of bone (for B-Bones only)"
-#+ * EditBone.envelope_distance -> envelope_distance:   float  "Bone deformation distance (for Envelope deform only)"
-#+ * EditBone.envelope_weight -> envelope_weight:   float  "Bone deformation weight (for Envelope deform only)"
-#+ * EditBone.head -> head:   float[3]  "Location of head end of the bone"
-#+ * EditBone.head_radius -> head_radius:   float  "Radius of head of bone (for Envelope deform only)"
-#+ * EditBone.hide -> hide:   boolean  "Bone is not visible when in Edit Mode"
-#+ * EditBone.hide_select -> hide_select:   boolean  "Bone is able to be selected"
-#EditBone.layers -> layers:   boolean[32]  "Layers bone exists in"
-#+ * EditBone.lock -> lock:   boolean  "Bone is not able to be transformed when in Edit Mode"
-#+ * EditBone.matrix -> matrix:   float[16],  "(read-only)    Read-only matrix calculated from the roll (armature space)"
-#+ * EditBone.name -> name:   string  "NO DESCRIPTION"
-#+ * EditBone.parent -> parent:   pointer  "Parent edit bone (in same Armature)"
-#+ * EditBone.roll -> roll:   float  "Bone rotation around head-tail axis"
-#+ * EditBone.select -> select:   boolean  "NO DESCRIPTION"
-#+ * EditBone.select_head -> select_head:   boolean  "NO DESCRIPTION"
-#+ * EditBone.select_tail -> select_tail:   boolean  "NO DESCRIPTION"
-#EditBone.show_wire -> show_wire:   boolean  "Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes"
-#+ * EditBone.tail -> tail:   float[3]  "Location of tail end of the bone"
-#+ * EditBone.tail_radius -> tail_radius:   float  "Radius of tail of bone (for Envelope deform only)"
-#EditBone.use_connect -> use_connect:   boolean  "When bone has a parent, bones head is struck to the parents tail"
-#EditBone.use_cyclic_offset -> use_cyclic_offset:   boolean  "When bone doesnt have a parent, it receives cyclic offset effects"
-#EditBone.use_deform -> use_deform:   boolean  "Bone does not deform any geometry"
-#EditBone.use_envelope_multiply -> use_envelope_multiply:   boolean  "When deforming bone, multiply effects of Vertex Group weights with Envelope influence"
-#EditBone.use_hinge -> use_hinge:   boolean  "Bone inherits rotation or scale from parent bone"
-#EditBone.use_inherit_scale -> use_inherit_scale:   boolean  "Bone inherits scaling from parent bone"
-#EditBone.use_local_location -> use_local_location:   boolean  "Bone location is set in local space"
-#+ * EffectorWeights.all -> all:   float  "All effectors weight"
-#EffectorWeights.apply_to_hair_growing -> apply_to_hair_growing:   boolean  "Use force fields when growing hair"
-#+ * EffectorWeights.boid -> boid:   float  "Boid effector weight"
-#+ * EffectorWeights.charge -> charge:   float  "Charge effector weight"
-#EffectorWeights.curve_guide -> curve_guide:   float  "Curve guide effector weight"
-#+ * EffectorWeights.drag -> drag:   float  "Drag effector weight"
-#+ * EffectorWeights.force -> force:   float  "Force effector weight"
-#+ * EffectorWeights.gravity -> gravity:   float  "Global gravity weight"
-#+ * EffectorWeights.group -> group:   pointer  "Limit effectors to this Group"
-#+ * EffectorWeights.harmonic -> harmonic:   float  "Harmonic effector weight"
-#+ * EffectorWeights.lennardjones -> lennardjones:   float  "Lennard-Jones effector weight"
-#+ * EffectorWeights.magnetic -> magnetic:   float  "Magnetic effector weight"
-#+ * EffectorWeights.texture -> texture:   float  "Texture effector weight"
-#+ * EffectorWeights.turbulence -> turbulence:   float  "Turbulence effector weight"
-#+ * EffectorWeights.vortex -> vortex:   float  "Vortex effector weight"
-#+ * EffectorWeights.wind -> wind:   float  "Wind effector weight"
-#+ * EnumPropertyItem.description -> description:   string,  "(read-only)    Description of the items purpose"
-#+ * EnumPropertyItem.identifier -> identifier:   string,  "(read-only)    Unique name used in the code and scripting"
-#+ * EnumPropertyItem.name -> name:   string,  "(read-only)    Human readable name"
-#+ * EnumPropertyItem.value -> value:   int,  "(read-only)    Value of the item"
-#+ * EnvironmentMap.clip_end -> clip_end:   float  "Objects further than this are not visible to map"
-#+ * EnvironmentMap.clip_start -> clip_start:   float  "Objects nearer than this are not visible to map"
-#+ * EnvironmentMap.depth -> depth:   int  "Number of times a map will be rendered recursively (mirror effects.)"
-#EnvironmentMap.layers_ignore -> layers_ignore:   boolean[20]  "Hide objects on these layers when generating the Environment Map"
-#+ * EnvironmentMap.mapping -> mapping:   enum  "NO DESCRIPTION"
-#+ * EnvironmentMap.resolution -> resolution:   int  "Pixel resolution of the rendered environment map"
-#+ * EnvironmentMap.source -> source:   enum  "NO DESCRIPTION"
-#+ * EnvironmentMap.viewpoint_object -> viewpoint_object:   pointer  "Object to use as the environment maps viewpoint location"
-#+ * EnvironmentMap.zoom -> zoom:   float  "NO DESCRIPTION"
-#+ * Event.ascii -> ascii:   string,  "(read-only)    Single ASCII character for this event"
- + * Event.alt -> is_pressed_alt:   boolean,  "(read-only)    True when the Alt/Option key is held"
- + * Event.oskey -> is_pressed_cmd:   boolean,  "(read-only)    True when the Cmd key is held"
- + * Event.ctrl -> is_pressed_ctrl:   boolean,  "(read-only)    True when the Ctrl key is held"
- + * Event.shift -> is_pressed_shift:   boolean,  "(read-only)    True when the Shift key is held"
-#+ * Event.mouse_prev_x -> mouse_prev_x:   int,  "(read-only)    The window relative vertical location of the mouse"
-#+ * Event.mouse_prev_y -> mouse_prev_y:   int,  "(read-only)    The window relative horizontal location of the mouse"
-#+ * Event.mouse_region_x -> mouse_region_x:   int,  "(read-only)    The region relative vertical location of the mouse"
-#+ * Event.mouse_region_y -> mouse_region_y:   int,  "(read-only)    The region relative horizontal location of the mouse"
-#+ * Event.mouse_x -> mouse_x:   int,  "(read-only)    The window relative vertical location of the mouse"
-#+ * Event.mouse_y -> mouse_y:   int,  "(read-only)    The window relative horizontal location of the mouse"
-#+ * Event.type -> type:   enum,  "(read-only)"
-#+ * Event.value -> value:   enum,  "(read-only)    The type of event, only applies to some"
-#+ * FCurve.array_index -> array_index:   int  "Index to the specific property affected by F-Curve if applicable"
-#+ * FCurve.color -> color:   float[3]  "Color of the F-Curve in the Graph Editor"
-#+ * FCurve.color_mode -> color_mode:   enum  "Method used to determine color of F-Curve in Graph Editor"
-#+ * FCurve.data_path -> data_path:   string  "RNA Path to property affected by F-Curve"
-#+ * FCurve.driver -> driver:   pointer,  "(read-only)    Channel Driver (only set for Driver F-Curves)"
-#+ * FCurve.extrapolation -> extrapolation:   enum  "NO DESCRIPTION"
-#+ * FCurve.group -> group:   pointer  "Action Group that this F-Curve belongs to"
-#+ * FCurve.hide -> hide:   boolean  "F-Curve and its keyframes are hidden in the Graph Editor graphs"
-#+ * FCurve.is_valid -> is_valid:   boolean  "False when F-Curve could not be evaluated in past, so should be skipped when evaluating"
-#+ * FCurve.keyframe_points -> keyframe_points:   collection,  "(read-only)    User-editable keyframes"
-#+ * FCurve.lock -> lock:   boolean  "F-Curves settings cannot be edited"
-#+ * FCurve.modifiers -> modifiers:   collection,  "(read-only)    Modifiers affecting the shape of the F-Curve"
-#+ * FCurve.mute -> mute:   boolean  "F-Curve is not evaluated"
-#+ * FCurve.sampled_points -> sampled_points:   collection,  "(read-only)    Sampled animation data"
-#+ * FCurve.select -> select:   boolean  "F-Curve is selected for editing"
-#+ * FCurve.use_auto_handle_clamp -> use_auto_handle_clamp:   boolean  "All auto-handles for F-Curve are clamped"
-#+ * FCurveModifiers.active -> active:   pointer  "Active F-Curve Modifier"
-#+ * FCurveSample.co -> co:   float[2]  "Point coordinates"
-#+ * FCurveSample.select -> select:   boolean  "Selection status"
-#REMOVE * FModifier.active -> active:   boolean  "F-Curve Modifier is the one being edited"
-#FModifier.is_valid -> is_valid:   boolean,  "(read-only)    F-Curve Modifier has invalid settings and will not be evaluated"
-#+ * FModifier.mute -> mute:   boolean  "F-Curve Modifier will not be evaluated"
-#FModifier.show_expanded -> show_expanded:   boolean  "F-Curve Modifiers panel is expanded in UI"
-#+ * FModifier.type -> type:   enum,  "(read-only)    F-Curve Modifier Type"
-#+ * FModifierEnvelopeControlPoint.frame -> frame:   float  "Frame this control-point occurs on"
-#FModifierEnvelopeControlPoint.max -> max:   float  "Upper bound of envelope at this control-point"
-#FModifierEnvelopeControlPoint.min -> min:   float  "Lower bound of envelope at this control-point"
-#FModifier|FModifierCycles.cycles_after -> cycles_after:   float  "Maximum number of cycles to allow after last keyframe. (0 = infinite)"
-#FModifier|FModifierCycles.cycles_before -> cycles_before:   float  "Maximum number of cycles to allow before first keyframe. (0 = infinite)"
-#FModifier|FModifierCycles.mode_after -> mode_after:   enum  "Cycling mode to use after last keyframe"
-#FModifier|FModifierCycles.mode_before -> mode_before:   enum  "Cycling mode to use before first keyframe"
-#+ * FModifier|FModifierEnvelope.control_points -> control_points:   collection,  "(read-only)    Control points defining the shape of the envelope"
-#FModifier|FModifierEnvelope.default_max -> default_max:   float  "Upper distance from Reference Value for 1:1 default influence"
-#FModifier|FModifierEnvelope.default_min -> default_min:   float  "Lower distance from Reference Value for 1:1 default influence"
-#+ * FModifier|FModifierEnvelope.reference_value -> reference_value:   float  "Value that envelopes influence is centered around / based on"
-#+ * FModifier|FModifierFunctionGenerator.amplitude -> amplitude:   float  "Scale factor determining the maximum/minimum values"
-#+ * FModifier|FModifierFunctionGenerator.function_type -> function_type:   enum  "Type of built-in function to use"
-#+ * FModifier|FModifierFunctionGenerator.phase_multiplier -> phase_multiplier:   float  "Scale factor determining the speed of the function"
-#+ * FModifier|FModifierFunctionGenerator.phase_offset -> phase_offset:   float  "Constant factor to offset time by for function"
-#FModifier|FModifierFunctionGenerator.use_additive -> use_additive:   boolean  "Values generated by this modifier are applied on top of the existing values instead of overwriting them"
-#+ * FModifier|FModifierFunctionGenerator.value_offset -> value_offset:   float  "Constant factor to offset values by"
-#+ * FModifier|FModifierGenerator.coefficients -> coefficients:   float[32]  "Coefficients for x (starting from lowest power of x^0)"
-#+ * FModifier|FModifierGenerator.mode -> mode:   enum  "Type of generator to use"
-#+ * FModifier|FModifierGenerator.poly_order -> poly_order:   int  "The highest power of x for this polynomial. (number of coefficients - 1)"
-#FModifier|FModifierGenerator.use_additive -> use_additive:   boolean  "Values generated by this modifier are applied on top of the existing values instead of overwriting them"
-#FModifier|FModifierLimits.max_x -> max_x:   float  "Highest X value to allow"
-#FModifier|FModifierLimits.max_y -> max_y:   float  "Highest Y value to allow"
-#FModifier|FModifierLimits.min_x -> min_x:   float  "Lowest X value to allow"
-#FModifier|FModifierLimits.min_y -> min_y:   float  "Lowest Y value to allow"
-#FModifier|FModifierLimits.use_max_x -> use_max_x:   boolean  "Use the maximum X value"
-#FModifier|FModifierLimits.use_max_y -> use_max_y:   boolean  "Use the maximum Y value"
-#FModifier|FModifierLimits.use_min_x -> use_min_x:   boolean  "Use the minimum X value"
-#FModifier|FModifierLimits.use_min_y -> use_min_y:   boolean  "Use the minimum Y value"
-#FModifier|FModifierNoise.blend_type -> blend_type:   enum  "Method of modifying the existing F-Curve"
-#+ * FModifier|FModifierNoise.depth -> depth:   int  "Amount of fine level detail present in the noise"
-#+ * FModifier|FModifierNoise.phase -> phase:   float  "A random seed for the noise effect"
-#FModifier|FModifierNoise.scale -> scale:   float  "Scaling (in time) of the noise"
-#+ * FModifier|FModifierNoise.strength -> strength:   float  "Amplitude of the noise - the amount that it modifies the underlying curve"
-#+ * FModifier|FModifierStepped.frame_end -> frame_end:   float  "Frame that modifiers influence ends (if applicable)"
-#FModifier|FModifierStepped.frame_offset -> frame_offset:   float  "Reference number of frames before frames get held. Use to get hold for 1-3 vs 5-7 holding patterns"
-#+ * FModifier|FModifierStepped.frame_start -> frame_start:   float  "Frame that modifiers influence starts (if applicable)"
-#FModifier|FModifierStepped.frame_step -> frame_step:   float  "Number of frames to hold each value"
-#+ * FModifier|FModifierStepped.use_frame_end -> use_frame_end:   boolean  "Restrict modifier to only act before its end frame"
-#+ * FModifier|FModifierStepped.use_frame_start -> use_frame_start:   boolean  "Restrict modifier to only act after its start frame"
-#FieldSettings.apply_to_location -> apply_to_location:   boolean  "Effect particles location"
-#FieldSettings.apply_to_rotation -> apply_to_rotation:   boolean  "Effect particles dynamic rotation"
-#FieldSettings.distance_max -> distance_max:   float  "Maximum distance for the field to work"
-#FieldSettings.distance_min -> distance_min:   float  "Minimum distance for the fields fall-off"
-#+ * FieldSettings.falloff_power -> falloff_power:   float  "Falloff power (real gravitational falloff = 2)"
-#+ * FieldSettings.falloff_type -> falloff_type:   enum  "Fall-off shape"
-#+ * FieldSettings.flow -> flow:   float  "Convert effector force into air flow velocity"
-#+ * FieldSettings.guide_clump_amount -> guide_clump_amount:   float  "Amount of clumping"
-#+ * FieldSettings.guide_clump_shape -> guide_clump_shape:   float  "Shape of clumping"
-#+ * FieldSettings.guide_free -> guide_free:   float  "Guide-free time from particle lifes end"
-#+ * FieldSettings.guide_kink_amplitude -> guide_kink_amplitude:   float  "The amplitude of the offset"
-#+ * FieldSettings.guide_kink_axis -> guide_kink_axis:   enum  "Which axis to use for offset"
-#+ * FieldSettings.guide_kink_frequency -> guide_kink_frequency:   float  "The frequency of the offset (1/total length)"
-#+ * FieldSettings.guide_kink_shape -> guide_kink_shape:   float  "Adjust the offset to the beginning/end"
-#+ * FieldSettings.guide_kink_type -> guide_kink_type:   enum  "Type of periodic offset on the curve"
-#+ * FieldSettings.guide_minimum -> guide_minimum:   float  "The distance from which particles are affected fully"
-#+ * FieldSettings.harmonic_damping -> harmonic_damping:   float  "Damping of the harmonic force"
-#+ * FieldSettings.inflow -> inflow:   float  "Inwards component of the vortex force"
-#+ * FieldSettings.linear_drag -> linear_drag:   float  "Drag component proportional to velocity"
-#+ * FieldSettings.noise -> noise:   float  "Noise of the force"
-#+ * FieldSettings.quadratic_drag -> quadratic_drag:   float  "Drag component proportional to the square of velocity"
-#+ * FieldSettings.radial_falloff -> radial_falloff:   float  "Radial falloff power (real gravitational falloff = 2)"
-#FieldSettings.radial_max -> radial_max:   float  "Maximum radial distance for the field to work"
-#FieldSettings.radial_min -> radial_min:   float  "Minimum radial distance for the fields fall-off"
-#+ * FieldSettings.rest_length -> rest_length:   float  "Rest length of the harmonic force"
-#+ * FieldSettings.seed -> seed:   int  "Seed of the noise"
-#+ * FieldSettings.shape -> shape:   enum  "Which direction is used to calculate the effector force"
-#+ * FieldSettings.size -> size:   float  "Size of the noise"
-#+ * FieldSettings.strength -> strength:   float  "Strength of force field"
-#+ * FieldSettings.texture -> texture:   pointer  "Texture to use as force"
-#+ * FieldSettings.texture_mode -> texture_mode:   enum  "How the texture effect is calculated (RGB & Curl need a RGB texture else Gradient will be used instead)"
-#+ * FieldSettings.texture_nabla -> texture_nabla:   float  "Defines size of derivative offset used for calculating gradient and curl"
-#+ * FieldSettings.type -> type:   enum  "Type of field"
-#FieldSettings.use_2d_force -> use_2d_force:   boolean  "Apply force only in 2d"
-#FieldSettings.use_absorption -> use_absorption:   boolean  "Force gets absorbed by collision objects"
-#FieldSettings.use_global_coords -> use_global_coords:   boolean  "Use effector/global coordinates for turbulence"
-#FieldSettings.use_guide_path_add -> use_guide_path_add:   boolean  "Based on distance/falloff it adds a portion of the entire path"
-#+ * FieldSettings.use_guide_path_weight -> use_guide_path_weight:   boolean  "Use curve weights to influence the particle influence along the curve"
-#+ * FieldSettings.use_max_distance -> use_max_distance:   boolean  "Use a maximum distance for the field to work"
-#+ * FieldSettings.use_min_distance -> use_min_distance:   boolean  "Use a minimum distance for the fields fall-off"
-#FieldSettings.use_multiple_springs -> use_multiple_springs:   boolean  "Every point is effected by multiple springs"
-#FieldSettings.use_object_coords -> use_object_coords:   boolean  "Use object/global coordinates for texture"
-#+ * FieldSettings.use_radial_max -> use_radial_max:   boolean  "Use a maximum radial distance for the field to work"
-#+ * FieldSettings.use_radial_min -> use_radial_min:   boolean  "Use a minimum radial distance for the fields fall-off"
-#FieldSettings.use_root_coords -> use_root_coords:   boolean  "Texture coordinates from root particle locations"
-#+ * FieldSettings.z_direction -> z_direction:   enum  "Effect in full or only positive/negative Z direction"
-#+ * FileSelectParams.directory -> directory:   string  "Directory displayed in the file browser"
-#FileSelectParams.display_type -> display_type:   enum  "Display mode for the file list"
-#FileSelectParams.filename -> filename:   string  "Active file in the file browser"
-#FileSelectParams.show_hidden -> show_hidden:   boolean  "Hide hidden dot files"
-#FileSelectParams.sort_method -> sort_method:   enum  "NO DESCRIPTION"
-#+ * FileSelectParams.title -> title:   string,  "(read-only)    Title for the file browser"
-#FileSelectParams.use_filter -> use_filter:   boolean  "Enable filtering of files"
-#FileSelectParams.use_filter_blender -> use_filter_blender:   boolean  "Show .blend files"
-#FileSelectParams.use_filter_folder -> use_filter_folder:   boolean  "Show folders"
-#FileSelectParams.use_filter_font -> use_filter_font:   boolean  "Show font files"
-#FileSelectParams.use_filter_image -> use_filter_image:   boolean  "Show image files"
-#FileSelectParams.use_filter_movie -> use_filter_movie:   boolean  "Show movie files"
-#FileSelectParams.use_filter_script -> use_filter_script:   boolean  "Show script files"
-#FileSelectParams.use_filter_sound -> use_filter_sound:   boolean  "Show sound files"
-#FileSelectParams.use_filter_text -> use_filter_text:   boolean  "Show text files"
-#+ * FluidSettings.type -> type:   enum  "Type of participation in the fluid simulation"
-#+ * FluidSettings|ControlFluidSettings.attraction_radius -> attraction_radius:   float  "Specifies the force field radius around the control object"
-#+ * FluidSettings|ControlFluidSettings.attraction_strength -> attraction_strength:   float  "Force strength for directional attraction towards the control object"
-#+ * FluidSettings|ControlFluidSettings.end_time -> end_time:   float  "Specifies time when the control particles are deactivated"
-#+ * FluidSettings|ControlFluidSettings.quality -> quality:   float  "Specifies the quality which is used for object sampling. (higher = better but slower)"
-#+ * FluidSettings|ControlFluidSettings.start_time -> start_time:   float  "Specifies time when the control particles are activated"
-#FluidSettings|ControlFluidSettings.use -> use:   boolean  "Object contributes to the fluid simulation"
-#FluidSettings|ControlFluidSettings.use_reverse_frames -> use_reverse_frames:   boolean  "Reverse control object movement"
-#+ * FluidSettings|ControlFluidSettings.velocity_radius -> velocity_radius:   float  "Specifies the force field radius around the control object"
-#+ * FluidSettings|ControlFluidSettings.velocity_strength -> velocity_strength:   float  "Force strength of how much of the control objects velocity is influencing the fluid velocity"
-#+ * FluidSettings|DomainFluidSettings.compressibility -> compressibility:   float  "Allowed compressibility due to gravitational force for standing fluid. (directly affects simulation step size)"
-#+ * FluidSettings|DomainFluidSettings.end_time -> end_time:   float  "Simulation time of the last blender frame (in seconds)"
-#FluidSettings|DomainFluidSettings.filepath -> filepath:   string  "Directory (and/or filename prefix) to store baked fluid simulation files in"
-#+ * FluidSettings|DomainFluidSettings.generate_particles -> generate_particles:   float  "Amount of particles to generate (0=off, 1=normal, >1=more)"
-#+ * FluidSettings|DomainFluidSettings.gravity -> gravity:   float[3]  "Gravity in X, Y and Z direction"
-#+ * FluidSettings|DomainFluidSettings.grid_levels -> grid_levels:   int  "Number of coarsened grids to use (-1 for automatic)"
-#+ * FluidSettings|DomainFluidSettings.memory_estimate -> memory_estimate:   string,  "(read-only)    Estimated amount of memory needed for baking the domain"
-#+ * FluidSettings|DomainFluidSettings.partial_slip_factor -> partial_slip_factor:   float  "Amount of mixing between no- and free-slip, 0 is no slip and 1 is free slip"
-#+ * FluidSettings|DomainFluidSettings.preview_resolution -> preview_resolution:   int  "Preview resolution in X,Y and Z direction"
-#+ * FluidSettings|DomainFluidSettings.render_display_mode -> render_display_mode:   enum  "How to display the mesh for rendering"
-#+ * FluidSettings|DomainFluidSettings.resolution -> resolution:   int  "Domain resolution in X,Y and Z direction"
-#FluidSettings|DomainFluidSettings.simulation_scale -> simulation_scale:   float  "Size of the simulation domain in metres"
-#+ * FluidSettings|DomainFluidSettings.slip_type -> slip_type:   enum  "NO DESCRIPTION"
-#+ * FluidSettings|DomainFluidSettings.start_time -> start_time:   float  "Simulation time of the first blender frame (in seconds)"
-#FluidSettings|DomainFluidSettings.surface_smooth -> surface_smooth:   float  "Amount of surface smoothing. A value of 0 is off, 1 is normal smoothing and more than 1 is extra smoothing"
-#+ * FluidSettings|DomainFluidSettings.surface_subdivisions -> surface_subdivisions:   int  "Number of isosurface subdivisions. This is necessary for the inclusion of particles into the surface generation. Warning - can lead to longer computation times!"
-#+ * FluidSettings|DomainFluidSettings.tracer_particles -> tracer_particles:   int  "Number of tracer particles to generate"
-#FluidSettings|DomainFluidSettings.use_reverse_frames -> use_reverse_frames:   boolean  "Reverse fluid frames"
-#FluidSettings|DomainFluidSettings.use_speed_vectors -> use_speed_vectors:   boolean  "Generate speed vectors for vector blur"
-#FluidSettings|DomainFluidSettings.use_time_override -> use_time_override:   boolean  "Use a custom start and end time (in seconds) instead of the scenes timeline"
-#+ * FluidSettings|DomainFluidSettings.viewport_display_mode -> viewport_display_mode:   enum  "How to display the mesh in the viewport"
-#+ * FluidSettings|DomainFluidSettings.viscosity_base -> viscosity_base:   float  "Viscosity setting: value that is multiplied by 10 to the power of (exponent*-1)"
-#+ * FluidSettings|DomainFluidSettings.viscosity_exponent -> viscosity_exponent:   int  "Negative exponent for the viscosity value (to simplify entering small values e.g. 5*10^-6.)"
-#+ * FluidSettings|DomainFluidSettings.viscosity_preset -> viscosity_preset:   enum  "Set viscosity of the fluid to a preset value, or use manual input"
-#+ * FluidSettings|FluidFluidSettings.initial_velocity -> initial_velocity:   float[3]  "Initial velocity of fluid"
-#FluidSettings|FluidFluidSettings.use -> use:   boolean  "Object contributes to the fluid simulation"
-#FluidSettings|FluidFluidSettings.use_animated_mesh -> use_animated_mesh:   boolean  "Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it"
-#+ * FluidSettings|FluidFluidSettings.volume_initialization -> volume_initialization:   enum  "Volume initialization type"
-#+ * FluidSettings|InflowFluidSettings.inflow_velocity -> inflow_velocity:   float[3]  "Initial velocity of fluid"
-#FluidSettings|InflowFluidSettings.use -> use:   boolean  "Object contributes to the fluid simulation"
-#FluidSettings|InflowFluidSettings.use_animated_mesh -> use_animated_mesh:   boolean  "Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it"
-#FluidSettings|InflowFluidSettings.use_local_coords -> use_local_coords:   boolean  "Use local coordinates for inflow. (e.g. for rotating objects)"
-#+ * FluidSettings|InflowFluidSettings.volume_initialization -> volume_initialization:   enum  "Volume initialization type"
-#+ * FluidSettings|ObstacleFluidSettings.impact_factor -> impact_factor:   float  "This is an unphysical value for moving objects - it controls the impact an obstacle has on the fluid, =0 behaves a bit like outflow (deleting fluid), =1 is default, while >1 results in high forces. Can be used to tweak total mass"
-#+ * FluidSettings|ObstacleFluidSettings.partial_slip_factor -> partial_slip_factor:   float  "Amount of mixing between no- and free-slip, 0 is no slip and 1 is free slip"
-#+ * FluidSettings|ObstacleFluidSettings.slip_type -> slip_type:   enum  "NO DESCRIPTION"
-#FluidSettings|ObstacleFluidSettings.use -> use:   boolean  "Object contributes to the fluid simulation"
-#FluidSettings|ObstacleFluidSettings.use_animated_mesh -> use_animated_mesh:   boolean  "Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it"
-#+ * FluidSettings|ObstacleFluidSettings.volume_initialization -> volume_initialization:   enum  "Volume initialization type"
-#FluidSettings|OutflowFluidSettings.use -> use:   boolean  "Object contributes to the fluid simulation"
-#FluidSettings|OutflowFluidSettings.use_animated_mesh -> use_animated_mesh:   boolean  "Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it"
-#+ * FluidSettings|OutflowFluidSettings.volume_initialization -> volume_initialization:   enum  "Volume initialization type"
-#+ * FluidSettings|ParticleFluidSettings.alpha_influence -> alpha_influence:   float  "Amount of particle alpha change, inverse of size influence: 0=off (all same alpha), 1=full. (large particles get lower alphas, smaller ones higher values)"
-#FluidSettings|ParticleFluidSettings.filepath -> filepath:   string  "Directory (and/or filename prefix) to store and load particles from"
-#+ * FluidSettings|ParticleFluidSettings.particle_influence -> particle_influence:   float  "Amount of particle size scaling: 0=off (all same size), 1=full (range 0.2-2.0), >1=stronger"
-#FluidSettings|ParticleFluidSettings.show_tracer -> show_tracer:   boolean  "Show tracer particles"
-#FluidSettings|ParticleFluidSettings.use_drops -> use_drops:   boolean  "Show drop particles"
-#FluidSettings|ParticleFluidSettings.use_floats -> use_floats:   boolean  "Show floating foam particles"
-#+ * Function.description -> description:   string,  "(read-only)    Description of the Functions purpose"
-#+ * Function.identifier -> identifier:   string,  "(read-only)    Unique name used in the code and scripting"
-#Function.is_registered -> is_registered:   boolean,  "(read-only)    Function is registered as callback as part of type registration"
-#Function.is_registered_optional -> is_registered_optional:   boolean,  "(read-only)    Function is optionally registered as callback part of type registration"
-#+ * Function.parameters -> parameters:   collection,  "(read-only)    Parameters for the function"
-#Function.use_self -> use_self:   boolean,  "(read-only)    Function does not pass its self as an argument (becomes a class method in python)"
-#+ * GPencilFrame.frame_number -> frame_number:   int  "The frame on which this sketch appears"
-#GPencilFrame.is_edited -> is_edited:   boolean  "Frame is being edited (painted on)"
-#+ * GPencilFrame.select -> select:   boolean  "Frame is selected for editing in the DopeSheet"
-#+ * GPencilFrame.strokes -> strokes:   collection,  "(read-only)    Freehand curves defining the sketch on this frame"
-#+ * GPencilLayer.active -> active:   boolean  "Set active layer for editing"
-#+ * GPencilLayer.active_frame -> active_frame:   pointer,  "(read-only)    Frame currently being displayed for this layer"
-#GPencilLayer.alpha -> alpha:   float  "Layer Opacity"
-#+ * GPencilLayer.color -> color:   float[3]  "Color for all strokes in this layer"
-#+ * GPencilLayer.frames -> frames:   collection,  "(read-only)    Sketches for this layer on different frames"
-#GPencilLayer.ghost_range_max -> ghost_range_max:   int  "Maximum number of frames on either side of the active frame to show (0 = show the first available sketch on either side)"
-#+ * GPencilLayer.hide -> hide:   boolean  "Set layer Visibility"
-#+ * GPencilLayer.info -> info:   string  "Layer name"
-#GPencilLayer.line_width -> line_width:   int  "Thickness of strokes (in pixels)"
-#+ * GPencilLayer.lock -> lock:   boolean  "Protect layer from further editing and/or frame changes"
-#GPencilLayer.lock_frame -> lock_frame:   boolean  "Lock current frame displayed by layer"
-#+ * GPencilLayer.select -> select:   boolean  "Layer is selected for editing in the DopeSheet"
-#+ * GPencilLayer.show_points -> show_points:   boolean  "Draw the points which make up the strokes (for debugging purposes)"
-#+ * GPencilLayer.use_onion_skinning -> use_onion_skinning:   boolean  "Ghost frames on either side of frame"
-#+ * GPencilStroke.points -> points:   collection,  "(read-only)    Stroke data points"
-#+ * GPencilStrokePoint.co -> co:   float[3]  "NO DESCRIPTION"
-#+ * GPencilStrokePoint.pressure -> pressure:   float  "Pressure of tablet at point when drawing it"
-#+ * GameObjectSettings.actuators -> actuators:   collection,  "(read-only)    Game engine actuators to act on events"
-#GameObjectSettings.collision_bounds_type -> collision_bounds_type:   enum  "Selects the collision type"
-#+ * GameObjectSettings.collision_margin -> collision_margin:   float  "Extra margin around object for collision detection, small amount required for stability"
-#+ * GameObjectSettings.controllers -> controllers:   collection,  "(read-only)    Game engine controllers to process events, connecting sensor to actuators"
-#+ * GameObjectSettings.damping -> damping:   float  "General movement damping"
-#+ * GameObjectSettings.form_factor -> form_factor:   float  "Form factor scales the inertia tensor"
-#+ * GameObjectSettings.friction_coefficients -> friction_coefficients:   float[3]  "Relative friction coefficient in the in the X, Y and Z directions, when anisotropic friction is enabled"
-#GameObjectSettings.lock_location_x -> lock_location_x:   boolean  "Disable simulation of linear motion along the X axis"
-#GameObjectSettings.lock_location_y -> lock_location_y:   boolean  "Disable simulation of linear motion along the Y axis"
-#GameObjectSettings.lock_location_z -> lock_location_z:   boolean  "Disable simulation of linear motion along the Z axis"
-#GameObjectSettings.lock_rotation_x -> lock_rotation_x:   boolean  "Disable simulation of angular  motion along the X axis"
-#GameObjectSettings.lock_rotation_y -> lock_rotation_y:   boolean  "Disable simulation of angular  motion along the Y axis"
-#GameObjectSettings.lock_rotation_z -> lock_rotation_z:   boolean  "Disable simulation of angular  motion along the Z axis"
-#+ * GameObjectSettings.mass -> mass:   float  "Mass of the object"
-#+ * GameObjectSettings.physics_type -> physics_type:   enum  "Selects the type of physical representation"
-#+ * GameObjectSettings.properties -> properties:   collection,  "(read-only)    Game engine properties"
-#+ * GameObjectSettings.radius -> radius:   float  "Radius of bounding sphere and material physics"
-#+ * GameObjectSettings.rotation_damping -> rotation_damping:   float  "General rotation damping"
-#+ * GameObjectSettings.sensors -> sensors:   collection,  "(read-only)    Game engine sensor to detect events"
-#+ * GameObjectSettings.show_actuators -> show_actuators:   boolean  "Shows actuators for this object in the user interface"
-#+ * GameObjectSettings.show_controllers -> show_controllers:   boolean  "Shows controllers for this object in the user interface"
-#GameObjectSettings.show_debug_state -> show_debug_state:   boolean  "Print state debug info in the game engine"
-#+ * GameObjectSettings.show_sensors -> show_sensors:   boolean  "Shows sensors for this object in the user interface"
-#+ * GameObjectSettings.show_state_panel -> show_state_panel:   boolean  "Show state panel"
-#+ * GameObjectSettings.soft_body -> soft_body:   pointer,  "(read-only)    Settings for Bullet soft body simulation"
-#GameObjectSettings.states_initial -> states_initial:   boolean[30]  "Initial state when the game starts"
-#GameObjectSettings.states_visible -> states_visible:   boolean[30]  "State determining which controllers are displayed"
-#+ * GameObjectSettings.use_activity_culling -> use_activity_culling:   boolean  "Disable simulation of angular  motion along the Z axis"
-#GameObjectSettings.use_actor -> use_actor:   boolean  "Object is detected by the Near and Radar sensor"
-#GameObjectSettings.use_all_states -> use_all_states:   boolean  "Set all state bits"
-#GameObjectSettings.use_anisotropic_friction -> use_anisotropic_friction:   boolean  "Enable anisotropic friction"
-#+ * GameObjectSettings.use_collision_bounds -> use_collision_bounds:   boolean  "Specify a collision bounds type other than the default"
-#GameObjectSettings.use_collision_compound -> use_collision_compound:   boolean  "Add children to form a compound collision object"
-#GameObjectSettings.use_ghost -> use_ghost:   boolean  "Object does not restitute collisions, like a ghost"
-#GameObjectSettings.use_material_physics -> use_material_physics:   boolean  "Use physics settings in materials"
-#GameObjectSettings.use_rotate_from_normal -> use_rotate_from_normal:   boolean  "Use face normal to rotate object, so that it points away from the surface"
-#GameObjectSettings.use_sleep -> use_sleep:   boolean  "Disable auto (de)activation in physics simulation"
-#GameObjectSettings.used_states -> used_states:   boolean[30],  "(read-only)    States which are being used by controllers"
-#GameObjectSettings.velocity_max -> velocity_max:   float  "Clamp velocity to this maximum speed"
-#GameObjectSettings.velocity_min -> velocity_min:   float  "Clamp velocity to this minimum speed (except when totally still)"
-#+ * GameProperty.name -> name:   string  "Available as GameObject attributes in the game engines python API"
-#GameProperty.show_debug -> show_debug:   boolean  "Print debug information for this property"
-#+ * GameProperty.type -> type:   enum  "NO DESCRIPTION"
-#+ * GameProperty|GameBooleanProperty.value -> value:   boolean  "Property value"
-#+ * GameProperty|GameFloatProperty.value -> value:   float  "Property value"
-#+ * GameProperty|GameIntProperty.value -> value:   int  "Property value"
-#+ * GameProperty|GameStringProperty.value -> value:   string  "Property value"
-#+ * GameProperty|GameTimerProperty.value -> value:   float  "Property value"
-#+ * GameSoftBodySettings.cluster_iterations -> cluster_iterations:   int  "Specify the number of cluster iterations"
-#GameSoftBodySettings.collision_margin -> collision_margin:   float  "Collision margin for soft body. Small value makes the algorithm unstable"
-#+ * GameSoftBodySettings.dynamic_friction -> dynamic_friction:   float  "Dynamic Friction"
-#GameSoftBodySettings.linear_stiffness -> linear_stiffness:   float  "Linear stiffness of the soft body links"
-#GameSoftBodySettings.location_iterations -> location_iterations:   int  "Position solver iterations"
-#GameSoftBodySettings.shape_threshold -> shape_threshold:   float  "Shape matching threshold"
-#GameSoftBodySettings.use_bending_constraints -> use_bending_constraints:   boolean  "Enable bending constraints"
-#GameSoftBodySettings.use_cluster_rigid_to_softbody -> use_cluster_rigid_to_softbody:   boolean  "Enable cluster collision between soft and rigid body"
-#GameSoftBodySettings.use_cluster_soft_to_softbody -> use_cluster_soft_to_softbody:   boolean  "Enable cluster collision between soft and soft body"
-#GameSoftBodySettings.use_shape_match -> use_shape_match:   boolean  "Enable soft body shape matching goal"
-#GameSoftBodySettings.weld_threshold -> weld_threshold:   float  "Welding threshold: distance between nearby vertices to be considered equal => set to 0.0 to disable welding test and speed up scene loading (ok if the mesh has no duplicates)"
-#+ * Header.bl_idname -> bl_idname:   string  "If this is set, the header gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is OBJECT_HT_hello, and bl_idname is not set by the script, then bl_idname = OBJECT_HT_hello"
-#+ * Header.bl_space_type -> bl_space_type:   enum  "The space where the header is going to be used in."
-#+ * Header.layout -> layout:   pointer,  "(read-only)    Defines the structure of the header in the UI."
-#+ * Histogram.mode -> mode:   enum  "Channels to display when drawing the histogram"
-#+ * ID.library -> library:   pointer,  "(read-only)    Library file the datablock is linked from"
-#+ * ID.name -> name:   string  "Unique datablock ID name"
-#+ * ID.tag -> tag:   boolean  "Tools can use this to tag data, (initial state is undefined)"
-#ID.use_fake_user -> use_fake_user:   boolean  "Saves this datablock even if it has no users"
-#+ * ID.users -> users:   int,  "(read-only)    Number of times this datablock is referenced"
-#+ * IDProperty.collection -> collection:   collection,  "(read-only)"
-#+ * IDProperty.double -> double:   float  "NO DESCRIPTION"
-#+ * IDProperty.double_array -> double_array:   float[1]  "NO DESCRIPTION"
-#+ * IDProperty.float -> float:   float  "NO DESCRIPTION"
-#+ * IDProperty.float_array -> float_array:   float[1]  "NO DESCRIPTION"
-#+ * IDProperty.group -> group:   pointer,  "(read-only)"
-#+ * IDProperty.int -> int:   int  "NO DESCRIPTION"
-#+ * IDProperty.int_array -> int_array:   int[1]  "NO DESCRIPTION"
-#+ * IDProperty.string -> string:   string  "NO DESCRIPTION"
-#+ * IDPropertyGroup.name -> name:   string  "Unique name used in the code and scripting"
-#+ * IDPropertyGroup|NetRenderJob.name -> name:   string  "NO DESCRIPTION"
-#+ * IDPropertyGroup|NetRenderSettings.active_blacklisted_slave_index -> active_blacklisted_slave_index:   int  "NO DESCRIPTION"
-#+ * IDPropertyGroup|NetRenderSettings.active_job_index -> active_job_index:   int  "NO DESCRIPTION"
-#+ * IDPropertyGroup|NetRenderSettings.active_slave_index -> active_slave_index:   int  "NO DESCRIPTION"
-#+ * IDPropertyGroup|NetRenderSettings.chunks -> chunks:   int  "Number of frame to dispatch to each slave in one chunk"
-#+ * IDPropertyGroup|NetRenderSettings.job_category -> job_category:   string  "Category of the job"
-#+ * IDPropertyGroup|NetRenderSettings.job_id -> job_id:   string  "id of the last sent render job"
-#+ * IDPropertyGroup|NetRenderSettings.job_name -> job_name:   string  "Name of the job"
-#+ * IDPropertyGroup|NetRenderSettings.jobs -> jobs:   collection,  "(read-only)"
-#+ * IDPropertyGroup|NetRenderSettings.mode -> mode:   enum  "Mode of operation of this instance"
-#+ * IDPropertyGroup|NetRenderSettings.path -> path:   string  "Path for temporary files"
-#+ * IDPropertyGroup|NetRenderSettings.priority -> priority:   int  "Priority of the job"
-#+ * IDPropertyGroup|NetRenderSettings.server_address -> server_address:   string  "IP or name of the master render server"
-#+ * IDPropertyGroup|NetRenderSettings.server_port -> server_port:   int  "port of the master render server"
-#+ * IDPropertyGroup|NetRenderSettings.slaves -> slaves:   collection,  "(read-only)"
-#+ * IDPropertyGroup|NetRenderSettings.slaves_blacklist -> slaves_blacklist:   collection,  "(read-only)"
-#IDPropertyGroup|NetRenderSettings.use_master_broadcast -> use_master_broadcast:   boolean  "broadcast master server address on local network"
-#IDPropertyGroup|NetRenderSettings.use_master_clear -> use_master_clear:   boolean  "delete saved files on exit"
-#IDPropertyGroup|NetRenderSettings.use_slave_clear -> use_slave_clear:   boolean  "delete downloaded files on exit"
-#IDPropertyGroup|NetRenderSettings.use_slave_output_log -> use_slave_output_log:   boolean  "Output render text log to console as well as sending it to the master"
-#IDPropertyGroup|NetRenderSettings.use_slave_thumb -> use_slave_thumb:   boolean  "Generate thumbnails on slaves instead of master"
-#+ * IDPropertyGroup|NetRenderSlave.name -> name:   string  "NO DESCRIPTION"
-#+ * IDPropertyGroup|OperatorFileListElement.name -> name:   string  "the name of a file or directory within a file list"
-#+ * IDPropertyGroup|OperatorMousePath.loc -> loc:   float[2]  "Mouse location"
-#+ * IDPropertyGroup|OperatorMousePath.time -> time:   float  "Time of mouse location"
-#+ * IDPropertyGroup|OperatorStrokeElement.location -> location:   float[3]  "NO DESCRIPTION"
-#+ * IDPropertyGroup|OperatorStrokeElement.mouse -> mouse:   float[2]  "NO DESCRIPTION"
-#+ * IDPropertyGroup|OperatorStrokeElement.pen_flip -> pen_flip:   boolean  "NO DESCRIPTION"
-#+ * IDPropertyGroup|OperatorStrokeElement.pressure -> pressure:   float  "Tablet pressure"
-#+ * IDPropertyGroup|OperatorStrokeElement.time -> time:   float  "NO DESCRIPTION"
-#+ * IDPropertyGroup|PoseTemplate.name -> name:   string  "NO DESCRIPTION"
-#+ * IDPropertyGroup|PoseTemplateSettings.active_template_index -> active_template_index:   int  "NO DESCRIPTION"
-#+ * IDPropertyGroup|PoseTemplateSettings.templates -> templates:   collection,  "(read-only)"
-#IDPropertyGroup|PoseTemplateSettings.use_generate_deform_rig -> use_generate_deform_rig:   boolean  "Create a copy of the metarig, constrainted by the generated rig"
-#+ * ID|Action.fcurves -> fcurves:   collection,  "(read-only)    The individual F-Curves that make up the Action"
-#+ * ID|Action.groups -> groups:   collection,  "(read-only)    Convenient groupings of F-Curves"
-#+ * ID|Action.pose_markers -> pose_markers:   collection,  "(read-only)    Markers specific to this Action, for labeling poses"
-#+ * ID|Armature.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#+ * ID|Armature.bones -> bones:   collection,  "(read-only)"
-#ID|Armature.draw_type -> draw_type:   enum  "NO DESCRIPTION"
-#+ * ID|Armature.edit_bones -> edit_bones:   collection,  "(read-only)"
-#+ * ID|Armature.ghost_frame_end -> ghost_frame_end:   int  "End frame of range of Ghosts to display (not for Around Current Frame Onion-skinning method)"
-#+ * ID|Armature.ghost_frame_start -> ghost_frame_start:   int  "Starting frame of range of Ghosts to display (not for Around Current Frame Onion-skinning method)"
-#+ * ID|Armature.ghost_size -> ghost_size:   int  "Frame step for Ghosts (not for On Keyframes Onion-skinning method)"
-#+ * ID|Armature.ghost_step -> ghost_step:   int  "Number of frame steps on either side of current frame to show as ghosts (only for Around Current Frame Onion-skinning method)"
-#+ * ID|Armature.ghost_type -> ghost_type:   enum  "Method of Onion-skinning for active Action"
-#ID|Armature.layers -> layers:   boolean[32]  "Armature layer visibility"
-#ID|Armature.layers_protected -> layers_protected:   boolean[32]  "Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo"
-#+ * ID|Armature.pose_position -> pose_position:   enum  "Show armature in binding pose or final posed state"
-#ID|Armature.show_axes -> show_axes:   boolean  "Draw bone axes"
-#ID|Armature.show_bone_custom_shapes -> show_bone_custom_shapes:   boolean  "Draw bones with their custom shapes"
-#ID|Armature.show_group_colors -> show_group_colors:   boolean  "Draw bone group colors"
-#ID|Armature.show_names -> show_names:   boolean  "Draw bone names"
-#ID|Armature.show_only_ghost_selected -> show_only_ghost_selected:   boolean  "NO DESCRIPTION"
-#ID|Armature.use_auto_ik -> use_auto_ik:   boolean  "Add temporaral IK constraints while grabbing bones in Pose Mode"
-#ID|Armature.use_deform_delay -> use_deform_delay:   boolean  "Dont deform children when manipulating bones in Pose Mode"
-#ID|Armature.use_deform_envelopes -> use_deform_envelopes:   boolean  "Enable Bone Envelopes when defining deform"
-#ID|Armature.use_deform_preserve_volume -> use_deform_preserve_volume:   boolean  "Enable deform rotation with Quaternions"
-#ID|Armature.use_deform_vertex_groups -> use_deform_vertex_groups:   boolean  "Enable Vertex Groups when defining deform"
-#ID|Armature.use_mirror_x -> use_mirror_x:   boolean  "Apply changes to matching bone on opposite side of X-Axis"
-#ID|Brush.auto_smooth_factor -> auto_smooth_factor:   float  "Amount of smoothing to automatically apply to each stroke"
-#+ * ID|Brush.blend -> blend:   enum  "Brush blending mode"
-#+ * ID|Brush.clone_alpha -> clone_alpha:   float  "Opacity of clone image display"
-#+ * ID|Brush.clone_image -> clone_image:   pointer  "Image for clone tool"
-#+ * ID|Brush.clone_offset -> clone_offset:   float[2]  "NO DESCRIPTION"
-#+ * ID|Brush.color -> color:   float[3]  "NO DESCRIPTION"
-#+ * ID|Brush.crease_pinch_factor -> crease_pinch_factor:   float  "How much the crease brush pinches"
-#ID|Brush.cursor_color_add -> cursor_color_add:   float[3]  "Color of cursor when adding"
-#ID|Brush.cursor_color_subtract -> cursor_color_subtract:   float[3]  "Color of cursor when subtracting"
-#+ * ID|Brush.curve -> curve:   pointer,  "(read-only)    Editable falloff curve"
-#+ * ID|Brush.direction -> direction:   enum  "NO DESCRIPTION"
-#+ * ID|Brush.icon_filepath -> icon_filepath:   string  "File path to brush icon"
-#+ * ID|Brush.imagepaint_tool -> imagepaint_tool:   enum  "NO DESCRIPTION"
-#+ * ID|Brush.jitter -> jitter:   float  "Jitter the position of the brush while painting"
-#+ * ID|Brush.normal_weight -> normal_weight:   float  "How much grab will pull vertexes out of surface during a grab"
-#+ * ID|Brush.plane_offset -> plane_offset:   float  "Adjusts plane on which the brush acts towards or away from the object surface"
-#+ * ID|Brush.plane_trim -> plane_trim:   float  "If a vertex is further from offset plane than this then it is not affected"
-#+ * ID|Brush.rate -> rate:   float  "Interval between paints for Airbrush"
-#+ * ID|Brush.sculpt_plane -> sculpt_plane:   enum  "NO DESCRIPTION"
-#+ * ID|Brush.sculpt_tool -> sculpt_tool:   enum  "NO DESCRIPTION"
-#+ * ID|Brush.size -> size:   int  "Radius of the brush in pixels"
-#+ * ID|Brush.smooth_stroke_factor -> smooth_stroke_factor:   float  "Higher values give a smoother stroke"
-#+ * ID|Brush.smooth_stroke_radius -> smooth_stroke_radius:   int  "Minimum distance from last point before stroke continues"
-#ID|Brush.spacing -> spacing:   int  "Spacing between brush daubs as a percentage of brush diameter"
-#+ * ID|Brush.strength -> strength:   float  "How powerful the effect of the brush is when applied"
-#+ * ID|Brush.stroke_method -> stroke_method:   enum  "NO DESCRIPTION"
-#+ * ID|Brush.texture -> texture:   pointer  "NO DESCRIPTION"
-#ID|Brush.texture_angle_source_no_random -> texture_angle_source_no_random:   enum  "NO DESCRIPTION"
-#ID|Brush.texture_angle_source_random -> texture_angle_source_random:   enum  "NO DESCRIPTION"
-#+ * ID|Brush.texture_overlay_alpha -> texture_overlay_alpha:   int  "NO DESCRIPTION"
-#+ * ID|Brush.texture_sample_bias -> texture_sample_bias:   float  "Value added to texture samples"
-#+ * ID|Brush.texture_slot -> texture_slot:   pointer,  "(read-only)"
-#+ * ID|Brush.unprojected_radius -> unprojected_radius:   float  "Radius of brush in Blender units"
-#+ * ID|Brush.use_accumulate -> use_accumulate:   boolean  "Accumulate stroke dabs on top of each other"
-#+ * ID|Brush.use_adaptive_space -> use_adaptive_space:   boolean  "Space daubs according to surface orientation instead of screen space"
-#+ * ID|Brush.use_airbrush -> use_airbrush:   boolean  "Keep applying paint effect while holding mouse (spray)"
-#+ * ID|Brush.use_alpha -> use_alpha:   boolean  "When this is disabled, lock alpha while painting"
-#+ * ID|Brush.use_anchor -> use_anchor:   boolean  "Keep the brush anchored to the initial location"
-#+ * ID|Brush.use_custom_icon -> use_custom_icon:   boolean  "Set the brush icon from an image file"
-#ID|Brush.use_edge_to_edge -> use_edge_to_edge:   boolean  "Drag anchor brush from edge-to-edge"
-#+ * ID|Brush.use_frontface -> use_frontface:   boolean  "Brush only affects vertexes that face the viewer"
-#+ * ID|Brush.use_inverse_smooth_pressure -> use_inverse_smooth_pressure:   boolean  "Lighter pressure causes more smoothing to be applied"
-#+ * ID|Brush.use_locked_size -> use_locked_size:   boolean  "When locked brush stays same size relative to object; when unlocked brush size is given in pixels"
-#+ * ID|Brush.use_offset_pressure -> use_offset_pressure:   boolean  "Enable tablet pressure sensitivity for offset"
-#+ * ID|Brush.use_original_normal -> use_original_normal:   boolean  "When locked keep using normal of surface where stroke was initiated"
-#+ * ID|Brush.use_paint_sculpt -> use_paint_sculpt:   boolean  "Use this brush in sculpt mode"
-#+ * ID|Brush.use_paint_texture -> use_paint_texture:   boolean  "Use this brush in texture paint mode"
-#+ * ID|Brush.use_paint_vertex -> use_paint_vertex:   boolean  "Use this brush in vertex paint mode"
-#+ * ID|Brush.use_paint_weight -> use_paint_weight:   boolean  "Use this brush in weight paint mode"
-#+ * ID|Brush.use_persistent -> use_persistent:   boolean  "Sculpts on a persistent layer of the mesh"
-#+ * ID|Brush.use_plane_trim -> use_plane_trim:   boolean  "Enable Plane Trim"
-#ID|Brush.use_pressure_jitter -> use_pressure_jitter:   boolean  "Enable tablet pressure sensitivity for jitter"
-#ID|Brush.use_pressure_size -> use_pressure_size:   boolean  "Enable tablet pressure sensitivity for size"
-#ID|Brush.use_pressure_spacing -> use_pressure_spacing:   boolean  "Enable tablet pressure sensitivity for spacing"
-#ID|Brush.use_pressure_strength -> use_pressure_strength:   boolean  "Enable tablet pressure sensitivity for strength"
-#+ * ID|Brush.use_rake -> use_rake:   boolean  "Rotate the brush texture to match the stroke direction"
-#+ * ID|Brush.use_random_rotation -> use_random_rotation:   boolean  "Rotate the brush texture at random"
-#ID|Brush.use_restore_mesh -> use_restore_mesh:   boolean  "Allows a single dot to be carefully positioned"
-#+ * ID|Brush.use_smooth_stroke -> use_smooth_stroke:   boolean  "Brush lags behind mouse and follows a smoother path"
-#+ * ID|Brush.use_space -> use_space:   boolean  "Limit brush application to the distance specified by spacing"
-#+ * ID|Brush.use_space_atten -> use_space_atten:   boolean  "Automatically adjusts strength to give consistent results for different spacings"
-#+ * ID|Brush.use_texture_overlay -> use_texture_overlay:   boolean  "Show texture in viewport"
-#+ * ID|Brush.use_wrap -> use_wrap:   boolean  "Enable torus wrapping while painting"
-#+ * ID|Brush.vertexpaint_tool -> vertexpaint_tool:   enum  "NO DESCRIPTION"
-#+ * ID|Camera.angle -> angle:   float  "Perspective Camera lens field of view in degrees"
-#+ * ID|Camera.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#+ * ID|Camera.clip_end -> clip_end:   float  "Camera far clipping distance"
-#+ * ID|Camera.clip_start -> clip_start:   float  "Camera near clipping distance"
-#+ * ID|Camera.dof_distance -> dof_distance:   float  "Distance to the focus point for depth of field"
-#+ * ID|Camera.dof_object -> dof_object:   pointer  "Use this object to define the depth of field focal point"
-#+ * ID|Camera.draw_size -> draw_size:   float  "Apparent size of the Camera object in the 3D View"
-#+ * ID|Camera.lens -> lens:   float  "Perspective Camera lens value in millimeters"
-#+ * ID|Camera.lens_unit -> lens_unit:   enum  "Unit to edit lens in for the user interface"
-#+ * ID|Camera.ortho_scale -> ortho_scale:   float  "Orthographic Camera scale (similar to zoom)"
-#+ * ID|Camera.passepartout_alpha -> passepartout_alpha:   float  "Opacity (alpha) of the darkened overlay in Camera view"
-#+ * ID|Camera.shift_x -> shift_x:   float  "Perspective Camera horizontal shift"
-#+ * ID|Camera.shift_y -> shift_y:   float  "Perspective Camera vertical shift"
-#+ * ID|Camera.show_limits -> show_limits:   boolean  "Draw the clipping range and focus point on the camera"
-#+ * ID|Camera.show_mist -> show_mist:   boolean  "Draw a line from the Camera to indicate the mist area"
-#+ * ID|Camera.show_name -> show_name:   boolean  "Show the active Cameras name in Camera view"
-#+ * ID|Camera.show_passepartout -> show_passepartout:   boolean  "Show a darkened overlay outside the image area in Camera view"
-#+ * ID|Camera.show_title_safe -> show_title_safe:   boolean  "Show indicators for the title safe zone in Camera view"
-#+ * ID|Camera.type -> type:   enum  "Camera types"
-#ID|Camera.use_panorama -> use_panorama:   boolean  "Render the scene with a cylindrical camera for pseudo-fisheye lens effects"
-#+ * ID|Curve.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#+ * ID|Curve.bevel_depth -> bevel_depth:   float  "Bevel depth when not using a bevel object"
-#+ * ID|Curve.bevel_object -> bevel_object:   pointer  "Curve object name that defines the bevel shape"
-#+ * ID|Curve.bevel_resolution -> bevel_resolution:   int  "Bevel resolution when depth is non-zero and no specific bevel object has been defined"
-#+ * ID|Curve.dimensions -> dimensions:   enum  "Select 2D or 3D curve type"
-#+ * ID|Curve.eval_time -> eval_time:   float  "Parametric position along the length of the curve that Objects following it should be at. Position is evaluated by dividing by the Path Length value"
-#+ * ID|Curve.extrude -> extrude:   float  "Amount of curve extrusion when not using a bevel object"
-#+ * ID|Curve.materials -> materials:   collection,  "(read-only)"
-#ID|Curve.offset -> offset:   float  "Scale the original width (1.0) based on given factor"
-#ID|Curve.path_duration -> path_duration:   int  "The number of frames that are needed to traverse the path, defining the maximum value for the Evaluation Time setting"
-#+ * ID|Curve.render_resolution_u -> render_resolution_u:   int  "Surface resolution in U direction used while rendering. Zero skips this property"
-#+ * ID|Curve.render_resolution_v -> render_resolution_v:   int  "Surface resolution in V direction used while rendering. Zero skips this property"
-#+ * ID|Curve.resolution_u -> resolution_u:   int  "Surface resolution in U direction"
-#+ * ID|Curve.resolution_v -> resolution_v:   int  "Surface resolution in V direction"
-#+ * ID|Curve.shape_keys -> shape_keys:   pointer,  "(read-only)"
-#ID|Curve.show_handles -> show_handles:   boolean  "Display bezier handles in editmode"
-#ID|Curve.show_normal_face -> show_normal_face:   boolean  "Display 3D curve normals in editmode"
-#+ * ID|Curve.splines -> splines:   collection,  "(read-only)    Collection of splines in this curve data object"
-#+ * ID|Curve.taper_object -> taper_object:   pointer  "Curve object name that defines the taper (width)"
-#ID|Curve.texspace_location -> texspace_location:   float[3]  "Texture space location"
-#+ * ID|Curve.texspace_size -> texspace_size:   float[3]  "Texture space size"
-#+ * ID|Curve.twist_mode -> twist_mode:   enum  "The type of tilt calculation for 3D Curves"
-#+ * ID|Curve.twist_smooth -> twist_smooth:   float  "Smoothing iteration for tangents"
-#ID|Curve.use_auto_texspace -> use_auto_texspace:   boolean  "Adjusts active objects texture space automatically when transforming object"
-#+ * ID|Curve.use_deform_bounds -> use_deform_bounds:   boolean  "Use the mesh bounds to clamp the deformation"
-#ID|Curve.use_fill_back -> use_fill_back:   boolean  "Draw filled back for extruded/beveled curves"
-#ID|Curve.use_fill_deform -> use_fill_deform:   boolean  "Fill curve after applying deformation"
-#ID|Curve.use_fill_front -> use_fill_front:   boolean  "Draw filled front for extruded/beveled curves"
-#ID|Curve.use_map_on_length -> use_map_on_length:   boolean  "Generate texture mapping coordinates following the curve direction, rather than the local bounding box"
-#+ * ID|Curve.use_path -> use_path:   boolean  "Enable the curve to become a translation path"
-#+ * ID|Curve.use_path_follow -> use_path_follow:   boolean  "Make curve path children to rotate along the path"
-#+ * ID|Curve.use_radius -> use_radius:   boolean  "Option for paths: apply the curve radius with path following it and deforming"
-#+ * ID|Curve.use_stretch -> use_stretch:   boolean  "Option for curve-deform: makes deformed child to stretch along entire path"
-#+ * ID|Curve.use_time_offset -> use_time_offset:   boolean  "Children will use TimeOffs value as path distance offset"
-#ID|Curve|SurfaceCurve.use_map_on_length -> use_map_on_length:   boolean  "Generate texture mapping coordinates following the curve direction, rather than the local bounding box"
-#MAKE COLLECTION ATTR * ID|Curve|TextCurve.active_textbox -> active_textbox:   int  "NO DESCRIPTION"
-#ID|Curve|TextCurve.align -> align:   enum  "Text align from the object center"
-#+ * ID|Curve|TextCurve.body -> body:   string  "contents of this text object"
-#+ * ID|Curve|TextCurve.body_format -> body_format:   collection,  "(read-only)    Stores the style of each character"
-#+ * ID|Curve|TextCurve.edit_format -> edit_format:   pointer,  "(read-only)    Editing settings character formatting"
-#+ * ID|Curve|TextCurve.family -> family:   string  "Use Blender Objects as font characters. Give font objects a common name followed by the character it represents, eg. familya, familyb etc, and turn on Verts Duplication"
-#ID|Curve|TextCurve.follow_curve -> follow_curve:   pointer  "Curve deforming text object"
-#+ * ID|Curve|TextCurve.font -> font:   pointer  "NO DESCRIPTION"
-#+ * ID|Curve|TextCurve.offset_x -> offset_x:   float  "Horizontal offset from the object origin"
-#+ * ID|Curve|TextCurve.offset_y -> offset_y:   float  "Vertical offset from the object origin"
-#+ * ID|Curve|TextCurve.shear -> shear:   float  "Italic angle of the characters"
-#ID|Curve|TextCurve.size -> size:   float  "NO DESCRIPTION"
-#+ * ID|Curve|TextCurve.small_caps_scale -> small_caps_scale:   float  "Scale of small capitals"
-#ID|Curve|TextCurve.space_character -> space_character:   float  "NO DESCRIPTION"
-#ID|Curve|TextCurve.space_line -> space_line:   float  "NO DESCRIPTION"
-#ID|Curve|TextCurve.space_word -> space_word:   float  "NO DESCRIPTION"
-#ID|Curve|TextCurve.text_boxes -> text_boxes:   collection,  "(read-only)"
-#ID|Curve|TextCurve.underline_height -> underline_height:   float  "NO DESCRIPTION"
-#ID|Curve|TextCurve.underline_position -> underline_position:   float  "Vertical position of underline"
-#ID|Curve|TextCurve.use_fast_edit -> use_fast_edit:   boolean  "Dont fill polygons while editing"
-#ID|Curve|TextCurve.use_map_on_length -> use_map_on_length:   boolean  "Generate texture mapping coordinates following the curve direction, rather than the local bounding box"
-#+ * ID|GreasePencil.draw_mode -> draw_mode:   enum  "NO DESCRIPTION"
-#+ * ID|GreasePencil.layers -> layers:   collection,  "(read-only)"
-#+ * ID|GreasePencil.use_stroke_endpoints -> use_stroke_endpoints:   boolean  "Only use the first and last parts of the stroke for snapping"
-#+ * ID|Group.dupli_offset -> dupli_offset:   float[3]  "Offset from the origin to use when instancing as DupliGroup"
-#ID|Group.layers -> layers:   boolean[20]  "Layers visible when this groups is instanced as a dupli"
-#+ * ID|Group.objects -> objects:   collection,  "(read-only)    A collection of this groups objects"
-#+ * ID|Image.bindcode -> bindcode:   int,  "(read-only)    OpenGL bindcode"
-#+ * ID|Image.depth -> depth:   int,  "(read-only)    Image bit depth"
-#+ * ID|Image.display_aspect -> display_aspect:   float[2]  "Display Aspect for this image, does not affect rendering"
-#+ * ID|Image.field_order -> field_order:   enum  "Order of video fields. Select which lines are displayed first"
-#+ * ID|Image.file_format -> file_format:   enum  "Format used for re-saving this file"
-#+ * ID|Image.filepath -> filepath:   string  "Image/Movie file name"
-#+ * ID|Image.filepath_raw -> filepath_raw:   string  "Image/Movie file name (without data refreshing)"
-#ID|Image.fps -> fps:   int  "Speed of the animation in frames per second"
-#ID|Image.frame_end -> frame_end:   int  "End frame of an animated texture"
-#ID|Image.frame_start -> frame_start:   int  "Start frame of an animated texture"
-#+ * ID|Image.generated_height -> generated_height:   int  "Generated image height"
-#+ * ID|Image.generated_type -> generated_type:   enum  "Generated image type"
-#+ * ID|Image.generated_width -> generated_width:   int  "Generated image width"
-#+ * ID|Image.has_data -> has_data:   boolean,  "(read-only)    True if this image has data"
-#ID|Image.is_dirty -> is_dirty:   boolean,  "(read-only)    Image has changed and is not saved"
-#+ * ID|Image.mapping -> mapping:   enum  "Mapping type to use for this image in the game engine"
-#+ * ID|Image.packed_file -> packed_file:   pointer,  "(read-only)"
-#+ * ID|Image.size -> size:   int[2],  "(read-only)    Width and height in pixels, zero when image data cant be loaded"
-#+ * ID|Image.source -> source:   enum  "Where the image comes from"
-#+ * ID|Image.tiles_x -> tiles_x:   int  "Degree of repetition in the X direction"
-#+ * ID|Image.tiles_y -> tiles_y:   int  "Degree of repetition in the Y direction"
-#+ * ID|Image.type -> type:   enum,  "(read-only)    How to generate the image"
-#ID|Image.use_animation -> use_animation:   boolean  "Use as animated texture in the game engine"
-#ID|Image.use_clamp_x -> use_clamp_x:   boolean  "Disable texture repeating horizontally"
-#ID|Image.use_clamp_y -> use_clamp_y:   boolean  "Disable texture repeating vertically"
-#ID|Image.use_fields -> use_fields:   boolean  "Use fields of the image"
-#ID|Image.use_premultiply -> use_premultiply:   boolean  "Convert RGB from key alpha to premultiplied alpha"
-#ID|Image.use_tiles -> use_tiles:   boolean  "Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)"
-#+ * ID|Key.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#+ * ID|Key.keys -> keys:   collection,  "(read-only)    Shape keys"
-#+ * ID|Key.reference_key -> reference_key:   pointer,  "(read-only)"
-#+ * ID|Key.slurph -> slurph:   int  "Creates a delay in amount of frames in applying keypositions, first vertex goes first"
-#ID|Key.use_relative -> use_relative:   boolean  "Makes shape keys relative"
-#+ * ID|Key.user -> user:   pointer,  "(read-only)    Datablock using these shape keys"
-#+ * ID|Lamp.active_texture -> active_texture:   pointer  "Active texture slot being displayed"
-#+ * ID|Lamp.active_texture_index -> active_texture_index:   int  "Index of active texture slot"
-#+ * ID|Lamp.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#+ * ID|Lamp.color -> color:   float[3]  "Light color"
-#+ * ID|Lamp.distance -> distance:   float  "Falloff distance - the light is at half the original intensity at this point"
-#+ * ID|Lamp.energy -> energy:   float  "Amount of light that the lamp emits"
-#+ * ID|Lamp.texture_slots -> texture_slots:   collection,  "(read-only)    Texture slots defining the mapping and influence of textures"
-#+ * ID|Lamp.type -> type:   enum  "Type of Lamp"
-#ID|Lamp.use_diffuse -> use_diffuse:   boolean  "Lamp does diffuse shading"
-#ID|Lamp.use_negative -> use_negative:   boolean  "Lamp casts negative light"
-#ID|Lamp.use_own_layer -> use_own_layer:   boolean  "Illuminates objects only on the same layer the lamp is on"
-#ID|Lamp.use_specular -> use_specular:   boolean  "Lamp creates specular highlights"
-#+ * ID|Lamp|AreaLamp.gamma -> gamma:   float  "Light gamma correction value"
-#+ * ID|Lamp|AreaLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "Threshold for Adaptive Sampling (Raytraced shadows)"
-#+ * ID|Lamp|AreaLamp.shadow_color -> shadow_color:   float[3]  "Color of shadows cast by the lamp"
-#+ * ID|Lamp|AreaLamp.shadow_method -> shadow_method:   enum  "Method to compute lamp shadow with"
-#ID|Lamp|AreaLamp.shadow_ray_sample_method -> shadow_ray_sample_method:   enum  "Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower"
-#+ * ID|Lamp|AreaLamp.shadow_ray_samples_x -> shadow_ray_samples_x:   int  "Amount of samples taken extra (samples x samples)"
-#+ * ID|Lamp|AreaLamp.shadow_ray_samples_y -> shadow_ray_samples_y:   int  "Amount of samples taken extra (samples x samples)"
-#+ * ID|Lamp|AreaLamp.shadow_soft_size -> shadow_soft_size:   float  "Light size for ray shadow sampling (Raytraced shadows)"
-#+ * ID|Lamp|AreaLamp.shape -> shape:   enum  "Shape of the area lamp"
-#+ * ID|Lamp|AreaLamp.size -> size:   float  "Size of the area of the area Lamp, X direction size for Rectangle shapes"
-#+ * ID|Lamp|AreaLamp.size_y -> size_y:   float  "Size of the area of the area Lamp in the Y direction for Rectangle shapes"
-#ID|Lamp|AreaLamp.use_dither -> use_dither:   boolean  "Use 2x2 dithering for sampling  (Constant Jittered sampling)"
-#ID|Lamp|AreaLamp.use_jitter -> use_jitter:   boolean  "Use noise for sampling  (Constant Jittered sampling)"
-#ID|Lamp|AreaLamp.use_only_shadow -> use_only_shadow:   boolean  "Causes light to cast shadows only without illuminating objects"
-#ID|Lamp|AreaLamp.use_shadow_layer -> use_shadow_layer:   boolean  "Causes only objects on the same layer to cast shadows"
-#ID|Lamp|AreaLamp.use_umbra -> use_umbra:   boolean  "Emphasize parts that are fully shadowed (Constant Jittered sampling)"
-#+ * ID|Lamp|PointLamp.falloff_curve -> falloff_curve:   pointer,  "(read-only)    Custom Lamp Falloff Curve"
-#+ * ID|Lamp|PointLamp.falloff_type -> falloff_type:   enum  "Intensity Decay with distance"
-#+ * ID|Lamp|PointLamp.linear_attenuation -> linear_attenuation:   float  "Linear distance attenuation"
-#+ * ID|Lamp|PointLamp.quadratic_attenuation -> quadratic_attenuation:   float  "Quadratic distance attenuation"
-#+ * ID|Lamp|PointLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "Threshold for Adaptive Sampling (Raytraced shadows)"
-#+ * ID|Lamp|PointLamp.shadow_color -> shadow_color:   float[3]  "Color of shadows cast by the lamp"
-#+ * ID|Lamp|PointLamp.shadow_method -> shadow_method:   enum  "Method to compute lamp shadow with"
-#ID|Lamp|PointLamp.shadow_ray_sample_method -> shadow_ray_sample_method:   enum  "Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower"
-#+ * ID|Lamp|PointLamp.shadow_ray_samples -> shadow_ray_samples:   int  "Amount of samples taken extra (samples x samples)"
-#+ * ID|Lamp|PointLamp.shadow_soft_size -> shadow_soft_size:   float  "Light size for ray shadow sampling (Raytraced shadows)"
-#ID|Lamp|PointLamp.use_only_shadow -> use_only_shadow:   boolean  "Causes light to cast shadows only without illuminating objects"
-#ID|Lamp|PointLamp.use_shadow_layer -> use_shadow_layer:   boolean  "Causes only objects on the same layer to cast shadows"
-#ID|Lamp|PointLamp.use_sphere -> use_sphere:   boolean  "Sets light intensity to zero beyond lamp distance"
-#+ * ID|Lamp|SpotLamp.compression_threshold -> compression_threshold:   float  "Deep shadow map compression threshold"
-#+ * ID|Lamp|SpotLamp.falloff_curve -> falloff_curve:   pointer,  "(read-only)    Custom Lamp Falloff Curve"
-#+ * ID|Lamp|SpotLamp.falloff_type -> falloff_type:   enum  "Intensity Decay with distance"
-#+ * ID|Lamp|SpotLamp.halo_intensity -> halo_intensity:   float  "Brightness of the spotlights halo cone  (Buffer Shadows)"
-#+ * ID|Lamp|SpotLamp.halo_step -> halo_step:   int  "Volumetric halo sampling frequency"
-#+ * ID|Lamp|SpotLamp.linear_attenuation -> linear_attenuation:   float  "Linear distance attenuation"
-#+ * ID|Lamp|SpotLamp.quadratic_attenuation -> quadratic_attenuation:   float  "Quadratic distance attenuation"
-#+ * ID|Lamp|SpotLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "Threshold for Adaptive Sampling (Raytraced shadows)"
-#+ * ID|Lamp|SpotLamp.shadow_buffer_bias -> shadow_buffer_bias:   float  "Shadow buffer sampling bias"
-#+ * ID|Lamp|SpotLamp.shadow_buffer_clip_end -> shadow_buffer_clip_end:   float  "Shadow map clip end beyond which objects will not generate shadows"
-#+ * ID|Lamp|SpotLamp.shadow_buffer_clip_start -> shadow_buffer_clip_start:   float  "Shadow map clip start: objects closer will not generate shadows"
-#+ * ID|Lamp|SpotLamp.shadow_buffer_samples -> shadow_buffer_samples:   int  "Number of shadow buffer samples"
-#+ * ID|Lamp|SpotLamp.shadow_buffer_size -> shadow_buffer_size:   int  "Resolution of the shadow buffer, higher values give crisper shadows but use more memory"
-#+ * ID|Lamp|SpotLamp.shadow_buffer_soft -> shadow_buffer_soft:   float  "Size of shadow buffer sampling area"
-#+ * ID|Lamp|SpotLamp.shadow_buffer_type -> shadow_buffer_type:   enum  "Type of shadow buffer"
-#+ * ID|Lamp|SpotLamp.shadow_color -> shadow_color:   float[3]  "Color of shadows cast by the lamp"
-#+ * ID|Lamp|SpotLamp.shadow_filter_type -> shadow_filter_type:   enum  "Type of shadow filter (Buffer Shadows)"
-#+ * ID|Lamp|SpotLamp.shadow_method -> shadow_method:   enum  "Method to compute lamp shadow with"
-#ID|Lamp|SpotLamp.shadow_ray_sample_method -> shadow_ray_sample_method:   enum  "Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower"
-#+ * ID|Lamp|SpotLamp.shadow_ray_samples -> shadow_ray_samples:   int  "Amount of samples taken extra (samples x samples)"
-#+ * ID|Lamp|SpotLamp.shadow_sample_buffers -> shadow_sample_buffers:   enum  "Number of shadow buffers to render for better AA, this increases memory usage"
-#+ * ID|Lamp|SpotLamp.shadow_soft_size -> shadow_soft_size:   float  "Light size for ray shadow sampling (Raytraced shadows)"
-#+ * ID|Lamp|SpotLamp.show_cone -> show_cone:   boolean  "Draw transparent cone in 3D view to visualize which objects are contained in it"
-#+ * ID|Lamp|SpotLamp.spot_blend -> spot_blend:   float  "The softness of the spotlight edge"
-#+ * ID|Lamp|SpotLamp.spot_size -> spot_size:   float  "Angle of the spotlight beam in degrees"
-#ID|Lamp|SpotLamp.use_auto_clip_end -> use_auto_clip_end:   boolean  "Automatic calculation of clipping-end, based on visible vertices"
-#ID|Lamp|SpotLamp.use_auto_clip_start -> use_auto_clip_start:   boolean  "Automatic calculation of clipping-start, based on visible vertices"
-#ID|Lamp|SpotLamp.use_halo -> use_halo:   boolean  "Renders spotlight with a volumetric halo (Buffer Shadows)"
-#ID|Lamp|SpotLamp.use_only_shadow -> use_only_shadow:   boolean  "Causes light to cast shadows only without illuminating objects"
-#ID|Lamp|SpotLamp.use_shadow_layer -> use_shadow_layer:   boolean  "Causes only objects on the same layer to cast shadows"
-#ID|Lamp|SpotLamp.use_sphere -> use_sphere:   boolean  "Sets light intensity to zero beyond lamp distance"
-#ID|Lamp|SpotLamp.use_square -> use_square:   boolean  "Casts a square spot light shape"
-#+ * ID|Lamp|SunLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "Threshold for Adaptive Sampling (Raytraced shadows)"
-#+ * ID|Lamp|SunLamp.shadow_color -> shadow_color:   float[3]  "Color of shadows cast by the lamp"
-#+ * ID|Lamp|SunLamp.shadow_method -> shadow_method:   enum  "Method to compute lamp shadow with"
-#ID|Lamp|SunLamp.shadow_ray_sample_method -> shadow_ray_sample_method:   enum  "Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower"
-#+ * ID|Lamp|SunLamp.shadow_ray_samples -> shadow_ray_samples:   int  "Amount of samples taken extra (samples x samples)"
-#+ * ID|Lamp|SunLamp.shadow_soft_size -> shadow_soft_size:   float  "Light size for ray shadow sampling (Raytraced shadows)"
-#+ * ID|Lamp|SunLamp.sky -> sky:   pointer,  "(read-only)    Sky related settings for sun lamps"
-#ID|Lamp|SunLamp.use_only_shadow -> use_only_shadow:   boolean  "Causes light to cast shadows only without illuminating objects"
-#ID|Lamp|SunLamp.use_shadow_layer -> use_shadow_layer:   boolean  "Causes only objects on the same layer to cast shadows"
-#+ * ID|Lattice.interpolation_type_u -> interpolation_type_u:   enum  "NO DESCRIPTION"
-#+ * ID|Lattice.interpolation_type_v -> interpolation_type_v:   enum  "NO DESCRIPTION"
-#+ * ID|Lattice.interpolation_type_w -> interpolation_type_w:   enum  "NO DESCRIPTION"
-#+ * ID|Lattice.points -> points:   collection,  "(read-only)    Points of the lattice"
-#+ * ID|Lattice.points_u -> points_u:   int  "Points in U direction (cant be changed when there are shape keys)"
-#+ * ID|Lattice.points_v -> points_v:   int  "Points in V direction (cant be changed when there are shape keys)"
-#+ * ID|Lattice.points_w -> points_w:   int  "Points in W direction (cant be changed when there are shape keys)"
-#+ * ID|Lattice.shape_keys -> shape_keys:   pointer,  "(read-only)"
-#ID|Lattice.use_outside -> use_outside:   boolean  "Only draw, and take into account, the outer vertices"
-#+ * ID|Lattice.vertex_group -> vertex_group:   string  "Vertex group to apply the influence of the lattice"
-#+ * ID|Library.filepath -> filepath:   string  "Path to the library .blend file"
-#+ * ID|Library.parent -> parent:   pointer,  "(read-only)"
-#+ * ID|Material.active_node_material -> active_node_material:   pointer  "Active node material"
-#+ * ID|Material.active_texture -> active_texture:   pointer  "Active texture slot being displayed"
-#+ * ID|Material.active_texture_index -> active_texture_index:   int  "Index of active texture slot"
-#+ * ID|Material.alpha -> alpha:   float  "Alpha transparency of the material"
-#+ * ID|Material.ambient -> ambient:   float  "Amount of global ambient color the material receives"
-#+ * ID|Material.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#+ * ID|Material.darkness -> darkness:   float  "Minnaert darkness"
-#+ * ID|Material.diffuse_color -> diffuse_color:   float[3]  "NO DESCRIPTION"
-#+ * ID|Material.diffuse_fresnel -> diffuse_fresnel:   float  "Power of Fresnel"
-#+ * ID|Material.diffuse_fresnel_factor -> diffuse_fresnel_factor:   float  "Blending factor of Fresnel"
-#+ * ID|Material.diffuse_intensity -> diffuse_intensity:   float  "Amount of diffuse reflection"
-#+ * ID|Material.diffuse_ramp -> diffuse_ramp:   pointer,  "(read-only)    Color ramp used to affect diffuse shading"
-#+ * ID|Material.diffuse_ramp_blend -> diffuse_ramp_blend:   enum  "NO DESCRIPTION"
-#+ * ID|Material.diffuse_ramp_factor -> diffuse_ramp_factor:   float  "Blending factor (also uses alpha in Colorband)"
-#+ * ID|Material.diffuse_ramp_input -> diffuse_ramp_input:   enum  "NO DESCRIPTION"
-#+ * ID|Material.diffuse_shader -> diffuse_shader:   enum  "NO DESCRIPTION"
-#+ * ID|Material.diffuse_toon_size -> diffuse_toon_size:   float  "Size of diffuse toon area"
-#+ * ID|Material.diffuse_toon_smooth -> diffuse_toon_smooth:   float  "Smoothness of diffuse toon area"
-#+ * ID|Material.emit -> emit:   float  "Amount of light to emit"
-#+ * ID|Material.halo -> halo:   pointer,  "(read-only)    Halo settings for the material"
-#+ * ID|Material.invert_z -> invert_z:   boolean  "Renders materials faces with an inverted Z buffer (scanline only)"
-#+ * ID|Material.light_group -> light_group:   pointer  "Limit lighting to lamps in this Group"
-#+ * ID|Material.mirror_color -> mirror_color:   float[3]  "Mirror color of the material"
-#+ * ID|Material.node_tree -> node_tree:   pointer,  "(read-only)    Node tree for node based materials"
-#ID|Material.offset_z -> offset_z:   float  "Gives faces an artificial offset in the Z buffer for Z transparency"
-#+ * ID|Material.physics -> physics:   pointer,  "(read-only)    Game physics settings"
-#+ * ID|Material.preview_render_type -> preview_render_type:   enum  "Type of preview render"
-#+ * ID|Material.raytrace_mirror -> raytrace_mirror:   pointer,  "(read-only)    Raytraced reflection settings for the material"
-#+ * ID|Material.raytrace_transparency -> raytrace_transparency:   pointer,  "(read-only)    Raytraced transparency settings for the material"
-#+ * ID|Material.roughness -> roughness:   float  "Oren-Nayar Roughness"
-#+ * ID|Material.shadow_buffer_bias -> shadow_buffer_bias:   float  "Factor to multiply shadow buffer bias with (0 is ignore.)"
-#ID|Material.shadow_cast_alpha -> shadow_cast_alpha:   float  "Shadow casting alpha, in use for Irregular and Deep shadow buffer"
-#+ * ID|Material.shadow_ray_bias -> shadow_ray_bias:   float  "Shadow raytracing bias to prevent terminator problems on shadow boundary"
-#+ * ID|Material.specular_alpha -> specular_alpha:   float  "Alpha transparency for specular areas"
-#+ * ID|Material.specular_color -> specular_color:   float[3]  "Specular color of the material"
-#+ * ID|Material.specular_hardness -> specular_hardness:   int  "NO DESCRIPTION"
-#+ * ID|Material.specular_intensity -> specular_intensity:   float  "NO DESCRIPTION"
-#+ * ID|Material.specular_ior -> specular_ior:   float  "NO DESCRIPTION"
-#+ * ID|Material.specular_ramp -> specular_ramp:   pointer,  "(read-only)    Color ramp used to affect specular shading"
-#+ * ID|Material.specular_ramp_blend -> specular_ramp_blend:   enum  "NO DESCRIPTION"
-#+ * ID|Material.specular_ramp_factor -> specular_ramp_factor:   float  "Blending factor (also uses alpha in Colorband)"
-#+ * ID|Material.specular_ramp_input -> specular_ramp_input:   enum  "NO DESCRIPTION"
-#+ * ID|Material.specular_shader -> specular_shader:   enum  "NO DESCRIPTION"
-#+ * ID|Material.specular_slope -> specular_slope:   float  "The standard deviation of surface slope"
-#+ * ID|Material.specular_toon_size -> specular_toon_size:   float  "Size of specular toon area"
-#+ * ID|Material.specular_toon_smooth -> specular_toon_smooth:   float  "Smoothness of specular toon area"
-#+ * ID|Material.strand -> strand:   pointer,  "(read-only)    Strand settings for the material"
-#+ * ID|Material.subsurface_scattering -> subsurface_scattering:   pointer,  "(read-only)    Subsurface scattering settings for the material"
-#+ * ID|Material.texture_slots -> texture_slots:   collection,  "(read-only)    Texture slots defining the mapping and influence of textures"
-#+ * ID|Material.translucency -> translucency:   float  "Amount of diffuse shading on the back side"
-#+ * ID|Material.transparency_method -> transparency_method:   enum  "Method to use for rendering transparency"
-#+ * ID|Material.type -> type:   enum  "Material type defining how the object is rendered"
-#ID|Material.use_cast_approximate -> use_cast_approximate:   boolean  "Allow this material to cast shadows when using approximate ambient occlusion."
-#ID|Material.use_cast_buffer_shadows -> use_cast_buffer_shadows:   boolean  "Allow this material to cast shadows from shadow buffer lamps"
-#ID|Material.use_cast_shadows_only -> use_cast_shadows_only:   boolean  "Makes objects with this material appear invisible, only casting shadows (not rendered)"
-#ID|Material.use_cubic -> use_cubic:   boolean  "Use cubic interpolation for diffuse values, for smoother transitions"
-#+ * ID|Material.use_diffuse_ramp -> use_diffuse_ramp:   boolean  "Toggle diffuse ramp operations"
-#ID|Material.use_face_texture -> use_face_texture:   boolean  "Replaces the objects base color with color from face assigned image textures"
-#ID|Material.use_face_texture_alpha -> use_face_texture_alpha:   boolean  "Replaces the objects base alpha value with alpha from face assigned image textures"
-#ID|Material.use_full_oversampling -> use_full_oversampling:   boolean  "Force this material to render full shading/textures for all anti-aliasing samples"
-#ID|Material.use_light_group_exclusive -> use_light_group_exclusive:   boolean  "Material uses the light group exclusively - these lamps are excluded from other scene lighting"
-#ID|Material.use_mist -> use_mist:   boolean  "Use mist with this material (in world settings)"
-#+ * ID|Material.use_nodes -> use_nodes:   boolean  "Use shader nodes to render the material"
-#ID|Material.use_object_color -> use_object_color:   boolean  "Modulate the result with a per-object color"
-#ID|Material.use_only_shadow -> use_only_shadow:   boolean  "Renders shadows as the materials alpha value, making materials transparent except for shadowed areas"
-#ID|Material.use_ray_shadow_bias -> use_ray_shadow_bias:   boolean  "Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)"
-#ID|Material.use_raytrace -> use_raytrace:   boolean  "Include this material and geometry that uses it in ray tracing calculations"
-#ID|Material.use_shadeless -> use_shadeless:   boolean  "Makes this material insensitive to light or shadow"
-#ID|Material.use_shadows -> use_shadows:   boolean  "Allows this material to receive shadows"
-#+ * ID|Material.use_sky -> use_sky:   boolean  "Renders this material with zero alpha, with sky background in place (scanline only)"
-#+ * ID|Material.use_specular_ramp -> use_specular_ramp:   boolean  "Toggle specular ramp operations"
-#ID|Material.use_tangent_shading -> use_tangent_shading:   boolean  "Use the materials tangent vector instead of the normal for shading - for anisotropic shading effects"
-#+ * ID|Material.use_textures -> use_textures:   boolean[18]  "Enable/Disable each texture"
-#ID|Material.use_transparency -> use_transparency:   boolean  "Render material as transparent"
-#ID|Material.use_transparent_shadows -> use_transparent_shadows:   boolean  "Allow this object to receive transparent shadows casted through other objects"
-#ID|Material.use_vertex_color_light -> use_vertex_color_light:   boolean  "Add vertex colors as additional lighting"
-#ID|Material.use_vertex_color_paint -> use_vertex_color_paint:   boolean  "Replaces object base color with vertex colors (multiplies with texture face face assigned textures)"
-#+ * ID|Material.volume -> volume:   pointer,  "(read-only)    Volume settings for the material"
-#+ * ID|Mesh.active_uv_texture_index -> active_uv_texture_index:   int  "Active UV texture index"
-#+ * ID|Mesh.active_vertex_color_index -> active_vertex_color_index:   int  "Active vertex color index"
-#+ * ID|Mesh.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#ID|Mesh.auto_smooth_angle -> auto_smooth_angle:   int  "Defines maximum angle between face normals that Auto Smooth will operate on"
-#+ * ID|Mesh.edges -> edges:   collection,  "(read-only)    Edges of the mesh"
-#+ * ID|Mesh.faces -> faces:   collection,  "(read-only)    Faces of the mesh"
-#ID|Mesh.layers_float -> layers_float:   collection,  "(read-only)"
-#ID|Mesh.layers_int -> layers_int:   collection,  "(read-only)"
-#ID|Mesh.layers_string -> layers_string:   collection,  "(read-only)"
-#+ * ID|Mesh.materials -> materials:   collection,  "(read-only)"
-#+ * ID|Mesh.shape_keys -> shape_keys:   pointer,  "(read-only)"
-#ID|Mesh.show_all_edges -> show_all_edges:   boolean  "Displays all edges for wireframe in all view modes in the 3D view"
-#ID|Mesh.show_double_sided -> show_double_sided:   boolean  "Render/display the mesh with double or single sided lighting"
-#ID|Mesh.show_edge_bevel_weight -> show_edge_bevel_weight:   boolean  "Displays weights created for the Bevel modifier"
-#ID|Mesh.show_edge_crease -> show_edge_crease:   boolean  "Displays creases created for subsurf weighting"
-#ID|Mesh.show_edge_seams -> show_edge_seams:   boolean  "Displays UV unwrapping seams"
-#ID|Mesh.show_edge_sharp -> show_edge_sharp:   boolean  "Displays sharp edges, used with the EdgeSplit modifier"
-#ID|Mesh.show_edges -> show_edges:   boolean  "Displays selected edges using highlights in the 3D view and UV editor"
-#ID|Mesh.show_extra_edge_angle -> show_extra_edge_angle:   boolean  "Displays the angles in the selected edges in degrees, Using global values when set in the transform panel"
-#ID|Mesh.show_extra_edge_length -> show_extra_edge_length:   boolean  "Displays selected edge lengths, Using global values when set in the transform panel"
-#ID|Mesh.show_extra_face_area -> show_extra_face_area:   boolean  "Displays the area of selected faces, Using global values when set in the transform panel"
-#ID|Mesh.show_faces -> show_faces:   boolean  "Displays all faces as shades in the 3D view and UV editor"
-#ID|Mesh.show_normal_face -> show_normal_face:   boolean  "Displays face normals as lines"
-#ID|Mesh.show_normal_vertex -> show_normal_vertex:   boolean  "Displays vertex normals as lines"
-#+ * ID|Mesh.sticky -> sticky:   collection,  "(read-only)    Sticky texture coordinates"
-#+ * ID|Mesh.texco_mesh -> texco_mesh:   pointer  "Derive texture coordinates from another mesh"
-#ID|Mesh.texspace_location -> texspace_location:   float[3]  "Texture space location"
-#+ * ID|Mesh.texspace_size -> texspace_size:   float[3]  "Texture space size"
-#+ * ID|Mesh.texture_mesh -> texture_mesh:   pointer  "Use another mesh for texture indices (vertex indices must be aligned)"
-#+ * ID|Mesh.total_edge_sel -> total_edge_sel:   int,  "(read-only)    Selected edge count in editmode"
-#+ * ID|Mesh.total_face_sel -> total_face_sel:   int,  "(read-only)    Selected face count in editmode"
-#+ * ID|Mesh.total_vert_sel -> total_vert_sel:   int,  "(read-only)    Selected vertex count in editmode"
-#ID|Mesh.use_auto_smooth -> use_auto_smooth:   boolean  "Treats all set-smoothed faces with angles less than the specified angle as smooth during render"
-#ID|Mesh.use_auto_texspace -> use_auto_texspace:   boolean  "Adjusts active objects texture space automatically when transforming object"
-#+ * ID|Mesh.use_mirror_topology -> use_mirror_topology:   boolean  "Use topology based mirroring"
-#+ * ID|Mesh.use_mirror_x -> use_mirror_x:   boolean  "X Axis mirror editing"
-#+ * ID|Mesh.use_paint_mask -> use_paint_mask:   boolean  "Face selection masking for painting"
-#+ * ID|Mesh.uv_texture_clone -> uv_texture_clone:   pointer  "UV texture to be used as cloning source"
-#+ * ID|Mesh.uv_texture_clone_index -> uv_texture_clone_index:   int  "Clone UV texture index"
-#+ * ID|Mesh.uv_texture_stencil -> uv_texture_stencil:   pointer  "UV texture to mask the painted area"
-#+ * ID|Mesh.uv_texture_stencil_index -> uv_texture_stencil_index:   int  "Mask UV texture index"
-#+ * ID|Mesh.uv_textures -> uv_textures:   collection,  "(read-only)"
-#+ * ID|Mesh.vertex_colors -> vertex_colors:   collection,  "(read-only)"
-#ID|Mesh.vertices -> vertices:   collection,  "(read-only)    Vertices of the mesh"
-#+ * ID|MetaBall.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#+ * ID|MetaBall.elements -> elements:   collection,  "(read-only)    Meta elements"
-#+ * ID|MetaBall.materials -> materials:   collection,  "(read-only)"
-#ID|MetaBall.render_resolution -> render_resolution:   float  "Polygonization resolution in rendering"
-#ID|MetaBall.resolution -> resolution:   float  "Polygonization resolution in the 3D viewport"
-#ID|MetaBall.texspace_location -> texspace_location:   float[3]  "Texture space location"
-#+ * ID|MetaBall.texspace_size -> texspace_size:   float[3]  "Texture space size"
-#+ * ID|MetaBall.threshold -> threshold:   float  "Influence of meta elements"
-#ID|MetaBall.update_method -> update_method:   enum  "Metaball edit update behavior"
-#ID|MetaBall.use_auto_texspace -> use_auto_texspace:   boolean  "Adjusts active objects texture space automatically when transforming object"
-#+ * ID|NodeTree.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#+ * ID|NodeTree.grease_pencil -> grease_pencil:   pointer  "Grease Pencil datablock"
-#+ * ID|NodeTree.nodes -> nodes:   collection,  "(read-only)"
-#+ * ID|Object.active_material -> active_material:   pointer  "Active material being displayed"
-#+ * ID|Object.active_material_index -> active_material_index:   int  "Index of active material slot"
-#+ * ID|Object.active_particle_system -> active_particle_system:   pointer,  "(read-only)    Active particle system being displayed"
-#+ * ID|Object.active_particle_system_index -> active_particle_system_index:   int  "Index of active particle system slot"
-#+ * ID|Object.active_shape_key -> active_shape_key:   pointer,  "(read-only)    Current shape key"
-#+ * ID|Object.active_shape_key_index -> active_shape_key_index:   int  "Current shape key index"
-#+ * ID|Object.active_vertex_group -> active_vertex_group:   pointer,  "(read-only)    Vertex groups of the object"
-#+ * ID|Object.active_vertex_group_index -> active_vertex_group_index:   int  "Active index in vertex group array"
-#+ * ID|Object.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#+ * ID|Object.animation_visualisation -> animation_visualisation:   pointer,  "(read-only)    Animation data for this datablock"
-#+ * ID|Object.bound_box -> bound_box:   float[24],  "(read-only)    Objects bound box in object-space coordinates"
-#+ * ID|Object.collision -> collision:   pointer,  "(read-only)    Settings for using the objects as a collider in physics simulation"
-#+ * ID|Object.color -> color:   float[4]  "Object color and alpha, used when faces have the ObColor mode enabled"
-#+ * ID|Object.constraints -> constraints:   collection,  "(read-only)    Constraints affecting the transformation of the object"
-#+ * ID|Object.data -> data:   pointer  "Object data"
-#+ * ID|Object.delta_location -> delta_location:   float[3]  "Extra translation added to the location of the object"
-#+ * ID|Object.delta_rotation_euler -> delta_rotation_euler:   float[3]  "Extra rotation added to the rotation of the object (when using Euler rotations)"
-#+ * ID|Object.delta_rotation_quaternion -> delta_rotation_quaternion:   float[4]  "Extra rotation added to the rotation of the object (when using Quaternion rotations)"
-#+ * ID|Object.delta_scale -> delta_scale:   float[3]  "Extra scaling added to the scale of the object"
-#+ * ID|Object.dimensions -> dimensions:   float[3]  "Absolute bounding box dimensions of the object"
-#+ * ID|Object.draw_bounds_type -> draw_bounds_type:   enum  "Object boundary display type"
-#ID|Object.draw_type -> draw_type:   enum  "Maximum draw type to display object with in viewport"
-#+ * ID|Object.dupli_faces_scale -> dupli_faces_scale:   float  "Scale the DupliFace objects"
-#+ * ID|Object.dupli_frames_end -> dupli_frames_end:   int  "End frame for DupliFrames"
-#+ * ID|Object.dupli_frames_off -> dupli_frames_off:   int  "Recurring frames to exclude from the Dupliframes"
-#+ * ID|Object.dupli_frames_on -> dupli_frames_on:   int  "Number of frames to use between DupOff frames"
-#+ * ID|Object.dupli_frames_start -> dupli_frames_start:   int  "Start frame for DupliFrames"
-#+ * ID|Object.dupli_group -> dupli_group:   pointer  "Instance an existing group"
-#+ * ID|Object.dupli_list -> dupli_list:   collection,  "(read-only)    Object duplis"
-#+ * ID|Object.dupli_type -> dupli_type:   enum  "If not None, object duplication method to use"
-#+ * ID|Object.empty_draw_size -> empty_draw_size:   float  "Size of display for empties in the viewport"
-#+ * ID|Object.empty_draw_type -> empty_draw_type:   enum  "Viewport display style for empties"
-#+ * ID|Object.field -> field:   pointer,  "(read-only)    Settings for using the objects as a field in physics simulation"
-#+ * ID|Object.game -> game:   pointer,  "(read-only)    Game engine related settings for the object"
-#+ * ID|Object.grease_pencil -> grease_pencil:   pointer  "Grease Pencil datablock"
-#+ * ID|Object.hide -> hide:   boolean  "Restrict visibility in the viewport"
-#+ * ID|Object.hide_render -> hide_render:   boolean  "Restrict renderability"
-#+ * ID|Object.hide_select -> hide_select:   boolean  "Restrict selection in the viewport"
-#ID|Object.is_duplicator -> is_duplicator:   boolean,  "(read-only)"
-#+ * ID|Object.layers -> layers:   boolean[20]  "Layers the object is on"
-#+ * ID|Object.location -> location:   float[3]  "Location of the object"
-#+ * ID|Object.lock_location -> lock_location:   boolean[3]  "Lock editing of location in the interface"
-#+ * ID|Object.lock_rotation -> lock_rotation:   boolean[3]  "Lock editing of rotation in the interface"
-#+ * ID|Object.lock_rotation_w -> lock_rotation_w:   boolean  "Lock editing of angle component of four-component rotations in the interface"
-#+ * ID|Object.lock_rotations_4d -> lock_rotations_4d:   boolean  "Lock editing of four component rotations by components (instead of as Eulers)"
-#+ * ID|Object.lock_scale -> lock_scale:   boolean[3]  "Lock editing of scale in the interface"
-#+ * ID|Object.material_slots -> material_slots:   collection,  "(read-only)    Material slots in the object"
-#+ * ID|Object.matrix_local -> matrix_local:   float[16]  "Parent relative transformation matrix"
-#+ * ID|Object.matrix_world -> matrix_world:   float[16]  "Worldspace transformation matrix"
-#+ * ID|Object.mode -> mode:   enum,  "(read-only)    Object interaction mode"
-#+ * ID|Object.modifiers -> modifiers:   collection,  "(read-only)    Modifiers affecting the geometric data of the object"
-#+ * ID|Object.motion_path -> motion_path:   pointer,  "(read-only)    Motion Path for this element"
-#+ * ID|Object.parent -> parent:   pointer  "Parent Object"
-#+ * ID|Object.parent_bone -> parent_bone:   string  "Name of parent bone in case of a bone parenting relation"
-#+ * ID|Object.parent_type -> parent_type:   enum  "Type of parent relation"
-#+ * ID|Object.parent_vertices -> parent_vertices:   int[3],  "(read-only)    Indices of vertices in cases of a vertex parenting relation"
-#+ * ID|Object.particle_systems -> particle_systems:   collection,  "(read-only)    Particle systems emitted from the object"
-#+ * ID|Object.pass_index -> pass_index:   int  "Index # for the IndexOB render pass"
-#+ * ID|Object.pose -> pose:   pointer,  "(read-only)    Current pose for armatures"
-#+ * ID|Object.pose_library -> pose_library:   pointer,  "(read-only)    Action used as a pose library for armatures"
-#+ * ID|Object.proxy -> proxy:   pointer,  "(read-only)    Library object this proxy object controls"
-#+ * ID|Object.proxy_group -> proxy_group:   pointer,  "(read-only)    Library group duplicator object this proxy object controls"
-#+ * ID|Object.rotation_axis_angle -> rotation_axis_angle:   float[4]  "Angle of Rotation for Axis-Angle rotation representation"
-#+ * ID|Object.rotation_euler -> rotation_euler:   float[3]  "Rotation in Eulers"
-#+ * ID|Object.rotation_mode -> rotation_mode:   enum  "NO DESCRIPTION"
-#+ * ID|Object.rotation_quaternion -> rotation_quaternion:   float[4]  "Rotation in Quaternions"
-#+ * ID|Object.scale -> scale:   float[3]  "Scaling of the object"
-#+ * ID|Object.select -> select:   boolean  "Object selection state"
-#ID|Object.show_axis -> show_axis:   boolean  "Displays the objects origin and axis"
-#ID|Object.show_bounds -> show_bounds:   boolean  "Displays the objects bounds"
-#ID|Object.show_name -> show_name:   boolean  "Displays the objects name"
-#ID|Object.show_shape_key -> show_shape_key:   boolean  "Always show the current Shape for this Object"
-#ID|Object.show_texture_space -> show_texture_space:   boolean  "Displays the objects texture space"
-#ID|Object.show_transparent -> show_transparent:   boolean  "Enables transparent materials for the object (Mesh only)"
-#ID|Object.show_wire -> show_wire:   boolean  "Adds the objects wireframe over solid drawing"
-#ID|Object.show_x_ray -> show_x_ray:   boolean  "Makes the object draw in front of others"
-#+ * ID|Object.soft_body -> soft_body:   pointer,  "(read-only)    Settings for soft body simulation"
-#+ * ID|Object.time_offset -> time_offset:   float  "Animation offset in frames for F-Curve and dupligroup instances"
-#+ * ID|Object.track_axis -> track_axis:   enum  "Axis that points in forward direction"
-#+ * ID|Object.type -> type:   enum,  "(read-only)    Type of Object"
-#+ * ID|Object.up_axis -> up_axis:   enum  "Axis that points in the upward direction"
-#+ * ID|Object.use_dupli_faces_scale -> use_dupli_faces_scale:   boolean  "Scale dupli based on face size"
-#+ * ID|Object.use_dupli_frames_speed -> use_dupli_frames_speed:   boolean  "Set dupliframes to use the frame"
-#ID|Object.use_dupli_vertices_rotation -> use_dupli_vertices_rotation:   boolean  "Rotate dupli according to vertex normal"
-#ID|Object.use_shape_key_edit_mode -> use_shape_key_edit_mode:   boolean  "Apply shape keys in edit mode (for Meshes only)"
-#ID|Object.use_slow_parent -> use_slow_parent:   boolean  "Create a delay in the parent relationship"
-#ID|Object.use_time_offset_add_parent -> use_time_offset_add_parent:   boolean  "Add the parents time offset value"
-#ID|Object.use_time_offset_edit -> use_time_offset_edit:   boolean  "Use time offset when inserting keys and display time offset for F-Curve and action views"
-#ID|Object.use_time_offset_parent -> use_time_offset_parent:   boolean  "Apply the time offset to this objects parent relationship"
-#ID|Object.use_time_offset_particle -> use_time_offset_particle:   boolean  "Let the time offset work on the particle effect"
-#+ * ID|Object.vertex_groups -> vertex_groups:   collection,  "(read-only)    Vertex groups of the object"
-#+ * ID|ParticleSettings.active_dupliweight -> active_dupliweight:   pointer,  "(read-only)"
-#+ * ID|ParticleSettings.active_dupliweight_index -> active_dupliweight_index:   int  "NO DESCRIPTION"
-#+ * ID|ParticleSettings.adaptive_angle -> adaptive_angle:   int  "How many degrees path has to curve to make another render segment"
-#ID|ParticleSettings.adaptive_pixel -> adaptive_pixel:   int  "How many pixels path has to cover to make another render segment"
-#+ * ID|ParticleSettings.angular_velocity_factor -> angular_velocity_factor:   float  "Angular velocity amount"
-#+ * ID|ParticleSettings.angular_velocity_mode -> angular_velocity_mode:   enum  "Particle angular velocity mode"
-#+ * ID|ParticleSettings.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#ID|ParticleSettings.apply_effector_to_children -> apply_effector_to_children:   boolean  "Apply effectors to children"
-#ID|ParticleSettings.apply_guide_to_children -> apply_guide_to_children:   boolean  "NO DESCRIPTION"
-#+ * ID|ParticleSettings.billboard_align -> billboard_align:   enum  "In respect to what the billboards are aligned"
-#+ * ID|ParticleSettings.billboard_animation -> billboard_animation:   enum  "How to animate billboard textures"
-#+ * ID|ParticleSettings.billboard_object -> billboard_object:   pointer  "Billboards face this object (default is active camera)"
-#+ * ID|ParticleSettings.billboard_offset -> billboard_offset:   float[2]  "NO DESCRIPTION"
-#ID|ParticleSettings.billboard_offset_split -> billboard_offset_split:   enum  "How to offset billboard textures"
-#+ * ID|ParticleSettings.billboard_tilt -> billboard_tilt:   float  "Tilt of the billboards"
-#ID|ParticleSettings.billboard_tilt_random -> billboard_tilt_random:   float  "Random tilt of the billboards"
-#+ * ID|ParticleSettings.billboard_uv_split -> billboard_uv_split:   int  "Amount of rows/columns to split UV coordinates for billboards"
-#+ * ID|ParticleSettings.boids -> boids:   pointer,  "(read-only)"
-#+ * ID|ParticleSettings.branch_threshold -> branch_threshold:   float  "Threshold of branching"
-#+ * ID|ParticleSettings.brownian_factor -> brownian_factor:   float  "Specify the amount of Brownian motion"
-#+ * ID|ParticleSettings.child_length -> child_length:   float  "Length of child paths"
-#ID|ParticleSettings.child_length_threshold -> child_length_threshold:   float  "Amount of particles left untouched by child path length"
-#+ * ID|ParticleSettings.child_nbr -> child_nbr:   int  "Amount of children/parent"
-#+ * ID|ParticleSettings.child_radius -> child_radius:   float  "Radius of children around parent"
-#+ * ID|ParticleSettings.child_roundness -> child_roundness:   float  "Roundness of children around parent"
-#+ * ID|ParticleSettings.child_size -> child_size:   float  "A multiplier for the child particle size"
-#ID|ParticleSettings.child_size_random -> child_size_random:   float  "Random variation to the size of the child particles"
-#+ * ID|ParticleSettings.child_type -> child_type:   enum  "Create child particles"
-#+ * ID|ParticleSettings.clump_factor -> clump_factor:   float  "Amount of clumping"
-#ID|ParticleSettings.clump_shape -> clump_shape:   float  "Shape of clumping"
-#ID|ParticleSettings.count -> count:   int  "Total number of particles"
-#ID|ParticleSettings.damping -> damping:   float  "Specify the amount of damping"
-#+ * ID|ParticleSettings.distribution -> distribution:   enum  "How to distribute particles on selected element"
-#+ * ID|ParticleSettings.drag_factor -> drag_factor:   float  "Specify the amount of air-drag"
-#ID|ParticleSettings.draw_method -> draw_method:   enum  "How particles are drawn in viewport"
-#ID|ParticleSettings.draw_percentage -> draw_percentage:   int  "Percentage of particles to display in 3D view"
-#+ * ID|ParticleSettings.draw_size -> draw_size:   int  "Size of particles on viewport in pixels (0=default)"
-#+ * ID|ParticleSettings.draw_step -> draw_step:   int  "How many steps paths are drawn with (power of 2)"
-#+ * ID|ParticleSettings.dupli_group -> dupli_group:   pointer  "Show Objects in this Group in place of particles"
-#+ * ID|ParticleSettings.dupli_object -> dupli_object:   pointer  "Show this Object in place of particles"
-#ID|ParticleSettings.dupli_weights -> dupli_weights:   collection,  "(read-only)    Weights for all of the objects in the dupli group"
-#+ * ID|ParticleSettings.effect_hair -> effect_hair:   float  "Hair stiffness for effectors"
-#+ * ID|ParticleSettings.effector_weights -> effector_weights:   pointer,  "(read-only)"
-#+ * ID|ParticleSettings.emit_from -> emit_from:   enum  "Where to emit particles from"
-#ID|ParticleSettings.factor_random -> factor_random:   float  "Give the starting speed a random variation"
-#+ * ID|ParticleSettings.fluid -> fluid:   pointer,  "(read-only)"
-#+ * ID|ParticleSettings.force_field_1 -> force_field_1:   pointer,  "(read-only)"
-#+ * ID|ParticleSettings.force_field_2 -> force_field_2:   pointer,  "(read-only)"
-#+ * ID|ParticleSettings.frame_end -> frame_end:   float  "Frame # to stop emitting particles"
-#+ * ID|ParticleSettings.frame_start -> frame_start:   float  "Frame # to start emitting particles"
-#+ * ID|ParticleSettings.grid_resolution -> grid_resolution:   int  "The resolution of the particle grid"
-#+ * ID|ParticleSettings.hair_step -> hair_step:   int  "Number of hair segments"
-#+ * ID|ParticleSettings.integrator -> integrator:   enum  "Select physics integrator type"
-#ID|ParticleSettings.invert_grid -> invert_grid:   boolean  "Invert what is considered object and what is not"
-#+ * ID|ParticleSettings.jitter_factor -> jitter_factor:   float  "Amount of jitter applied to the sampling"
-#+ * ID|ParticleSettings.keyed_loops -> keyed_loops:   int  "Number of times the keys are looped"
-#+ * ID|ParticleSettings.keys_step -> keys_step:   int  "NO DESCRIPTION"
-#+ * ID|ParticleSettings.kink -> kink:   enum  "Type of periodic offset on the path"
-#+ * ID|ParticleSettings.kink_amplitude -> kink_amplitude:   float  "The amplitude of the offset"
-#+ * ID|ParticleSettings.kink_axis -> kink_axis:   enum  "Which axis to use for offset"
-#+ * ID|ParticleSettings.kink_frequency -> kink_frequency:   float  "The frequency of the offset (1/total length)"
-#+ * ID|ParticleSettings.kink_shape -> kink_shape:   float  "Adjust the offset to the beginning/end"
-#ID|ParticleSettings.length_random -> length_random:   float  "Give path length a random variation"
-#+ * ID|ParticleSettings.lifetime -> lifetime:   float  "Specify the life span of the particles"
-#ID|ParticleSettings.lifetime_random -> lifetime_random:   float  "Give the particle life a random variation"
-#+ * ID|ParticleSettings.line_length_head -> line_length_head:   float  "Length of the lines head"
-#+ * ID|ParticleSettings.line_length_tail -> line_length_tail:   float  "Length of the lines tail"
-#ID|ParticleSettings.lock_billboard -> lock_billboard:   boolean  "Lock the billboards align axis"
-#ID|ParticleSettings.lock_boids_to_surface -> lock_boids_to_surface:   boolean  "Constrain boids to a surface"
-#+ * ID|ParticleSettings.mass -> mass:   float  "Specify the mass of the particles"
-#+ * ID|ParticleSettings.material -> material:   int  "Specify material used for the particles"
-#+ * ID|ParticleSettings.normal_factor -> normal_factor:   float  "Let the surface normal give the particle a starting speed"
-#ID|ParticleSettings.object_align_factor -> object_align_factor:   float[3]  "Let the emitter object orientation give the particle a starting speed"
-#+ * ID|ParticleSettings.object_factor -> object_factor:   float  "Let the object give the particle a starting speed"
-#+ * ID|ParticleSettings.particle_factor -> particle_factor:   float  "Let the target particle give the particle a starting speed"
-#+ * ID|ParticleSettings.particle_size -> particle_size:   float  "The size of the particles"
-#+ * ID|ParticleSettings.path_end -> path_end:   float  "End time of drawn path"
-#+ * ID|ParticleSettings.path_start -> path_start:   float  "Starting time of drawn path"
-#+ * ID|ParticleSettings.phase_factor -> phase_factor:   float  "Initial rotation phase"
-#ID|ParticleSettings.phase_factor_random -> phase_factor_random:   float  "Randomize rotation phase"
-#+ * ID|ParticleSettings.physics_type -> physics_type:   enum  "Particle physics type"
-#+ * ID|ParticleSettings.react_event -> react_event:   enum  "The event of target particles to react on"
-#+ * ID|ParticleSettings.reaction_shape -> reaction_shape:   float  "Power of reaction strength dependence on distance to target"
-#+ * ID|ParticleSettings.reactor_factor -> reactor_factor:   float  "Let the vector away from the target particles location give the particle a starting speed"
-#+ * ID|ParticleSettings.render_step -> render_step:   int  "How many steps paths are rendered with (power of 2)"
-#ID|ParticleSettings.render_type -> render_type:   enum  "How particles are rendered"
-#ID|ParticleSettings.rendered_child_count -> rendered_child_count:   int  "Amount of children/parent for rendering"
-#ID|ParticleSettings.rotation_factor_random -> rotation_factor_random:   float  "Randomize rotation"
-#+ * ID|ParticleSettings.rotation_mode -> rotation_mode:   enum  "Particles initial rotation"
-#ID|ParticleSettings.roughness_1 -> roughness_1:   float  "Amount of location dependent rough"
-#ID|ParticleSettings.roughness_1_size -> roughness_1_size:   float  "Size of location dependent rough"
-#ID|ParticleSettings.roughness_2 -> roughness_2:   float  "Amount of random rough"
-#ID|ParticleSettings.roughness_2_size -> roughness_2_size:   float  "Size of random rough"
-#ID|ParticleSettings.roughness_2_threshold -> roughness_2_threshold:   float  "Amount of particles left untouched by random rough"
-#ID|ParticleSettings.roughness_end_shape -> roughness_end_shape:   float  "Shape of end point rough"
-#ID|ParticleSettings.roughness_endpoint -> roughness_endpoint:   float  "Amount of end point rough"
-#ID|ParticleSettings.show_health -> show_health:   boolean  "Draw boid health"
-#ID|ParticleSettings.show_material_color -> show_material_color:   boolean  "Draw particles using materials diffuse color"
-#ID|ParticleSettings.show_number -> show_number:   boolean  "Show particle number"
-#+ * ID|ParticleSettings.show_size -> show_size:   boolean  "Show particle size"
-#ID|ParticleSettings.show_unborn -> show_unborn:   boolean  "Show particles before they are emitted"
-#ID|ParticleSettings.show_velocity -> show_velocity:   boolean  "Show particle velocity"
-#+ * ID|ParticleSettings.simplify_rate -> simplify_rate:   float  "Speed of simplification"
-#+ * ID|ParticleSettings.simplify_refsize -> simplify_refsize:   int  "Reference size in pixels, after which simplification begins"
-#+ * ID|ParticleSettings.simplify_transition -> simplify_transition:   float  "Transition period for fading out strands"
-#+ * ID|ParticleSettings.simplify_viewport -> simplify_viewport:   float  "Speed of Simplification"
-#ID|ParticleSettings.size_random -> size_random:   float  "Give the particle size a random variation"
-#+ * ID|ParticleSettings.subframes -> subframes:   int  "Subframes to simulate for improved stability and finer granularity simulations"
-#+ * ID|ParticleSettings.tangent_factor -> tangent_factor:   float  "Let the surface tangent give the particle a starting speed"
-#+ * ID|ParticleSettings.tangent_phase -> tangent_phase:   float  "Rotate the surface tangent"
-#+ * ID|ParticleSettings.time_tweak -> time_tweak:   float  "A multiplier for physics timestep (1.0 means one frame = 1/25 seconds)"
-#+ * ID|ParticleSettings.trail_count -> trail_count:   int  "Number of trail particles"
-#+ * ID|ParticleSettings.type -> type:   enum  "NO DESCRIPTION"
-#ID|ParticleSettings.use_absolute_path_time -> use_absolute_path_time:   boolean  "Path timing is in absolute frames"
-#ID|ParticleSettings.use_animate_branching -> use_animate_branching:   boolean  "Animate branching"
-#ID|ParticleSettings.use_branching -> use_branching:   boolean  "Branch child paths from each other"
-#ID|ParticleSettings.use_dead -> use_dead:   boolean  "Show particles after they have died"
-#ID|ParticleSettings.use_die_on_collision -> use_die_on_collision:   boolean  "Particles die when they collide with a deflector object"
-#ID|ParticleSettings.use_dynamic_rotation -> use_dynamic_rotation:   boolean  "Sets rotation to dynamic/constant"
-#ID|ParticleSettings.use_emit_random -> use_emit_random:   boolean  "Emit in random order of elements"
-#ID|ParticleSettings.use_even_distribution -> use_even_distribution:   boolean  "Use even distribution from faces based on face areas or edge lengths"
-#+ * ID|ParticleSettings.use_global_dupli -> use_global_dupli:   boolean  "Use objects global coordinates for duplication"
-#+ * ID|ParticleSettings.use_group_count -> use_group_count:   boolean  "Use object multiple times in the same group"
-#ID|ParticleSettings.use_group_pick_random -> use_group_pick_random:   boolean  "Pick objects from group randomly"
-#ID|ParticleSettings.use_hair_bspline -> use_hair_bspline:   boolean  "Interpolate hair using B-Splines"
-#ID|ParticleSettings.use_multiply_size_mass -> use_multiply_size_mass:   boolean  "Multiply mass by particle size"
-#ID|ParticleSettings.use_parent_particles -> use_parent_particles:   boolean  "Render parent particles"
-#ID|ParticleSettings.use_react_multiple -> use_react_multiple:   boolean  "React multiple times"
-#ID|ParticleSettings.use_react_start_end -> use_react_start_end:   boolean  "Give birth to unreacted particles eventually"
-#ID|ParticleSettings.use_render_adaptive -> use_render_adaptive:   boolean  "Draw steps of the particle path"
-#ID|ParticleSettings.use_render_emitter -> use_render_emitter:   boolean  "Render emitter Object also"
-#ID|ParticleSettings.use_self_effect -> use_self_effect:   boolean  "Particle effectors effect themselves"
-#ID|ParticleSettings.use_simplify -> use_simplify:   boolean  "Remove child strands as the object becomes smaller on the screen"
-#ID|ParticleSettings.use_simplify_viewport -> use_simplify_viewport:   boolean  "NO DESCRIPTION"
-#ID|ParticleSettings.use_size_deflect -> use_size_deflect:   boolean  "Use particles size in deflection"
-#ID|ParticleSettings.use_strand_primitive -> use_strand_primitive:   boolean  "Use the strand primitive for rendering"
-#ID|ParticleSettings.use_symmetric_branching -> use_symmetric_branching:   boolean  "Start and end points are the same"
-#ID|ParticleSettings.use_velocity_length -> use_velocity_length:   boolean  "Multiply line length by particle speed"
-#ID|ParticleSettings.use_whole_group -> use_whole_group:   boolean  "Use whole group at once"
-#+ * ID|ParticleSettings.userjit -> userjit:   int  "Emission locations / face (0 = automatic)"
-#+ * ID|ParticleSettings.virtual_parents -> virtual_parents:   float  "Relative amount of virtual parents"
-#+ * ID|Scene.active_keying_set_index -> active_keying_set_index:   int  "Current Keying Set index (negative for builtin and positive for absolute)"
-#+ * ID|Scene.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#ID|Scene.audio_distance_model -> audio_distance_model:   enum  "Distance model for distance attenuation calculation"
-#ID|Scene.audio_doppler_factor -> audio_doppler_factor:   float  "Pitch factor for Doppler effect calculation"
-#ID|Scene.audio_doppler_speed -> audio_doppler_speed:   float  "Speed of sound for Doppler effect calculation"
-#ID|Scene.background_set -> background_set:   pointer  "Background set scene"
-#+ * ID|Scene.camera -> camera:   pointer  "Active camera used for rendering the scene"
-#+ * ID|Scene.cursor_location -> cursor_location:   float[3]  "3D cursor location"
-#+ * ID|Scene.frame_current -> frame_current:   int  "NO DESCRIPTION"
-#+ * ID|Scene.frame_end -> frame_end:   int  "Final frame of the playback/rendering range"
-#ID|Scene.frame_preview_end -> frame_preview_end:   int  "Alternative end frame for UI playback"
-#ID|Scene.frame_preview_start -> frame_preview_start:   int  "Alternative start frame for UI playback"
-#+ * ID|Scene.frame_start -> frame_start:   int  "First frame of the playback/rendering range"
-#+ * ID|Scene.frame_step -> frame_step:   int  "Number of frames to skip forward while rendering/playing back each frame"
-#ID|Scene.game_settings -> game_settings:   pointer,  "(read-only)"
-#+ * ID|Scene.gravity -> gravity:   float[3]  "Constant acceleration in a given direction"
-#+ * ID|Scene.grease_pencil -> grease_pencil:   pointer  "Grease Pencil datablock"
-#ID|Scene.is_nla_tweakmode -> is_nla_tweakmode:   boolean,  "(read-only)    Indicates whether there is any action referenced by NLA being edited. Strictly read-only"
-#+ * ID|Scene.keying_sets -> keying_sets:   collection,  "(read-only)    Absolute Keying Sets for this Scene"
-#ID|Scene.keying_sets_all -> keying_sets_all:   collection,  "(read-only)    All Keying Sets available for use (builtins and Absolute Keying Sets for this Scene)"
-#+ * ID|Scene.layers -> layers:   boolean[20]  "Layers visible when rendering the scene"
-#+ * ID|Scene.network_render -> network_render:   pointer,  "(read-only)    Network Render Settings"
-#+ * ID|Scene.nodetree -> nodetree:   pointer,  "(read-only)    Compositing node tree"
-#ID|Scene.object_bases -> object_bases:   collection,  "(read-only)"
-#+ * ID|Scene.objects -> objects:   collection,  "(read-only)"
-#+ * ID|Scene.orientations -> orientations:   collection,  "(read-only)"
-#+ * ID|Scene.pose_templates -> pose_templates:   pointer,  "(read-only)    Pose Template Settings"
-#+ * ID|Scene.render -> render:   pointer,  "(read-only)"
-#+ * ID|Scene.sequence_editor -> sequence_editor:   pointer,  "(read-only)"
-#+ * ID|Scene.sync_mode -> sync_mode:   enum  "How to sync playback"
-#+ * ID|Scene.timeline_markers -> timeline_markers:   collection,  "(read-only)    Markers used in all timelines for the current scene"
-#+ * ID|Scene.tool_settings -> tool_settings:   pointer,  "(read-only)"
-#+ * ID|Scene.unit_settings -> unit_settings:   pointer,  "(read-only)    Unit editing settings"
-#ID|Scene.use_audio -> use_audio:   boolean  "Play back of audio from Sequence Editor will be muted"
-#ID|Scene.use_audio_scrub -> use_audio_scrub:   boolean  "Play audio from Sequence Editor while scrubbing"
-#ID|Scene.use_audio_sync -> use_audio_sync:   boolean  "Play back and sync with audio clock, dropping frames if frame display is too slow"
-#ID|Scene.use_frame_drop -> use_frame_drop:   boolean  "Play back dropping frames if frame display is too slow"
-#+ * ID|Scene.use_gravity -> use_gravity:   boolean  "Use global gravity for all dynamics"
-#+ * ID|Scene.use_nodes -> use_nodes:   boolean  "Enable the compositing node tree"
-#+ * ID|Scene.use_preview_range -> use_preview_range:   boolean  "Use an alternative start/end frame for UI playback, rather than the scene start/end frame"
-#ID|Scene.use_stamp_note -> use_stamp_note:   string  "User define note for the render stamping"
-#+ * ID|Scene.world -> world:   pointer  "World used for rendering the scene"
-#+ * ID|Screen.areas -> areas:   collection,  "(read-only)    Areas the screen is subdivided into"
-#ID|Screen.is_animation_playing -> is_animation_playing:   boolean,  "(read-only)    Animation playback is active"
-#+ * ID|Screen.scene -> scene:   pointer  "Active scene to be edited in the screen"
-#ID|Screen.show_fullscreen -> show_fullscreen:   boolean,  "(read-only)    An area is maximised, filling this screen"
-#+ * ID|Sound.filepath -> filepath:   string  "Sound sample file used by this Sound datablock"
-#+ * ID|Sound.packed_file -> packed_file:   pointer,  "(read-only)"
-#ID|Sound.use_memory_cache -> use_memory_cache:   boolean  "The sound file is decoded and loaded into RAM"
-#+ * ID|Text.current_character -> current_character:   int,  "(read-only)    Index of current character in current line, and also start index of character in selection if one exists"
-#+ * ID|Text.current_line -> current_line:   pointer,  "(read-only)    Current line, and start line of selection if one exists"
-#+ * ID|Text.filepath -> filepath:   string  "Filename of the text file"
-#ID|Text.is_dirty -> is_dirty:   boolean,  "(read-only)    Text file has been edited since last save"
-#ID|Text.is_in_memory -> is_in_memory:   boolean,  "(read-only)    Text file is in memory, without a corresponding file on disk"
-#ID|Text.is_modified -> is_modified:   boolean,  "(read-only)    Text file on disk is different than the one in memory"
-#+ * ID|Text.lines -> lines:   collection,  "(read-only)    Lines of text"
-#+ * ID|Text.markers -> markers:   collection,  "(read-only)    Text markers highlighting part of the text"
-#ID|Text.select_end_character -> select_end_character:   int,  "(read-only)    Index of character after end of selection in the selection end line"
-#ID|Text.select_end_line -> select_end_line:   pointer,  "(read-only)    End line of selection"
-#+ * ID|Text.use_module -> use_module:   boolean  "Register this text as a module on loading, Text name must end with .py"
-#ID|Text.use_tabs_as_spaces -> use_tabs_as_spaces:   boolean  "Automatically converts all new tabs into spaces"
-#+ * ID|Texture.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#+ * ID|Texture.color_ramp -> color_ramp:   pointer,  "(read-only)"
-#+ * ID|Texture.contrast -> contrast:   float  "NO DESCRIPTION"
-#+TODO MAKE COLOR * ID|Texture.factor_blue -> factor_blue:   float  "NO DESCRIPTION"
-#+TODO MAKE COLOR * ID|Texture.factor_green -> factor_green:   float  "NO DESCRIPTION"
-#+TODO MAKE COLOR * ID|Texture.factor_red -> factor_red:   float  "NO DESCRIPTION"
-#ID|Texture.intensity -> intensity:   float  "NO DESCRIPTION"
-#+ * ID|Texture.node_tree -> node_tree:   pointer,  "(read-only)    Node tree for node-based textures"
-#+ * ID|Texture.saturation -> saturation:   float  "NO DESCRIPTION"
-#+ * ID|Texture.type -> type:   enum  "NO DESCRIPTION"
-#+ * ID|Texture.use_color_ramp -> use_color_ramp:   boolean  "Toggle color ramp operations"
-#+ * ID|Texture.use_nodes -> use_nodes:   boolean  "Make this a node-based texture"
-#+ * ID|Texture.use_preview_alpha -> use_preview_alpha:   boolean  "Show Alpha in Preview Render"
-#+ * ID|Texture|BlendTexture.progression -> progression:   enum  "Sets the style of the color blending"
-#ID|Texture|BlendTexture.use_flip_axis -> use_flip_axis:   enum  "Flips the textures X and Y axis"
-#ID|Texture|CloudsTexture.cloud_type -> cloud_type:   enum  "NO DESCRIPTION"
-#+ * ID|Texture|CloudsTexture.nabla -> nabla:   float  "Size of derivative offset used for calculating normal"
-#+ * ID|Texture|CloudsTexture.noise_basis -> noise_basis:   enum  "Sets the noise basis used for turbulence"
-#+ * ID|Texture|CloudsTexture.noise_depth -> noise_depth:   int  "Sets the depth of the cloud calculation"
-#ID|Texture|CloudsTexture.noise_scale -> noise_scale:   float  "Sets scaling for noise input"
-#+ * ID|Texture|CloudsTexture.noise_type -> noise_type:   enum  "NO DESCRIPTION"
-#+ * ID|Texture|DistortedNoiseTexture.distortion -> distortion:   float  "NO DESCRIPTION"
-#+ * ID|Texture|DistortedNoiseTexture.nabla -> nabla:   float  "Size of derivative offset used for calculating normal"
-#+ * ID|Texture|DistortedNoiseTexture.noise_basis -> noise_basis:   enum  "Sets the noise basis used for turbulence"
-#+ * ID|Texture|DistortedNoiseTexture.noise_distortion -> noise_distortion:   enum  "Sets the noise basis for the distortion"
-#ID|Texture|DistortedNoiseTexture.noise_scale -> noise_scale:   float  "Sets scaling for noise input"
-#+ * ID|Texture|EnvironmentMapTexture.environment_map -> environment_map:   pointer,  "(read-only)    Gets the environment map associated with this texture"
-#+ * ID|Texture|EnvironmentMapTexture.filter_eccentricity -> filter_eccentricity:   int  "Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower"
-#+ * ID|Texture|EnvironmentMapTexture.filter_probes -> filter_probes:   int  "Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower"
-#+ * ID|Texture|EnvironmentMapTexture.filter_size -> filter_size:   float  "Multiplies the filter size used by MIP Map and Interpolation"
-#ID|Texture|EnvironmentMapTexture.filter_type -> filter_type:   enum  "Texture filter to use for sampling image"
-#+ * ID|Texture|EnvironmentMapTexture.image -> image:   pointer  "Source image file to read the environment map from"
-#+ * ID|Texture|EnvironmentMapTexture.image_user -> image_user:   pointer,  "(read-only)    Parameters defining which layer, pass and frame of the image is displayed"
-#ID|Texture|EnvironmentMapTexture.use_filter_size_min -> use_filter_size_min:   boolean  "Use Filter Size as a minimal filter value in pixels"
-#ID|Texture|EnvironmentMapTexture.use_mipmap -> use_mipmap:   boolean  "Uses auto-generated MIP maps for the image"
-#ID|Texture|EnvironmentMapTexture.use_mipmap_gauss -> use_mipmap_gauss:   boolean  "Uses Gauss filter to sample down MIP maps"
-#+ * ID|Texture|ImageTexture.checker_distance -> checker_distance:   float  "Sets distance between checker tiles"
-#+ * ID|Texture|ImageTexture.crop_max_x -> crop_max_x:   float  "Sets maximum X value to crop the image"
-#+ * ID|Texture|ImageTexture.crop_max_y -> crop_max_y:   float  "Sets maximum Y value to crop the image"
-#+ * ID|Texture|ImageTexture.crop_min_x -> crop_min_x:   float  "Sets minimum X value to crop the image"
-#+ * ID|Texture|ImageTexture.crop_min_y -> crop_min_y:   float  "Sets minimum Y value to crop the image"
-#+ * ID|Texture|ImageTexture.extension -> extension:   enum  "Sets how the image is extrapolated past its original bounds"
-#+ * ID|Texture|ImageTexture.filter_eccentricity -> filter_eccentricity:   int  "Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower"
-#+ * ID|Texture|ImageTexture.filter_probes -> filter_probes:   int  "Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower"
-#+ * ID|Texture|ImageTexture.filter_size -> filter_size:   float  "Multiplies the filter size used by MIP Map and Interpolation"
-#ID|Texture|ImageTexture.filter_type -> filter_type:   enum  "Texture filter to use for sampling image"
-#+ * ID|Texture|ImageTexture.image -> image:   pointer  "NO DESCRIPTION"
-#+ * ID|Texture|ImageTexture.image_user -> image_user:   pointer,  "(read-only)    Parameters defining which layer, pass and frame of the image is displayed"
-#+ * ID|Texture|ImageTexture.invert_alpha -> invert_alpha:   boolean  "Inverts all the alpha values in the image"
-#+ * ID|Texture|ImageTexture.normal_space -> normal_space:   enum  "Sets space of normal map image"
-#+ * ID|Texture|ImageTexture.repeat_x -> repeat_x:   int  "Sets a repetition multiplier in the X direction"
-#+ * ID|Texture|ImageTexture.repeat_y -> repeat_y:   int  "Sets a repetition multiplier in the Y direction"
-#+ * ID|Texture|ImageTexture.use_alpha -> use_alpha:   boolean  "Uses the alpha channel information in the image"
-#ID|Texture|ImageTexture.use_calculate_alpha -> use_calculate_alpha:   boolean  "Calculates an alpha channel based on RGB values in the image"
-#ID|Texture|ImageTexture.use_checker_even -> use_checker_even:   boolean  "Sets even checker tiles"
-#ID|Texture|ImageTexture.use_checker_odd -> use_checker_odd:   boolean  "Sets odd checker tiles"
-#ID|Texture|ImageTexture.use_filter_size_min -> use_filter_size_min:   boolean  "Use Filter Size as a minimal filter value in pixels"
-#ID|Texture|ImageTexture.use_flip_axis -> use_flip_axis:   boolean  "Flips the textures X and Y axis"
-#ID|Texture|ImageTexture.use_interpolation -> use_interpolation:   boolean  "Interpolates pixels using Area filter"
-#ID|Texture|ImageTexture.use_mipmap -> use_mipmap:   boolean  "Uses auto-generated MIP maps for the image"
-#ID|Texture|ImageTexture.use_mipmap_gauss -> use_mipmap_gauss:   boolean  "Uses Gauss filter to sample down MIP maps"
-#ID|Texture|ImageTexture.use_mirror_x -> use_mirror_x:   boolean  "Mirrors the image repetition on the X direction"
-#ID|Texture|ImageTexture.use_mirror_y -> use_mirror_y:   boolean  "Mirrors the image repetition on the Y direction"
-#ID|Texture|ImageTexture.use_normal_map -> use_normal_map:   boolean  "Uses image RGB values for normal mapping"
-#+ * ID|Texture|MagicTexture.noise_depth -> noise_depth:   int  "Sets the depth of the cloud calculation"
-#+ * ID|Texture|MagicTexture.turbulence -> turbulence:   float  "Sets the turbulence of the bandnoise and ringnoise types"
-#ID|Texture|MarbleTexture.marble_type -> marble_type:   enum  "NO DESCRIPTION"
-#+ * ID|Texture|MarbleTexture.nabla -> nabla:   float  "Size of derivative offset used for calculating normal"
-#+ * ID|Texture|MarbleTexture.noise_basis -> noise_basis:   enum  "Sets the noise basis used for turbulence"
-#+ * ID|Texture|MarbleTexture.noise_depth -> noise_depth:   int  "Sets the depth of the cloud calculation"
-#ID|Texture|MarbleTexture.noise_scale -> noise_scale:   float  "Sets scaling for noise input"
-#+ * ID|Texture|MarbleTexture.noise_type -> noise_type:   enum  "NO DESCRIPTION"
-#ID|Texture|MarbleTexture.noisebasis_2 -> noisebasis_2:   enum  "NO DESCRIPTION"
-#+ * ID|Texture|MarbleTexture.turbulence -> turbulence:   float  "Sets the turbulence of the bandnoise and ringnoise types"
-#ID|Texture|MusgraveTexture.dimension_max -> dimension_max:   float  "Highest fractal dimension"
-#+ * ID|Texture|MusgraveTexture.gain -> gain:   float  "The gain multiplier"
-#+ * ID|Texture|MusgraveTexture.lacunarity -> lacunarity:   float  "Gap between successive frequencies"
-#+ * ID|Texture|MusgraveTexture.musgrave_type -> musgrave_type:   enum  "NO DESCRIPTION"
-#+ * ID|Texture|MusgraveTexture.nabla -> nabla:   float  "Size of derivative offset used for calculating normal"
-#+ * ID|Texture|MusgraveTexture.noise_basis -> noise_basis:   enum  "Sets the noise basis used for turbulence"
-#+ * ID|Texture|MusgraveTexture.noise_intensity -> noise_intensity:   float  "NO DESCRIPTION"
-#ID|Texture|MusgraveTexture.noise_scale -> noise_scale:   float  "Sets scaling for noise input"
-#+ * ID|Texture|MusgraveTexture.octaves -> octaves:   float  "Number of frequencies used"
-#+ * ID|Texture|MusgraveTexture.offset -> offset:   float  "The fractal offset"
-#ID|Texture|PointDensityTexture.point_density -> point_density:   pointer,  "(read-only)    The point density settings associated with this texture"
-#+ * ID|Texture|StucciTexture.noise_basis -> noise_basis:   enum  "Sets the noise basis used for turbulence"
-#ID|Texture|StucciTexture.noise_scale -> noise_scale:   float  "Sets scaling for noise input"
-#+ * ID|Texture|StucciTexture.noise_type -> noise_type:   enum  "NO DESCRIPTION"
-#ID|Texture|StucciTexture.stucci_type -> stucci_type:   enum  "NO DESCRIPTION"
-#+ * ID|Texture|StucciTexture.turbulence -> turbulence:   float  "Sets the turbulence of the bandnoise and ringnoise types"
-#ID|Texture|VoronoiTexture.color_mode -> color_mode:   enum  "NO DESCRIPTION"
-#+ * ID|Texture|VoronoiTexture.distance_metric -> distance_metric:   enum  "NO DESCRIPTION"
-#+ * ID|Texture|VoronoiTexture.minkovsky_exponent -> minkovsky_exponent:   float  "Minkovsky exponent"
-#+ * ID|Texture|VoronoiTexture.nabla -> nabla:   float  "Size of derivative offset used for calculating normal"
-#+ * ID|Texture|VoronoiTexture.noise_intensity -> noise_intensity:   float  "NO DESCRIPTION"
-#ID|Texture|VoronoiTexture.noise_scale -> noise_scale:   float  "Sets scaling for noise input"
-#+ * ID|Texture|VoronoiTexture.weight_1 -> weight_1:   float  "Voronoi feature weight 1"
-#+ * ID|Texture|VoronoiTexture.weight_2 -> weight_2:   float  "Voronoi feature weight 2"
-#+ * ID|Texture|VoronoiTexture.weight_3 -> weight_3:   float  "Voronoi feature weight 3"
-#+ * ID|Texture|VoronoiTexture.weight_4 -> weight_4:   float  "Voronoi feature weight 4"
-#+ * ID|Texture|VoxelDataTexture.image -> image:   pointer  "NO DESCRIPTION"
-#+ * ID|Texture|VoxelDataTexture.image_user -> image_user:   pointer,  "(read-only)    Parameters defining which layer, pass and frame of the image is displayed"
-#ID|Texture|VoxelDataTexture.voxel_data -> voxel_data:   pointer,  "(read-only)    The voxel data associated with this texture"
-#+ * ID|Texture|WoodTexture.nabla -> nabla:   float  "Size of derivative offset used for calculating normal"
-#+ * ID|Texture|WoodTexture.noise_basis -> noise_basis:   enum  "Sets the noise basis used for turbulence"
-#ID|Texture|WoodTexture.noise_scale -> noise_scale:   float  "Sets scaling for noise input"
-#+ * ID|Texture|WoodTexture.noise_type -> noise_type:   enum  "NO DESCRIPTION"
-#ID|Texture|WoodTexture.noisebasis_2 -> noisebasis_2:   enum  "NO DESCRIPTION"
-#+ * ID|Texture|WoodTexture.turbulence -> turbulence:   float  "Sets the turbulence of the bandnoise and ringnoise types"
-#ID|Texture|WoodTexture.wood_type -> wood_type:   enum  "NO DESCRIPTION"
-#+ * ID|VectorFont.filepath -> filepath:   string,  "(read-only)"
-#+ * ID|VectorFont.packed_file -> packed_file:   pointer,  "(read-only)"
-#+ * ID|WindowManager.keyconfigs -> keyconfigs:   collection,  "(read-only)    Registered key configurations"
-#+ * ID|WindowManager.operators -> operators:   collection,  "(read-only)    Operator registry"
-#+ * ID|WindowManager.windows -> windows:   collection,  "(read-only)    Open windows"
-#+ * ID|World.active_texture -> active_texture:   pointer  "Active texture slot being displayed"
-#+ * ID|World.active_texture_index -> active_texture_index:   int  "Index of active texture slot"
-#+ * ID|World.ambient_color -> ambient_color:   float[3]  "NO DESCRIPTION"
-#+ * ID|World.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
-#ID|World.color_range -> color_range:   float  "The color range that will be mapped to 0-1"
-#+ * ID|World.exposure -> exposure:   float  "Amount of exponential color correction for light"
-#+ * ID|World.horizon_color -> horizon_color:   float[3]  "Color at the horizon"
-#ID|World.light_settings -> light_settings:   pointer,  "(read-only)    World lighting settings"
-#ID|World.mist_settings -> mist_settings:   pointer,  "(read-only)    World mist settings"
-#ID|World.star_settings -> star_settings:   pointer,  "(read-only)    World stars settings"
-#+ * ID|World.texture_slots -> texture_slots:   collection,  "(read-only)    Texture slots defining the mapping and influence of textures"
-#ID|World.use_sky_blend -> use_sky_blend:   boolean  "Render background with natural progression from horizon to zenith"
-#ID|World.use_sky_paper -> use_sky_paper:   boolean  "Flatten blend or texture coordinates"
-#ID|World.use_sky_real -> use_sky_real:   boolean  "Render background with a real horizon, relative to the camera angle"
-#+ * ID|World.zenith_color -> zenith_color:   float[3]  "Color at the zenith"
-#+ * IKParam.ik_solver -> ik_solver:   enum,  "(read-only)    IK solver for which these parameters are defined, 0 for Legacy, 1 for iTaSC"
-#IKParam|Itasc.damping_epsilon -> damping_epsilon:   float  "Singular value under which damping is progressively applied. Higher values=more stability, less reactivity. Default=0.1"
-#IKParam|Itasc.damping_max -> damping_max:   float  "Maximum damping coefficient when singular value is nearly 0. Higher values=more stability, less reactivity. Default=0.5"
-#+ * IKParam|Itasc.feedback -> feedback:   float  "Feedback coefficient for error correction. Average response time=1/feedback. Default=20"
-#IKParam|Itasc.iterations -> iterations:   int  "Maximum number of iterations for convergence in case of reiteration"
-#+ * IKParam|Itasc.mode -> mode:   enum  "NO DESCRIPTION"
-#+ * IKParam|Itasc.precision -> precision:   float  "Precision of convergence in case of reiteration"
-#IKParam|Itasc.reiteration_method -> reiteration_method:   enum  "Defines if the solver is allowed to reiterate (converges until precision is met) on none, first or all frames"
-#+ * IKParam|Itasc.solver -> solver:   enum  "Solving method selection: Automatic damping or manual damping"
-#IKParam|Itasc.step_count -> step_count:   int  "Divides the frame interval into this many steps"
-#IKParam|Itasc.step_max -> step_max:   float  "Higher bound for timestep in second in case of automatic substeps"
-#IKParam|Itasc.step_min -> step_min:   float  "Lower bound for timestep in second in case of automatic substeps"
-#IKParam|Itasc.use_auto_step -> use_auto_step:   boolean  "Automatically determine the optimal number of steps for best performance/accuracy trade off"
-#IKParam|Itasc.velocity_max -> velocity_max:   float  "Maximum joint velocity in rad/s. Default=50"
-#+ * ImageUser.fields_per_frame -> fields_per_frame:   int  "The number of fields per rendered frame (2 fields is 1 image)"
-#ImageUser.frame_duration -> frame_duration:   int  "Sets the number of images of a movie to use"
-#ImageUser.frame_offset -> frame_offset:   int  "Offsets the number of the frame to use in the animation"
-#+ * ImageUser.frame_start -> frame_start:   int  "Sets the global starting frame of the movie"
-#+ * ImageUser.multilayer_layer -> multilayer_layer:   int,  "(read-only)    Layer in multilayer image"
-#+ * ImageUser.multilayer_pass -> multilayer_pass:   int,  "(read-only)    Pass in multilayer image"
-#ImageUser.use_auto_refresh -> use_auto_refresh:   boolean  "Always refresh image on frame changes"
-#ImageUser.use_cyclic -> use_cyclic:   boolean  "Cycle the images in the movie"
-#KeyConfig.is_user_defined -> is_user_defined:   boolean,  "(read-only)    Indicates that a keyconfig was defined by the user"
-#+ * KeyConfig.keymaps -> keymaps:   collection,  "(read-only)    Key maps configured as part of this configuration"
-#+ * KeyConfig.name -> name:   string  "Name of the key configuration"
-#KeyConfigurations.active -> active:   pointer  "Active wm KeyConfig"
-#KeyConfigurations.default -> default:   pointer,  "(read-only)"
-#KeyMap.is_modal -> is_modal:   boolean,  "(read-only)    Indicates that a keymap is used for translate modal events for an operator"
-#KeyMap.is_user_defined -> is_user_defined:   boolean  "Keymap is defined by the user"
-#+ * KeyMap.items -> items:   collection,  "(read-only)    Items in the keymap, linking an operator to an input event"
-#+ * KeyMap.name -> name:   string,  "(read-only)    Name of the key map"
-#+ * KeyMap.region_type -> region_type:   enum,  "(read-only)    Optional region type keymap is associated with"
-#KeyMap.show_expanded_children -> show_expanded_children:   boolean  "Children expanded in the user interface"
-#KeyMap.show_expanded_items -> show_expanded_items:   boolean  "Expanded in the user interface"
-#+ * KeyMap.space_type -> space_type:   enum,  "(read-only)    Optional space type keymap is associated with"
-#TODO MOVE TO COLLECTION * KeyMapItem.active -> active:   boolean  "Activate or deactivate item"
-#+ * KeyMapItem.id -> id:   int,  "(read-only)    ID of the item"
-#+ * KeyMapItem.idname -> idname:   string  "Identifier of operator to call on input event"
-#+ * KeyMapItem.key_modifier -> key_modifier:   enum  "Regular key pressed as a modifier"
-#+ * KeyMapItem.map_type -> map_type:   enum  "Type of event mapping"
-#+ * KeyMapItem.name -> name:   string,  "(read-only)    Name of operator to call on input event"
- + * KeyMapItem.alt -> pressed_alt:   boolean  "Alt key pressed"
- + * KeyMapItem.any -> pressed_any:   boolean  "Any modifier keys pressed"
- + * KeyMapItem.ctrl -> pressed_ctrl:   boolean  "Control key pressed"
- + * KeyMapItem.oskey -> pressed_oskey:   boolean  "Operating system key pressed"
- + * KeyMapItem.shift -> pressed_shift:   boolean  "Shift key pressed"
-#+ * KeyMapItem.properties -> properties:   pointer,  "(read-only)    Properties to set when the operator is called"
-#TODO * KeyMapItem.propvalue -> propvalue:   enum  "The value this event translates to in a modal keymap"
-#KeyMapItem.show_expanded -> show_expanded:   boolean  "Show key map event and property details in the user interface"
-#+ * KeyMapItem.type -> type:   enum  "Type of event"
-#+ * KeyMapItem.value -> value:   enum  "NO DESCRIPTION"
-#+ * Keyframe.co -> co:   float[2]  "Coordinates of the control point"
-#Keyframe.handle_left -> handle_left:   float[2]  "Coordinates of the first handle"
-#Keyframe.handle_left_type -> handle_left_type:   enum  "Handle types"
-#Keyframe.handle_right -> handle_right:   float[2]  "Coordinates of the second handle"
-#Keyframe.handle_right_type -> handle_right_type:   enum  "Handle types"
-#+ * Keyframe.interpolation -> interpolation:   enum  "Interpolation method to use for segment of the curve from this Keyframe until the next Keyframe"
-#+ * Keyframe.select_control_point -> select_control_point:   boolean  "Control point selection status"
-#+ * Keyframe.select_left_handle -> select_left_handle:   boolean  "Handle 1 selection status"
-#+ * Keyframe.select_right_handle -> select_right_handle:   boolean  "Handle 2 selection status"
-#+ * Keyframe.type -> type:   enum  "The type of keyframe"
-#+ * KeyingSet.active_path_index -> active_path_index:   int  "Current Keying Set index"
-#KeyingSet.is_path_absolute -> is_path_absolute:   boolean,  "(read-only)    Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)"
-#+ * KeyingSet.name -> name:   string  "NO DESCRIPTION"
-#+ * KeyingSet.paths -> paths:   collection,  "(read-only)    Keying Set Paths to define settings that get keyframed together"
-#+ * KeyingSet.type_info -> type_info:   pointer,  "(read-only)    Callback function defines for built-in Keying Sets"
-#KeyingSet.use_insertkey_needed -> use_insertkey_needed:   boolean  "Only insert keyframes where theyre needed in the relevant F-Curves"
-#KeyingSet.use_insertkey_visual -> use_insertkey_visual:   boolean  "Insert keyframes based on visual transforms"
-#KeyingSet.use_insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:   boolean  "Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis"
-#+ * KeyingSetInfo.bl_idname -> bl_idname:   string  "NO DESCRIPTION"
-#+ * KeyingSetInfo.bl_label -> bl_label:   string  "NO DESCRIPTION"
-#KeyingSetInfo.use_insertkey_needed -> use_insertkey_needed:   boolean  "Only insert keyframes where theyre needed in the relevant F-Curves"
-#KeyingSetInfo.use_insertkey_visual -> use_insertkey_visual:   boolean  "Insert keyframes based on visual transforms"
-#KeyingSetInfo.use_insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:   boolean  "Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis"
-#+ * KeyingSetPath.array_index -> array_index:   int  "Index to the specific setting if applicable"
-#+ * KeyingSetPath.data_path -> data_path:   string  "Path to property setting"
-#+ * KeyingSetPath.group -> group:   string  "Name of Action Group to assign setting(s) for this path to"
-#KeyingSetPath.group_method -> group_method:   enum  "Method used to define which Group-name to use"
-#+ * KeyingSetPath.id -> id:   pointer  "ID-Block that keyframes for Keying Set should be added to (for Absolute Keying Sets only)"
-#+ * KeyingSetPath.id_type -> id_type:   enum  "Type of ID-block that can be used"
-#KeyingSetPath.use_entire_array -> use_entire_array:   boolean  "When an array/vector type is chosen (Location, Rotation, Color, etc.), entire array is to be used"
-#KeyingSetPath.use_insertkey_needed -> use_insertkey_needed:   boolean  "Only insert keyframes where theyre needed in the relevant F-Curves"
-#KeyingSetPath.use_insertkey_visual -> use_insertkey_visual:   boolean  "Insert keyframes based on visual transforms"
-#KeyingSetPath.use_insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:   boolean  "Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis"
-#KeyingSetPaths.active -> active:   pointer  "Active Keying Set used to insert/delete keyframes"
-#KeyingSets.active -> active:   pointer  "Active Keying Set used to insert/delete keyframes"
-#+ * LampSkySettings.atmosphere_distance_factor -> atmosphere_distance_factor:   float  "Multiplier to convert blender units to physical distance"
-#+ * LampSkySettings.atmosphere_extinction -> atmosphere_extinction:   float  "Extinction scattering contribution factor"
-#+ * LampSkySettings.atmosphere_inscattering -> atmosphere_inscattering:   float  "Scatter contribution factor"
-#+ * LampSkySettings.atmosphere_turbidity -> atmosphere_turbidity:   float  "Sky turbidity"
-#+ * LampSkySettings.backscattered_light -> backscattered_light:   float  "Backscattered light"
-#+ * LampSkySettings.horizon_brightness -> horizon_brightness:   float  "Horizon brightness"
-#+ * LampSkySettings.sky_blend -> sky_blend:   float  "Blend factor with sky"
-#+ * LampSkySettings.sky_blend_type -> sky_blend_type:   enum  "Blend mode for combining sun sky with world sky"
-#+ * LampSkySettings.sky_color_space -> sky_color_space:   enum  "Color space to use for internal XYZ->RGB color conversion"
-#+ * LampSkySettings.sky_exposure -> sky_exposure:   float  "Strength of sky shading exponential exposure correction"
-#+ * LampSkySettings.spread -> spread:   float  "Horizon Spread"
-#+ * LampSkySettings.sun_brightness -> sun_brightness:   float  "Sun brightness"
-#+ * LampSkySettings.sun_intensity -> sun_intensity:   float  "Sun intensity"
-#+ * LampSkySettings.sun_size -> sun_size:   float  "Sun size"
-#+ * LampSkySettings.use_atmosphere -> use_atmosphere:   boolean  "Apply sun effect on atmosphere"
-#+ * LampSkySettings.use_sky -> use_sky:   boolean  "Apply sun effect on sky"
-#+ * LatticePoint.co -> co:   float[3],  "(read-only)"
-#LatticePoint.co_deform -> co_deform:   float[3]  "NO DESCRIPTION"
-#+ * LatticePoint.groups -> groups:   collection,  "(read-only)    Weights for the vertex groups this point is member of"
-#+ * Macro.bl_description -> bl_description:   string  "NO DESCRIPTION"
-#+ * Macro.bl_idname -> bl_idname:   string  "NO DESCRIPTION"
-#+ * Macro.bl_label -> bl_label:   string  "NO DESCRIPTION"
-#+ * Macro.bl_options -> bl_options:   enum  "Options for this operator type"
-#+ * Macro.name -> name:   string,  "(read-only)"
-#+ * Macro.properties -> properties:   pointer,  "(read-only)"
-#+ * Main.actions -> actions:   collection,  "(read-only)    Action datablocks."
-#+ * Main.armatures -> armatures:   collection,  "(read-only)    Armature datablocks."
-#+ * Main.brushes -> brushes:   collection,  "(read-only)    Brush datablocks."
-#+ * Main.cameras -> cameras:   collection,  "(read-only)    Camera datablocks."
-#+ * Main.curves -> curves:   collection,  "(read-only)    Curve datablocks."
-#+ * Main.filepath -> filepath:   string,  "(read-only)    Path to the .blend file"
-#+ * Main.fonts -> fonts:   collection,  "(read-only)    Vector font datablocks."
-#Main.grease_pencil -> grease_pencil:   collection,  "(read-only)    Grease Pencil datablocks."
-#+ * Main.groups -> groups:   collection,  "(read-only)    Group datablocks."
-#+ * Main.images -> images:   collection,  "(read-only)    Image datablocks."
-#Main.is_dirty -> is_dirty:   boolean,  "(read-only)    Has the current session been saved to disk as a .blend file"
-#+ * Main.lamps -> lamps:   collection,  "(read-only)    Lamp datablocks."
-#+ * Main.lattices -> lattices:   collection,  "(read-only)    Lattice datablocks."
-#+ * Main.libraries -> libraries:   collection,  "(read-only)    Library datablocks."
-#+ * Main.materials -> materials:   collection,  "(read-only)    Material datablocks."
-#+ * Main.meshes -> meshes:   collection,  "(read-only)    Mesh datablocks."
-#+ * Main.metaballs -> metaballs:   collection,  "(read-only)    Metaball datablocks."
-#+ * Main.node_groups -> node_groups:   collection,  "(read-only)    Node group datablocks."
-#+ * Main.objects -> objects:   collection,  "(read-only)    Object datablocks."
-#+ * Main.particles -> particles:   collection,  "(read-only)    Particle datablocks."
-#+ * Main.scenes -> scenes:   collection,  "(read-only)    Scene datablocks."
-#+ * Main.screens -> screens:   collection,  "(read-only)    Screen datablocks."
-#+ * Main.scripts -> scripts:   collection,  "(read-only)    Script datablocks (DEPRECATED)."
- + * Main.debug -> show_debug:   boolean  "Print debugging information in console"
-#+ * Main.sounds -> sounds:   collection,  "(read-only)    Sound datablocks."
-#+ * Main.texts -> texts:   collection,  "(read-only)    Text datablocks."
-#+ * Main.textures -> textures:   collection,  "(read-only)    Texture datablocks."
-#+ * Main.window_managers -> window_managers:   collection,  "(read-only)    Window manager datablocks."
-#+ * Main.worlds -> worlds:   collection,  "(read-only)    World datablocks."
-#+ * MaterialHalo.add -> add:   float  "Sets the strength of the add effect"
-#+ * MaterialHalo.flare_boost -> flare_boost:   float  "Gives the flare extra strength"
-#+ * MaterialHalo.flare_seed -> flare_seed:   int  "Specifies an offset in the flare seed table"
-#+ * MaterialHalo.flare_size -> flare_size:   float  "Sets the factor by which the flare is larger than the halo"
-#MaterialHalo.flare_subflare_count -> flare_subflare_count:   int  "Sets the number of subflares"
-#MaterialHalo.flare_subflare_size -> flare_subflare_size:   float  "Sets the dimension of the subflares, dots and circles"
-#+ * MaterialHalo.hardness -> hardness:   int  "Sets the hardness of the halo"
-#MaterialHalo.line_count -> line_count:   int  "Sets the number of star shaped lines rendered over the halo"
-#MaterialHalo.ring_count -> ring_count:   int  "Sets the number of rings rendered over the halo"
-#+ * MaterialHalo.seed -> seed:   int  "Randomizes ring dimension and line location"
-#+ * MaterialHalo.size -> size:   float  "Sets the dimension of the halo"
-#MaterialHalo.star_tip_count -> star_tip_count:   int  "Sets the number of points on the star shaped halo"
-#MaterialHalo.use_extreme_alpha -> use_extreme_alpha:   boolean  "Uses extreme alpha"
-#MaterialHalo.use_flare_mode -> use_flare_mode:   boolean  "Renders halo as a lensflare"
-#MaterialHalo.use_lines -> use_lines:   boolean  "Renders star shaped lines over halo"
-#MaterialHalo.use_ring -> use_ring:   boolean  "Renders rings over halo"
-#MaterialHalo.use_shaded -> use_shaded:   boolean  "Lets halo receive light and shadows from external objects"
-#MaterialHalo.use_soft -> use_soft:   boolean  "Softens the edges of halos at intersections with other geometry"
-#MaterialHalo.use_star -> use_star:   boolean  "Renders halo as a star"
-#MaterialHalo.use_texture -> use_texture:   boolean  "Gives halo a texture"
-#MaterialHalo.use_vertex_normal -> use_vertex_normal:   boolean  "Uses the vertex normal to specify the dimension of the halo"
-#MaterialPhysics.damping -> damping:   float  "Damping of the spring force, when inside the physics distance area"
-#+ * MaterialPhysics.distance -> distance:   float  "Distance of the physics area"
-#+ * MaterialPhysics.elasticity -> elasticity:   float  "Elasticity of collisions"
-#+ * MaterialPhysics.force -> force:   float  "Upward spring force, when inside the physics distance area"
-#+ * MaterialPhysics.friction -> friction:   float  "Coulomb friction coefficient, when inside the physics distance area"
-#MaterialPhysics.use_normal_align -> use_normal_align:   boolean  "Align dynamic game objects along the surface normal, when inside the physics distance area"
-#+ * MaterialRaytraceMirror.depth -> depth:   int  "Maximum allowed number of light inter-reflections"
-#+ * MaterialRaytraceMirror.distance -> distance:   float  "Maximum distance of reflected rays. Reflections further than this range fade to sky color or material color"
-#+ * MaterialRaytraceMirror.fade_to -> fade_to:   enum  "The color that rays with no intersection within the Max Distance take. Material color can be best for indoor scenes, sky color for outdoor"
-#+ * MaterialRaytraceMirror.fresnel -> fresnel:   float  "Power of Fresnel for mirror reflection"
-#+ * MaterialRaytraceMirror.fresnel_factor -> fresnel_factor:   float  "Blending factor for Fresnel"
-#+ * MaterialRaytraceMirror.gloss_anisotropic -> gloss_anisotropic:   float  "The shape of the reflection, from 0.0 (circular) to 1.0 (fully stretched along the tangent"
-#+ * MaterialRaytraceMirror.gloss_factor -> gloss_factor:   float  "The shininess of the reflection. Values < 1.0 give diffuse, blurry reflections"
-#+ * MaterialRaytraceMirror.gloss_samples -> gloss_samples:   int  "Number of cone samples averaged for blurry reflections"
-#+ * MaterialRaytraceMirror.gloss_threshold -> gloss_threshold:   float  "Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped"
-#+ * MaterialRaytraceMirror.reflect_factor -> reflect_factor:   float  "Sets the amount mirror reflection for raytrace"
-#+ * MaterialRaytraceMirror.use -> use:   boolean  "Enable raytraced reflections"
-#+ * MaterialRaytraceTransparency.depth -> depth:   int  "Maximum allowed number of light inter-refractions"
-#MaterialRaytraceTransparency.depth_max -> depth_max:   float  "Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled)"
-#+ * MaterialRaytraceTransparency.falloff -> falloff:   float  "Falloff power for transmissivity filter effect (1.0 is linear)"
-#+ * MaterialRaytraceTransparency.filter -> filter:   float  "Amount to blend in the materials diffuse color in raytraced transparency (simulating absorption)"
-#+ * MaterialRaytraceTransparency.fresnel -> fresnel:   float  "Power of Fresnel for transparency (Ray or ZTransp)"
-#+ * MaterialRaytraceTransparency.fresnel_factor -> fresnel_factor:   float  "Blending factor for Fresnel"
-#+ * MaterialRaytraceTransparency.gloss_factor -> gloss_factor:   float  "The clarity of the refraction. Values < 1.0 give diffuse, blurry refractions"
-#+ * MaterialRaytraceTransparency.gloss_samples -> gloss_samples:   int  "Number of cone samples averaged for blurry refractions"
-#+ * MaterialRaytraceTransparency.gloss_threshold -> gloss_threshold:   float  "Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped"
-#+ * MaterialRaytraceTransparency.ior -> ior:   float  "Sets angular index of refraction for raytraced refraction"
-#+ * MaterialSlot.link -> link:   enum  "Link material to object or the objects data"
-#+ * MaterialSlot.material -> material:   pointer  "Material datablock used by this material slot"
-#+ * MaterialSlot.name -> name:   string,  "(read-only)    Material slot name"
-#+ * MaterialStrand.blend_distance -> blend_distance:   float  "Worldspace distance over which to blend in the surface normal"
-#+ * MaterialStrand.root_size -> root_size:   float  "Start size of strands in pixels or Blender units"
-#+ * MaterialStrand.shape -> shape:   float  "Positive values make strands rounder, negative makes strands spiky"
-#MaterialStrand.size_min -> size_min:   float  "Minimum size of strands in pixels"
-#+ * MaterialStrand.tip_size -> tip_size:   float  "End size of strands in pixels or Blender units"
-#MaterialStrand.use_blender_units -> use_blender_units:   boolean  "Use Blender units for widths instead of pixels"
-#MaterialStrand.use_surface_diffuse -> use_surface_diffuse:   boolean  "Make diffuse shading more similar to shading the surface"
-#MaterialStrand.use_tangent_shading -> use_tangent_shading:   boolean  "Uses direction of strands as normal for tangent-shading"
-#+ * MaterialStrand.uv_layer -> uv_layer:   string  "Name of UV layer to override"
-#+ * MaterialStrand.width_fade -> width_fade:   float  "Transparency along the width of the strand"
-#+ * MaterialSubsurfaceScattering.back -> back:   float  "Back scattering weight"
-#+ * MaterialSubsurfaceScattering.color -> color:   float[3]  "Scattering color"
-#+ * MaterialSubsurfaceScattering.color_factor -> color_factor:   float  "Blend factor for SSS colors"
-#MaterialSubsurfaceScattering.error_threshold -> error_threshold:   float  "Error tolerance (low values are slower and higher quality)"
-#+ * MaterialSubsurfaceScattering.front -> front:   float  "Front scattering weight"
-#+ * MaterialSubsurfaceScattering.ior -> ior:   float  "Index of refraction (higher values are denser)"
-#+ * MaterialSubsurfaceScattering.radius -> radius:   float[3]  "Mean red/green/blue scattering path length"
-#+ * MaterialSubsurfaceScattering.scale -> scale:   float  "Object scale factor"
-#+ * MaterialSubsurfaceScattering.texture_factor -> texture_factor:   float  "Texture scatting blend factor"
-#+ * MaterialSubsurfaceScattering.use -> use:   boolean  "Enable diffuse subsurface scatting effects in a material"
-#+ * MaterialVolume.asymmetry -> asymmetry:   float  "Back scattering (-1.0) to Forward scattering (1.0) and the range in between"
-#+ * MaterialVolume.cache_resolution -> cache_resolution:   int  "Resolution of the voxel grid, low resolutions are faster, high resolutions use more memory"
-#+ * MaterialVolume.density -> density:   float  "The base density of the volume"
-#+ * MaterialVolume.density_scale -> density_scale:   float  "Multiplier for the materials density"
-#MaterialVolume.depth_threshold -> depth_threshold:   float  "Stop ray marching early if transmission drops below this luminance - higher values give speedups in dense volumes at the expense of accuracy"
-#+ * MaterialVolume.emission -> emission:   float  "Amount of light that gets emitted by the volume"
-#+ * MaterialVolume.emission_color -> emission_color:   float[3]  "NO DESCRIPTION"
-#MaterialVolume.light_method -> light_method:   enum  "Method of shading, attenuating, and scattering light through the volume"
-#+ * MaterialVolume.ms_diffusion -> ms_diffusion:   float  "Diffusion factor, the strength of the blurring effect"
-#+ * MaterialVolume.ms_intensity -> ms_intensity:   float  "Multiplier for multiple scattered light energy"
-#+ * MaterialVolume.ms_spread -> ms_spread:   float  "Proportional distance over which the light is diffused"
-#+ * MaterialVolume.reflection -> reflection:   float  "Multiplier to make out-scattered light brighter or darker (non-physically correct)"
-#+ * MaterialVolume.reflection_color -> reflection_color:   float[3]  "Colour of light scattered out of the volume (does not affect transmission)"
-#+ * MaterialVolume.scattering -> scattering:   float  "Amount of light that gets scattered out by the volume - the more out-scattering, the shallower the light will penetrate"
-#MaterialVolume.step_method -> step_method:   enum  "Method of calculating the steps through the volume"
-#+ * MaterialVolume.step_size -> step_size:   float  "Distance between subsequent volume depth samples"
-#+ * MaterialVolume.transmission_color -> transmission_color:   float[3]  "Result color of the volume, after other light has been scattered/absorbed"
-#MaterialVolume.use_external_shadows -> use_external_shadows:   boolean  "Receive shadows from sources outside the volume (temporary)"
-#MaterialVolume.use_light_cache -> use_light_cache:   boolean  "Pre-calculate the shading information into a voxel grid, speeds up shading at slightly less accuracy"
-#+ * Menu.bl_idname -> bl_idname:   string  "If this is set, the menu gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is OBJECT_MT_hello, and bl_idname is not set by the script, then bl_idname = OBJECT_MT_hello"
-#+ * Menu.bl_label -> bl_label:   string  "The menu label"
-#+ * Menu.layout -> layout:   pointer,  "(read-only)    Defines the structure of the menu in the UI."
-#+ * MeshColor.color1 -> color1:   float[3]  "NO DESCRIPTION"
-#+ * MeshColor.color2 -> color2:   float[3]  "NO DESCRIPTION"
-#+ * MeshColor.color3 -> color3:   float[3]  "NO DESCRIPTION"
-#+ * MeshColor.color4 -> color4:   float[3]  "NO DESCRIPTION"
-#+ * MeshColorLayer.active -> active:   boolean  "Sets the layer as active for display and editing"
-#+ * MeshColorLayer.active_render -> active_render:   boolean  "Sets the layer as active for rendering"
-#+ * MeshColorLayer.data -> data:   collection,  "(read-only)"
-#+ * MeshColorLayer.name -> name:   string  "NO DESCRIPTION"
-#+ * MeshEdge.bevel_weight -> bevel_weight:   float  "Weight used by the Bevel modifier"
-#+ * MeshEdge.crease -> crease:   float  "Weight used by the Subsurf modifier for creasing"
-#+ * MeshEdge.hide -> hide:   boolean  "NO DESCRIPTION"
-#+ * MeshEdge.index -> index:   int,  "(read-only)    Index number of the vertex"
-#MeshEdge.is_fgon -> is_fgon:   boolean  "Fgon edge"
-#MeshEdge.is_loose -> is_loose:   boolean  "Loose edge"
-#+ * MeshEdge.select -> select:   boolean  "NO DESCRIPTION"
-#MeshEdge.use_edge_sharp -> use_edge_sharp:   boolean  "Sharp edge for the EdgeSplit modifier"
-#MeshEdge.use_seam -> use_seam:   boolean  "Seam edge for UV unwrapping"
-#MeshEdge.vertices -> vertices:   int[2]  "Vertex indices"
-#+ * MeshFace.area -> area:   float,  "(read-only)    read only area of the face"
-#+ * MeshFace.hide -> hide:   boolean  "NO DESCRIPTION"
-#+ * MeshFace.index -> index:   int,  "(read-only)    Index number of the vertex"
-#+ * MeshFace.material_index -> material_index:   int  "NO DESCRIPTION"
-#+ * MeshFace.normal -> normal:   float[3],  "(read-only)    local space unit length normal vector for this face"
-#+ * MeshFace.select -> select:   boolean  "NO DESCRIPTION"
-#MeshFace.use_smooth -> use_smooth:   boolean  "NO DESCRIPTION"
-#MeshFace.vertices -> vertices:   int[4]  "Vertex indices"
-#MeshFace.vertices_raw -> vertices_raw:   int[4]  "Fixed size vertex indices array"
-#+ * MeshFaces.active -> active:   int  "The active face for this mesh"
-#+ * MeshFaces.active_tface -> active_tface:   pointer,  "(read-only)    Active Texture Face"
-#+ * MeshFloatProperty.value -> value:   float  "NO DESCRIPTION"
-#+ * MeshFloatPropertyLayer.data -> data:   collection,  "(read-only)"
-#+ * MeshFloatPropertyLayer.name -> name:   string  "NO DESCRIPTION"
-#+ * MeshIntProperty.value -> value:   int  "NO DESCRIPTION"
-#+ * MeshIntPropertyLayer.data -> data:   collection,  "(read-only)"
-#+ * MeshIntPropertyLayer.name -> name:   string  "NO DESCRIPTION"
-#+ * MeshSticky.co -> co:   float[2]  "Sticky texture coordinate location"
-#+ * MeshStringProperty.value -> value:   string  "NO DESCRIPTION"
-#+ * MeshStringPropertyLayer.data -> data:   collection,  "(read-only)"
-#+ * MeshStringPropertyLayer.name -> name:   string  "NO DESCRIPTION"
-#MeshTextureFace.blend_type -> blend_type:   enum  "Transparency blending mode"
-#MeshTextureFace.hide -> hide:   boolean  "Make face invisible"
-#+ * MeshTextureFace.image -> image:   pointer  "NO DESCRIPTION"
-#MeshTextureFace.pin_uv -> pin_uv:   boolean[4]  "NO DESCRIPTION"
-#+ * MeshTextureFace.select_uv -> select_uv:   boolean[4]  "NO DESCRIPTION"
-#MeshTextureFace.use_alpha_sort -> use_alpha_sort:   boolean  "Enable sorting of faces for correct alpha drawing (slow, use Clip Alpha instead when possible)"
-#MeshTextureFace.use_billboard -> use_billboard:   boolean  "Billboard with Z-axis constraint"
-#MeshTextureFace.use_bitmap_text -> use_bitmap_text:   boolean  "Enable bitmap text on face"
-#MeshTextureFace.use_blend_shared -> use_blend_shared:   boolean  "Blend vertex colors across face when vertices are shared"
-#MeshTextureFace.use_collision -> use_collision:   boolean  "Use face for collision and ray-sensor detection"
-#MeshTextureFace.use_halo -> use_halo:   boolean  "Screen aligned billboard"
-#MeshTextureFace.use_image -> use_image:   boolean  "Render face with texture"
-#MeshTextureFace.use_light -> use_light:   boolean  "Use light for face"
-#MeshTextureFace.use_object_color -> use_object_color:   boolean  "Use ObColor instead of vertex colors"
-#MeshTextureFace.use_shadow_cast -> use_shadow_cast:   boolean  "Face is used for shadow"
-#MeshTextureFace.use_twoside -> use_twoside:   boolean  "Render face two-sided"
-#+ * MeshTextureFace.uv -> uv:   float[8]  "NO DESCRIPTION"
-#+ * MeshTextureFace.uv1 -> uv1:   float[2]  "NO DESCRIPTION"
-#+ * MeshTextureFace.uv2 -> uv2:   float[2]  "NO DESCRIPTION"
-#+ * MeshTextureFace.uv3 -> uv3:   float[2]  "NO DESCRIPTION"
-#+ * MeshTextureFace.uv4 -> uv4:   float[2]  "NO DESCRIPTION"
-#+ * MeshTextureFace.uv_raw -> uv_raw:   float[8]  "Fixed size UV coordinates array"
-#+ * MeshTextureFaceLayer.active -> active:   boolean  "Sets the layer as active for display and editing"
-#+ * MeshTextureFaceLayer.active_clone -> active_clone:   boolean  "Sets the layer as active for cloning"
-#+ * MeshTextureFaceLayer.active_render -> active_render:   boolean  "Sets the layer as active for rendering"
-#+ * MeshTextureFaceLayer.data -> data:   collection,  "(read-only)"
-#+ * MeshTextureFaceLayer.name -> name:   string  "NO DESCRIPTION"
-#+ * MeshVertex.bevel_weight -> bevel_weight:   float  "Weight used by the Bevel modifier Only Vertices option"
-#+ * MeshVertex.co -> co:   float[3]  "NO DESCRIPTION"
-#+ * MeshVertex.groups -> groups:   collection,  "(read-only)    Weights for the vertex groups this vertex is member of"
-#+ * MeshVertex.hide -> hide:   boolean  "NO DESCRIPTION"
-#+ * MeshVertex.index -> index:   int,  "(read-only)    Index number of the vertex"
-#+ * MeshVertex.normal -> normal:   float[3]  "Vertex Normal"
-#+ * MeshVertex.select -> select:   boolean  "NO DESCRIPTION"
-#MetaBallElements.active -> active:   pointer,  "(read-only)    Last selected element"
-#MetaElement.co -> co:   float[3]  "NO DESCRIPTION"
-#+ * MetaElement.hide -> hide:   boolean  "Hide element"
-#+ * MetaElement.radius -> radius:   float  "NO DESCRIPTION"
-#+ * MetaElement.rotation -> rotation:   float[4]  "NO DESCRIPTION"
-#+ * MetaElement.size_x -> size_x:   float  "Size of element, use of components depends on element type"
-#+ * MetaElement.size_y -> size_y:   float  "Size of element, use of components depends on element type"
-#+ * MetaElement.size_z -> size_z:   float  "Size of element, use of components depends on element type"
-#+ * MetaElement.stiffness -> stiffness:   float  "Stiffness defines how much of the element to fill"
-#+ * MetaElement.type -> type:   enum  "Metaball types"
-#MetaElement.use_negative -> use_negative:   boolean  "Set metaball as negative one"
-#+ * Modifier.name -> name:   string  "Modifier name"
-#Modifier.show_expanded -> show_expanded:   boolean  "Set modifier expanded in the user interface"
-#Modifier.show_in_editmode -> show_in_editmode:   boolean  "Use modifier while in the edit mode"
-#Modifier.show_on_cage -> show_on_cage:   boolean  "Enable direct editing of modifier control cage"
-#Modifier.show_render -> show_render:   boolean  "Use modifier during rendering"
-#Modifier.show_viewport -> show_viewport:   boolean  "Realtime display of a modifier"
-#+ * Modifier.type -> type:   enum,  "(read-only)"
-#Modifier|ArmatureModifier.invert_vertex_group -> invert_vertex_group:   boolean  "Invert vertex group influence"
-#+ * Modifier|ArmatureModifier.object -> object:   pointer  "Armature object to deform with"
-#+ * Modifier|ArmatureModifier.use_bone_envelopes -> use_bone_envelopes:   boolean  "NO DESCRIPTION"
-#Modifier|ArmatureModifier.use_deform_preserve_volume -> use_deform_preserve_volume:   boolean  "Deform rotation interpolation with quaternions"
-#Modifier|ArmatureModifier.use_multi_modifier -> use_multi_modifier:   boolean  "Use same input as previous modifier, and mix results using overall vgroup"
-#+ * Modifier|ArmatureModifier.use_vertex_groups -> use_vertex_groups:   boolean  "NO DESCRIPTION"
-#+ * Modifier|ArmatureModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#Modifier|ArrayModifier.constant_offset_displace -> constant_offset_displace:   float[3]  "NO DESCRIPTION"
-#+ * Modifier|ArrayModifier.count -> count:   int  "Number of duplicates to make"
-#+ * Modifier|ArrayModifier.curve -> curve:   pointer  "Curve object to fit array length to"
-#+ * Modifier|ArrayModifier.end_cap -> end_cap:   pointer  "Mesh object to use as an end cap"
-#Modifier|ArrayModifier.fit_length -> fit_length:   float  "Length to fit array within"
-#+ * Modifier|ArrayModifier.fit_type -> fit_type:   enum  "Array length calculation method"
-#Modifier|ArrayModifier.merge_threshold -> merge_threshold:   float  "Limit below which to merge vertices"
-#+ * Modifier|ArrayModifier.offset_object -> offset_object:   pointer  "NO DESCRIPTION"
-#Modifier|ArrayModifier.relative_offset_displace -> relative_offset_displace:   float[3]  "NO DESCRIPTION"
-#+ * Modifier|ArrayModifier.start_cap -> start_cap:   pointer  "Mesh object to use as a start cap"
-#Modifier|ArrayModifier.use_constant_offset -> use_constant_offset:   boolean  "Add a constant offset"
-#Modifier|ArrayModifier.use_merge_vertices -> use_merge_vertices:   boolean  "Merge vertices in adjacent duplicates"
-#Modifier|ArrayModifier.use_merge_vertices_cap -> use_merge_vertices_cap:   boolean  "Merge vertices in first and last duplicates"
-#Modifier|ArrayModifier.use_object_offset -> use_object_offset:   boolean  "Add another objects transformation to the total offset"
-#Modifier|ArrayModifier.use_relative_offset -> use_relative_offset:   boolean  "Add an offset relative to the objects bounding box"
-#Modifier|BevelModifier.angle_limit -> angle_limit:   float  "Angle above which to bevel edges"
-#+ * Modifier|BevelModifier.edge_weight_method -> edge_weight_method:   enum  "What edge weight to use for weighting a vertex"
-#+ * Modifier|BevelModifier.limit_method -> limit_method:   enum  "NO DESCRIPTION"
-#Modifier|BevelModifier.use_only_vertices -> use_only_vertices:   boolean  "Bevel verts/corners, not edges"
-#+ * Modifier|BevelModifier.width -> width:   float  "Bevel value/amount"
-#+ * Modifier|BooleanModifier.object -> object:   pointer  "Mesh object to use for Boolean operation"
-#+ * Modifier|BooleanModifier.operation -> operation:   enum  "NO DESCRIPTION"
-#Modifier|BuildModifier.frame_duration -> frame_duration:   float  "Specify the total time the build effect requires"
-#+ * Modifier|BuildModifier.frame_start -> frame_start:   float  "Specify the start frame of the effect"
-#+ * Modifier|BuildModifier.seed -> seed:   int  "Specify the seed for random if used"
-#Modifier|BuildModifier.use_random_order -> use_random_order:   boolean  "Randomize the faces or edges during build"
-#+ * Modifier|CastModifier.cast_type -> cast_type:   enum  "NO DESCRIPTION"
-#+ * Modifier|CastModifier.factor -> factor:   float  "NO DESCRIPTION"
-#+ * Modifier|CastModifier.object -> object:   pointer  "Control object: if available, its location determines the center of the effect"
-#+ * Modifier|CastModifier.radius -> radius:   float  "Only deform vertices within this distance from the center of the effect (leave as 0 for infinite.)"
-#+ * Modifier|CastModifier.size -> size:   float  "Size of projection shape (leave as 0 for auto.)"
-#Modifier|CastModifier.use_radius_as_size -> use_radius_as_size:   boolean  "Use radius as size of projection shape (0 = auto)"
-#+ * Modifier|CastModifier.use_transform -> use_transform:   boolean  "Use object transform to control projection shape"
-#Modifier|CastModifier.use_x -> use_x:   boolean  "NO DESCRIPTION"
-#Modifier|CastModifier.use_y -> use_y:   boolean  "NO DESCRIPTION"
-#Modifier|CastModifier.use_z -> use_z:   boolean  "NO DESCRIPTION"
-#+ * Modifier|CastModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#+ * Modifier|ClothModifier.collision_settings -> collision_settings:   pointer,  "(read-only)"
-#+ * Modifier|ClothModifier.point_cache -> point_cache:   pointer,  "(read-only)"
-#+ * Modifier|ClothModifier.settings -> settings:   pointer,  "(read-only)"
-#+ * Modifier|CollisionModifier.settings -> settings:   pointer,  "(read-only)"
-#+ * Modifier|CurveModifier.deform_axis -> deform_axis:   enum  "The axis that the curve deforms along"
-#+ * Modifier|CurveModifier.object -> object:   pointer  "Curve object to deform with"
-#+ * Modifier|CurveModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#+ * Modifier|DecimateModifier.face_count -> face_count:   int,  "(read-only)    The current number of faces in the decimated mesh"
-#+ * Modifier|DecimateModifier.ratio -> ratio:   float  "Defines the ratio of triangles to reduce to"
-#+ * Modifier|DisplaceModifier.direction -> direction:   enum  "NO DESCRIPTION"
-#Modifier|DisplaceModifier.mid_level -> mid_level:   float  "Material value that gives no displacement"
-#+ * Modifier|DisplaceModifier.strength -> strength:   float  "NO DESCRIPTION"
-#+ * Modifier|DisplaceModifier.texture -> texture:   pointer  "NO DESCRIPTION"
-#+ * Modifier|DisplaceModifier.texture_coordinate_object -> texture_coordinate_object:   pointer  "NO DESCRIPTION"
-#Modifier|DisplaceModifier.texture_coords -> texture_coords:   enum  "NO DESCRIPTION"
-#+ * Modifier|DisplaceModifier.uv_layer -> uv_layer:   string  "UV layer name"
-#+ * Modifier|DisplaceModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#+ * Modifier|EdgeSplitModifier.split_angle -> split_angle:   float  "Angle above which to split edges"
-#+ * Modifier|EdgeSplitModifier.use_edge_angle -> use_edge_angle:   boolean  "Split edges with high angle between faces"
-#Modifier|EdgeSplitModifier.use_edge_sharp -> use_edge_sharp:   boolean  "Split edges that are marked as sharp"
-#+ * Modifier|ExplodeModifier.protect -> protect:   float  "Clean vertex group edges"
-#Modifier|ExplodeModifier.show_alive -> show_alive:   boolean  "Show mesh when particles are alive"
-#Modifier|ExplodeModifier.show_dead -> show_dead:   boolean  "Show mesh when particles are dead"
-#Modifier|ExplodeModifier.show_unborn -> show_unborn:   boolean  "Show mesh when particles are unborn"
-#Modifier|ExplodeModifier.use_edge_split -> use_edge_split:   boolean  "Split face edges for nicer shrapnel"
-#Modifier|ExplodeModifier.use_size -> use_size:   boolean  "Use particle size for the shrapnel"
-#+ * Modifier|ExplodeModifier.vertex_group -> vertex_group:   string  "NO DESCRIPTION"
-#+ * Modifier|FluidSimulationModifier.settings -> settings:   pointer,  "(read-only)    Settings for how this object is used in the fluid simulation"
-#+ * Modifier|HookModifier.falloff -> falloff:   float  "If not zero, the distance from the hook where influence ends"
-#+ * Modifier|HookModifier.force -> force:   float  "Relative force of the hook"
-#+ * Modifier|HookModifier.object -> object:   pointer  "Parent Object for hook, also recalculates and clears offset"
-#+ * Modifier|HookModifier.subtarget -> subtarget:   string  "Name of Parent Bone for hook (if applicable), also recalculates and clears offset"
-#+ * Modifier|HookModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#+ * Modifier|LatticeModifier.object -> object:   pointer  "Lattice object to deform with"
-#+ * Modifier|LatticeModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#+ * Modifier|MaskModifier.armature -> armature:   pointer  "Armature to use as source of bones to mask"
-#Modifier|MaskModifier.invert_vertex_group -> invert_vertex_group:   boolean  "Use vertices that are not part of region defined"
-#+ * Modifier|MaskModifier.mode -> mode:   enum  "NO DESCRIPTION"
-#+ * Modifier|MaskModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#Modifier|MeshDeformModifier.invert_vertex_group -> invert_vertex_group:   boolean  "Invert vertex group influence"
-#+ * Modifier|MeshDeformModifier.is_bound -> is_bound:   boolean,  "(read-only)    Whether geometry has been bound to control cage"
-#+ * Modifier|MeshDeformModifier.object -> object:   pointer  "Mesh object to deform with"
-#+ * Modifier|MeshDeformModifier.precision -> precision:   int  "The grid size for binding"
-#Modifier|MeshDeformModifier.use_dynamic_bind -> use_dynamic_bind:   boolean  "Recompute binding dynamically on top of other deformers (slower and more memory consuming.)"
-#+ * Modifier|MeshDeformModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#Modifier|MirrorModifier.merge_threshold -> merge_threshold:   float  "Distance from axis within which mirrored vertices are merged"
-#+ * Modifier|MirrorModifier.mirror_object -> mirror_object:   pointer  "Object to use as mirror"
-#Modifier|MirrorModifier.use_clip -> use_clip:   boolean  "Prevents vertices from going through the mirror during transform"
-#Modifier|MirrorModifier.use_mirror_u -> use_mirror_u:   boolean  "Mirror the U texture coordinate around the 0.5 point"
-#Modifier|MirrorModifier.use_mirror_v -> use_mirror_v:   boolean  "Mirror the V texture coordinate around the 0.5 point"
-#Modifier|MirrorModifier.use_mirror_vertex_groups -> use_mirror_vertex_groups:   boolean  "Mirror vertex groups (e.g. .R->.L)"
-#Modifier|MirrorModifier.use_x -> use_x:   boolean  "Enable X axis mirror"
-#Modifier|MirrorModifier.use_y -> use_y:   boolean  "Enable Y axis mirror"
-#Modifier|MirrorModifier.use_z -> use_z:   boolean  "Enable Z axis mirror"
-#+ * Modifier|MultiresModifier.filepath -> filepath:   string  "Path to external displacements file"
-#Modifier|MultiresModifier.is_external -> is_external:   boolean,  "(read-only)    Store multires displacements outside the .blend file, to save memory"
-#+ * Modifier|MultiresModifier.levels -> levels:   int  "Number of subdivisions to use in the viewport"
-#+ * Modifier|MultiresModifier.render_levels -> render_levels:   int  "NO DESCRIPTION"
-#+ * Modifier|MultiresModifier.sculpt_levels -> sculpt_levels:   int  "Number of subdivisions to use in sculpt mode"
-#Modifier|MultiresModifier.show_only_control_edges -> show_only_control_edges:   boolean  "Skip drawing/rendering of interior subdivided edges"
-#+ * Modifier|MultiresModifier.subdivision_type -> subdivision_type:   enum  "Selects type of subdivision algorithm"
-#+ * Modifier|MultiresModifier.total_levels -> total_levels:   int,  "(read-only)    Number of subdivisions for which displacements are stored"
-#+ * Modifier|ParticleInstanceModifier.axis -> axis:   enum  "Pole axis for rotation"
-#+ * Modifier|ParticleInstanceModifier.object -> object:   pointer  "Object that has the particle system"
-#Modifier|ParticleInstanceModifier.particle_system_index -> particle_system_index:   int  "NO DESCRIPTION"
-#+ * Modifier|ParticleInstanceModifier.position -> position:   float  "Position along path"
-#+ * Modifier|ParticleInstanceModifier.random_position -> random_position:   float  "Randomize position along path"
-#Modifier|ParticleInstanceModifier.show_alive -> show_alive:   boolean  "Show instances when particles are alive"
-#Modifier|ParticleInstanceModifier.show_dead -> show_dead:   boolean  "Show instances when particles are dead"
-#Modifier|ParticleInstanceModifier.show_unborn -> show_unborn:   boolean  "Show instances when particles are unborn"
-#Modifier|ParticleInstanceModifier.use_children -> use_children:   boolean  "Create instances from child particles"
-#Modifier|ParticleInstanceModifier.use_normal -> use_normal:   boolean  "Create instances from normal particles"
-#+ * Modifier|ParticleInstanceModifier.use_path -> use_path:   boolean  "Create instances along particle paths"
-#Modifier|ParticleInstanceModifier.use_preserve_shape -> use_preserve_shape:   boolean  "Dont stretch the object"
-#Modifier|ParticleInstanceModifier.use_size -> use_size:   boolean  "Use particle size to scale the instances"
-#+ * Modifier|ParticleSystemModifier.particle_system -> particle_system:   pointer,  "(read-only)    Particle System that this modifier controls"
-#+ * Modifier|ScrewModifier.angle -> angle:   float  "Angle of revolution"
-#+ * Modifier|ScrewModifier.axis -> axis:   enum  "Screw axis"
-#+ * Modifier|ScrewModifier.iterations -> iterations:   int  "Number of times to apply the screw operation"
-#+ * Modifier|ScrewModifier.object -> object:   pointer  "Object to define the screw axis"
-#+ * Modifier|ScrewModifier.render_steps -> render_steps:   int  "Number of steps in the revolution"
-#+ * Modifier|ScrewModifier.screw_offset -> screw_offset:   float  "Offset the revolution along its axis"
-#+ * Modifier|ScrewModifier.steps -> steps:   int  "Number of steps in the revolution"
-#+ * Modifier|ScrewModifier.use_normal_calculate -> use_normal_calculate:   boolean  "Calculate the order of edges (needed for meshes, but not curves)"
-#+ * Modifier|ScrewModifier.use_normal_flip -> use_normal_flip:   boolean  "Flip normals of lathed faces"
-#+ * Modifier|ScrewModifier.use_object_screw_offset -> use_object_screw_offset:   boolean  "Use the distance between the objects to make a screw"
-#+ * Modifier|ShrinkwrapModifier.auxiliary_target -> auxiliary_target:   pointer  "Additional mesh target to shrink to"
-#+ * Modifier|ShrinkwrapModifier.offset -> offset:   float  "Distance to keep from the target"
-#+ * Modifier|ShrinkwrapModifier.subsurf_levels -> subsurf_levels:   int  "Number of subdivisions that must be performed before extracting vertices positions and normals"
-#+ * Modifier|ShrinkwrapModifier.target -> target:   pointer  "Mesh target to shrink to"
-#Modifier|ShrinkwrapModifier.use_cull_back_faces -> use_cull_back_faces:   boolean  "Stop vertices from projecting to a back face on the target"
-#Modifier|ShrinkwrapModifier.use_cull_front_faces -> use_cull_front_faces:   boolean  "Stop vertices from projecting to a front face on the target"
-#Modifier|ShrinkwrapModifier.use_keep_above_surface -> use_keep_above_surface:   boolean  "NO DESCRIPTION"
-#Modifier|ShrinkwrapModifier.use_negative_direction -> use_negative_direction:   boolean  "Allow vertices to move in the negative direction of axis"
-#Modifier|ShrinkwrapModifier.use_positive_direction -> use_positive_direction:   boolean  "Allow vertices to move in the positive direction of axis"
-#Modifier|ShrinkwrapModifier.use_project_x -> use_project_x:   boolean  "NO DESCRIPTION"
-#Modifier|ShrinkwrapModifier.use_project_y -> use_project_y:   boolean  "NO DESCRIPTION"
-#Modifier|ShrinkwrapModifier.use_project_z -> use_project_z:   boolean  "NO DESCRIPTION"
-#+ * Modifier|ShrinkwrapModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#Modifier|ShrinkwrapModifier.wrap_method -> wrap_method:   enum  "NO DESCRIPTION"
-#Modifier|SimpleDeformModifier.deform_method -> deform_method:   enum  "NO DESCRIPTION"
-#+ * Modifier|SimpleDeformModifier.factor -> factor:   float  "NO DESCRIPTION"
-#+ * Modifier|SimpleDeformModifier.limits -> limits:   float[2]  "Lower/Upper limits for deform"
-#Modifier|SimpleDeformModifier.lock_x -> lock_x:   boolean  "NO DESCRIPTION"
-#Modifier|SimpleDeformModifier.lock_y -> lock_y:   boolean  "NO DESCRIPTION"
-#+ * Modifier|SimpleDeformModifier.origin -> origin:   pointer  "Origin of modifier space coordinates"
-#Modifier|SimpleDeformModifier.use_relative -> use_relative:   boolean  "Sets the origin of deform space to be relative to the object"
-#+ * Modifier|SimpleDeformModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#+ * Modifier|SmokeModifier.coll_settings -> coll_settings:   pointer,  "(read-only)"
-#+ * Modifier|SmokeModifier.domain_settings -> domain_settings:   pointer,  "(read-only)"
-#+ * Modifier|SmokeModifier.flow_settings -> flow_settings:   pointer,  "(read-only)"
-#Modifier|SmokeModifier.smoke_type -> smoke_type:   enum  "NO DESCRIPTION"
-#+ * Modifier|SmoothModifier.factor -> factor:   float  "NO DESCRIPTION"
-#Modifier|SmoothModifier.iterations -> iterations:   int  "NO DESCRIPTION"
-#Modifier|SmoothModifier.use_x -> use_x:   boolean  "NO DESCRIPTION"
-#Modifier|SmoothModifier.use_y -> use_y:   boolean  "NO DESCRIPTION"
-#Modifier|SmoothModifier.use_z -> use_z:   boolean  "NO DESCRIPTION"
-#+ * Modifier|SmoothModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#+ * Modifier|SoftBodyModifier.point_cache -> point_cache:   pointer,  "(read-only)"
-#+ * Modifier|SoftBodyModifier.settings -> settings:   pointer,  "(read-only)"
-#+ * Modifier|SolidifyModifier.edge_crease_inner -> edge_crease_inner:   float  "Assign a crease to inner edges"
-#+ * Modifier|SolidifyModifier.edge_crease_outer -> edge_crease_outer:   float  "Assign a crease to outer edges"
-#+ * Modifier|SolidifyModifier.edge_crease_rim -> edge_crease_rim:   float  "Assign a crease to the edges making up the rim"
-#Modifier|SolidifyModifier.invert_vertex_group -> invert_vertex_group:   boolean  "Invert the vertex group influence"
-#+ * Modifier|SolidifyModifier.offset -> offset:   float  "Offset the thickness from the center"
-#+ * Modifier|SolidifyModifier.thickness -> thickness:   float  "Thickness of the shell"
-#+ * Modifier|SolidifyModifier.use_even_offset -> use_even_offset:   boolean  "Maintain thickness by adjusting for sharp corners (slow, disable when not needed)"
-#+ * Modifier|SolidifyModifier.use_quality_normals -> use_quality_normals:   boolean  "Calculate normals which result in more even thickness (slow, disable when not needed)"
-#+ * Modifier|SolidifyModifier.use_rim -> use_rim:   boolean  "Create edge loops between the inner and outer surfaces on face edges (slow, disable when not needed)"
-#+ * Modifier|SolidifyModifier.use_rim_material -> use_rim_material:   boolean  "Use in the next material for rim faces"
-#+ * Modifier|SolidifyModifier.vertex_group -> vertex_group:   string  "Vertex group name"
-#+ * Modifier|SubsurfModifier.levels -> levels:   int  "Number of subdivisions to perform"
-#+ * Modifier|SubsurfModifier.render_levels -> render_levels:   int  "Number of subdivisions to perform when rendering"
-#Modifier|SubsurfModifier.show_only_control_edges -> show_only_control_edges:   boolean  "Skip drawing/rendering of interior subdivided edges"
-#+ * Modifier|SubsurfModifier.subdivision_type -> subdivision_type:   enum  "Selects type of subdivision algorithm"
-#Modifier|SubsurfModifier.use_subsurf_uv -> use_subsurf_uv:   boolean  "Use subsurf to subdivide UVs"
-#+ * Modifier|UVProjectModifier.aspect_x -> aspect_x:   float  "NO DESCRIPTION"
-#+ * Modifier|UVProjectModifier.aspect_y -> aspect_y:   float  "NO DESCRIPTION"
-#+ * Modifier|UVProjectModifier.image -> image:   pointer  "NO DESCRIPTION"
-#Modifier|UVProjectModifier.projector_count -> projector_count:   int  "Number of projectors to use"
-#+ * Modifier|UVProjectModifier.projectors -> projectors:   collection,  "(read-only)"
-#+ * Modifier|UVProjectModifier.scale_x -> scale_x:   float  "NO DESCRIPTION"
-#+ * Modifier|UVProjectModifier.scale_y -> scale_y:   float  "NO DESCRIPTION"
-#Modifier|UVProjectModifier.use_image_override -> use_image_override:   boolean  "Override faces current images with the given image"
-#+ * Modifier|UVProjectModifier.uv_layer -> uv_layer:   string  "UV layer name"
-#+ * Modifier|WaveModifier.damping_time -> damping_time:   float  "NO DESCRIPTION"
-#+ * Modifier|WaveModifier.falloff_radius -> falloff_radius:   float  "NO DESCRIPTION"
-#+ * Modifier|WaveModifier.height -> height:   float  "NO DESCRIPTION"
-#+ * Modifier|WaveModifier.lifetime -> lifetime:   float  "NO DESCRIPTION"
-#+ * Modifier|WaveModifier.narrowness -> narrowness:   float  "NO DESCRIPTION"
-#+ * Modifier|WaveModifier.speed -> speed:   float  "NO DESCRIPTION"
-#+ * Modifier|WaveModifier.start_position_object -> start_position_object:   pointer  "NO DESCRIPTION"
-#+ * Modifier|WaveModifier.start_position_x -> start_position_x:   float  "NO DESCRIPTION"
-#+ * Modifier|WaveModifier.start_position_y -> start_position_y:   float  "NO DESCRIPTION"
-#+ * Modifier|WaveModifier.texture -> texture:   pointer  "Texture for modulating the wave"
-#Modifier|WaveModifier.texture_coords -> texture_coords:   enum  "Texture coordinates used for modulating input"
-#Modifier|WaveModifier.texture_coords_object -> texture_coords_object:   pointer  "NO DESCRIPTION"
-#+ * Modifier|WaveModifier.time_offset -> time_offset:   float  "Either the starting frame (for positive speed) or ending frame (for negative speed.)"
-#Modifier|WaveModifier.use_cyclic -> use_cyclic:   boolean  "Cyclic wave effect"
-#Modifier|WaveModifier.use_normal -> use_normal:   boolean  "Displace along normals"
-#Modifier|WaveModifier.use_normal_x -> use_normal_x:   boolean  "Enable displacement along the X normal"
-#Modifier|WaveModifier.use_normal_y -> use_normal_y:   boolean  "Enable displacement along the Y normal"
-#Modifier|WaveModifier.use_normal_z -> use_normal_z:   boolean  "Enable displacement along the Z normal"
-#Modifier|WaveModifier.use_x -> use_x:   boolean  "X axis motion"
-#Modifier|WaveModifier.use_y -> use_y:   boolean  "Y axis motion"
-#+ * Modifier|WaveModifier.uv_layer -> uv_layer:   string  "UV layer name"
-#+ * Modifier|WaveModifier.vertex_group -> vertex_group:   string  "Vertex group name for modulating the wave"
-#+ * Modifier|WaveModifier.width -> width:   float  "NO DESCRIPTION"
-#+ * MotionPath.frame_end -> frame_end:   int,  "(read-only)    End frame of the stored range"
-#+ * MotionPath.frame_start -> frame_start:   int,  "(read-only)    Starting frame of the stored range"
-#MotionPath.is_modified -> is_modified:   boolean  "Path is being edited"
-#+ * MotionPath.length -> length:   int,  "(read-only)    Number of frames cached"
-#+ * MotionPath.points -> points:   collection,  "(read-only)    Cached positions per frame"
-#+ * MotionPath.use_bone_head -> use_bone_head:   boolean,  "(read-only)    For PoseBone paths, use the bone head location when calculating this path"
-#+ * MotionPathVert.co -> co:   float[3]  "NO DESCRIPTION"
-#+ * MotionPathVert.select -> select:   boolean  "Path point is selected for editing"
-#+ * NlaStrip.action -> action:   pointer  "Action referenced by this strip"
-#NlaStrip.action_frame_end -> action_frame_end:   float  "NO DESCRIPTION"
-#NlaStrip.action_frame_start -> action_frame_start:   float  "NO DESCRIPTION"
-#+ * NlaStrip.active -> active:   boolean,  "(read-only)    NLA Strip is active"
-#+ * NlaStrip.blend_in -> blend_in:   float  "Number of frames at start of strip to fade in influence"
-#+ * NlaStrip.blend_out -> blend_out:   float  "NO DESCRIPTION"
-#NlaStrip.blend_type -> blend_type:   enum  "Method used for combining strips result with accumulated result"
-#+ * NlaStrip.extrapolation -> extrapolation:   enum  "Action to take for gaps past the strip extents"
-#+ * NlaStrip.fcurves -> fcurves:   collection,  "(read-only)    F-Curves for controlling the strips influence and timing"
-#+ * NlaStrip.frame_end -> frame_end:   float  "NO DESCRIPTION"
-#+ * NlaStrip.frame_start -> frame_start:   float  "NO DESCRIPTION"
-#+ * NlaStrip.influence -> influence:   float  "Amount the strip contributes to the current result"
-#+ * NlaStrip.modifiers -> modifiers:   collection,  "(read-only)    Modifiers affecting all the F-Curves in the referenced Action"
-#+ * NlaStrip.mute -> mute:   boolean  "NLA Strip is not evaluated"
-#+ * NlaStrip.name -> name:   string  "NO DESCRIPTION"
-#+ * NlaStrip.repeat -> repeat:   float  "Number of times to repeat the action range"
-#+ * NlaStrip.scale -> scale:   float  "Scaling factor for action"
-#+ * NlaStrip.select -> select:   boolean  "NLA Strip is selected"
-#+ * NlaStrip.strip_time -> strip_time:   float  "Frame of referenced Action to evaluate"
-#+ * NlaStrip.strips -> strips:   collection,  "(read-only)    NLA Strips that this strip acts as a container for (if it is of type Meta)"
-#+ * NlaStrip.type -> type:   enum,  "(read-only)    Type of NLA Strip"
-#NlaStrip.use_animated_influence -> use_animated_influence:   boolean  "Influence setting is controlled by an F-Curve rather than automatically determined"
-#NlaStrip.use_animated_time -> use_animated_time:   boolean  "Strip time is controlled by an F-Curve rather than automatically determined"
-#NlaStrip.use_animated_time_cyclic -> use_animated_time_cyclic:   boolean  "Cycle the animated time within the action start & end"
-#NlaStrip.use_auto_blend -> use_auto_blend:   boolean  "Number of frames for Blending In/Out is automatically determined from overlapping strips"
-#NlaStrip.use_reverse -> use_reverse:   boolean  "NLA Strip is played back in reverse order (only when timing is automatically determined)"
-#+ * NlaTrack.active -> active:   boolean,  "(read-only)    NLA Track is active"
-#NlaTrack.is_solo -> is_solo:   boolean,  "(read-only)    NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled)"
-#+ * NlaTrack.lock -> lock:   boolean  "NLA Track is locked"
-#+ * NlaTrack.mute -> mute:   boolean  "NLA Track is not evaluated"
-#+ * NlaTrack.name -> name:   string  "NO DESCRIPTION"
-#+ * NlaTrack.select -> select:   boolean  "NLA Track is selected"
-#+ * NlaTrack.strips -> strips:   collection,  "(read-only)    NLA Strips on this NLA-track"
-#+ * Node.inputs -> inputs:   collection,  "(read-only)"
-#+ * Node.location -> location:   float[2]  "NO DESCRIPTION"
-#+ * Node.name -> name:   string  "Node name"
-#+ * Node.outputs -> outputs:   collection,  "(read-only)"
-#+ * Node|CompositorNode.type -> type:   enum,  "(read-only)"
-#+ * Node|CompositorNode|CompositorNodeAlphaOver.premul -> premul:   float  "Mix Factor"
-#Node|CompositorNode|CompositorNodeAlphaOver.use_premultiply -> use_premultiply:   boolean  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeBilateralblur.iterations -> iterations:   int  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeBilateralblur.sigma_color -> sigma_color:   float  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeBilateralblur.sigma_space -> sigma_space:   float  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeBlur.factor -> factor:   float  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeBlur.factor_x -> factor_x:   float  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeBlur.factor_y -> factor_y:   float  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeBlur.filter_type -> filter_type:   enum  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeBlur.size_x -> size_x:   int  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeBlur.size_y -> size_y:   int  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeBlur.use_bokeh -> use_bokeh:   boolean  "Uses circular filter (slower)"
-#Node|CompositorNode|CompositorNodeBlur.use_gamma_correction -> use_gamma_correction:   boolean  "Applies filter on gamma corrected values"
-#Node|CompositorNode|CompositorNodeBlur.use_relative -> use_relative:   boolean  "Use relative (percent) values to define blur radius"
-#+ * Node|CompositorNode|CompositorNodeChannelMatte.color_space -> color_space:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeChannelMatte.limit_channel -> limit_channel:   enum  "Limit by this channels value"
-#Node|CompositorNode|CompositorNodeChannelMatte.limit_max -> limit_max:   float  "Values higher than this setting are 100% opaque"
-#Node|CompositorNode|CompositorNodeChannelMatte.limit_method -> limit_method:   enum  "Algorithm to use to limit channel"
-#Node|CompositorNode|CompositorNodeChannelMatte.limit_min -> limit_min:   float  "Values lower than this setting are 100% keyed"
-#Node|CompositorNode|CompositorNodeChannelMatte.matte_channel -> matte_channel:   enum  "Channel used to determine matte"
-#+ * Node|CompositorNode|CompositorNodeChromaMatte.gain -> gain:   float  "Alpha gain"
-#+ * Node|CompositorNode|CompositorNodeChromaMatte.lift -> lift:   float  "Alpha lift"
-#+ * Node|CompositorNode|CompositorNodeChromaMatte.shadow_adjust -> shadow_adjust:   float  "Adjusts the brightness of any shadows captured"
-#Node|CompositorNode|CompositorNodeChromaMatte.threshold -> threshold:   float  "Tolerance below which colors will be considered as exact matches"
-#Node|CompositorNode|CompositorNodeChromaMatte.tolerance -> tolerance:   float  "Tolerance for a color to be considered a keying color"
-#Node|CompositorNode|CompositorNodeColorBalance.correction_method -> correction_method:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeColorBalance.gain -> gain:   float[3]  "Correction for Highlights"
-#+ * Node|CompositorNode|CompositorNodeColorBalance.gamma -> gamma:   float[3]  "Correction for Midtones"
-#+ * Node|CompositorNode|CompositorNodeColorBalance.lift -> lift:   float[3]  "Correction for Shadows"
-#+ * Node|CompositorNode|CompositorNodeColorBalance.offset -> offset:   float[3]  "Correction for Shadows"
-#+ * Node|CompositorNode|CompositorNodeColorBalance.power -> power:   float[3]  "Correction for Midtones"
-#+ * Node|CompositorNode|CompositorNodeColorBalance.slope -> slope:   float[3]  "Correction for Highlights"
-#Node|CompositorNode|CompositorNodeColorMatte.color_hue -> color_hue:   float  "Hue tolerance for colors to be considered a keying color"
-#Node|CompositorNode|CompositorNodeColorMatte.color_saturation -> color_saturation:   float  "Saturation Tolerance for the color"
-#Node|CompositorNode|CompositorNodeColorMatte.color_value -> color_value:   float  "Value Tolerance for the color"
-#+ * Node|CompositorNode|CompositorNodeColorSpill.channel -> channel:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeColorSpill.limit_channel -> limit_channel:   enum  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeColorSpill.limit_method -> limit_method:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeColorSpill.ratio -> ratio:   float  "Scale limit by value"
-#+ * Node|CompositorNode|CompositorNodeColorSpill.unspill_blue -> unspill_blue:   float  "Blue spillmap scale"
-#+ * Node|CompositorNode|CompositorNodeColorSpill.unspill_green -> unspill_green:   float  "Green spillmap scale"
-#+ * Node|CompositorNode|CompositorNodeColorSpill.unspill_red -> unspill_red:   float  "Red spillmap scale"
-#Node|CompositorNode|CompositorNodeColorSpill.use_unspill -> use_unspill:   boolean  "Compensate all channels (diffenrently) by hand"
-#Node|CompositorNode|CompositorNodeCrop.max_x -> max_x:   int  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeCrop.max_y -> max_y:   int  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeCrop.min_x -> min_x:   int  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeCrop.min_y -> min_y:   int  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeCrop.use_crop_size -> use_crop_size:   boolean  "Whether to crop the size of the input image"
-#+ * Node|CompositorNode|CompositorNodeCurveRGB.mapping -> mapping:   pointer,  "(read-only)"
-#+ * Node|CompositorNode|CompositorNodeCurveVec.mapping -> mapping:   pointer,  "(read-only)"
-#+ * Node|CompositorNode|CompositorNodeDBlur.angle -> angle:   float  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeDBlur.center_x -> center_x:   float  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeDBlur.center_y -> center_y:   float  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeDBlur.distance -> distance:   float  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeDBlur.iterations -> iterations:   int  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeDBlur.spin -> spin:   float  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeDBlur.use_wrap -> use_wrap:   boolean  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeDBlur.zoom -> zoom:   float  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeDefocus.angle -> angle:   int  "Bokeh shape rotation offset in degrees"
-#Node|CompositorNode|CompositorNodeDefocus.blur_max -> blur_max:   float  "blur limit, maximum CoC radius, 0=no limit"
-#+ * Node|CompositorNode|CompositorNodeDefocus.bokeh -> bokeh:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeDefocus.f_stop -> f_stop:   float  "Amount of focal blur, 128=infinity=perfect focus, half the value doubles the blur radius"
-#+ * Node|CompositorNode|CompositorNodeDefocus.samples -> samples:   int  "Number of samples (16=grainy, higher=less noise)"
-#+ * Node|CompositorNode|CompositorNodeDefocus.threshold -> threshold:   float  "CoC radius threshold, prevents background bleed on in-focus midground, 0=off"
-#Node|CompositorNode|CompositorNodeDefocus.use_gamma_correction -> use_gamma_correction:   boolean  "Enable gamma correction before and after main process"
-#Node|CompositorNode|CompositorNodeDefocus.use_preview -> use_preview:   boolean  "Enable sampling mode, useful for preview when using low samplecounts"
-#+ * Node|CompositorNode|CompositorNodeDefocus.use_zbuffer -> use_zbuffer:   boolean  "Disable when using an image as input instead of actual zbuffer (auto enabled if node not image based, eg. time node)"
-#+ * Node|CompositorNode|CompositorNodeDefocus.z_scale -> z_scale:   float  "Scales the Z input when not using a zbuffer, controls maximum blur designated by the color white or input value 1"
-#+ * Node|CompositorNode|CompositorNodeDiffMatte.falloff -> falloff:   float  "Color distances below this additional threshold are partially keyed"
-#+ * Node|CompositorNode|CompositorNodeDiffMatte.tolerance -> tolerance:   float  "Color distances below this threshold are keyed"
-#+ * Node|CompositorNode|CompositorNodeDilateErode.distance -> distance:   int  "Distance to grow/shrink (number of iterations)"
-#+ * Node|CompositorNode|CompositorNodeDistanceMatte.falloff -> falloff:   float  "Color distances below this additional threshold are partially keyed"
-#+ * Node|CompositorNode|CompositorNodeDistanceMatte.tolerance -> tolerance:   float  "Color distances below this threshold are keyed"
-#+ * Node|CompositorNode|CompositorNodeFilter.filter_type -> filter_type:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeFlip.axis -> axis:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeGlare.angle_offset -> angle_offset:   float  "Streak angle offset in degrees"
-#+ * Node|CompositorNode|CompositorNodeGlare.color_modulation -> color_modulation:   float  "Amount of Color Modulation, modulates colors of streaks and ghosts for a spectral dispersion effect"
-#+ * Node|CompositorNode|CompositorNodeGlare.fade -> fade:   float  "Streak fade-out factor"
-#+ * Node|CompositorNode|CompositorNodeGlare.glare_type -> glare_type:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeGlare.iterations -> iterations:   int  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeGlare.mix -> mix:   float  "-1 is original image only, 0 is exact 50/50 mix, 1 is processed image only"
-#+ * Node|CompositorNode|CompositorNodeGlare.quality -> quality:   enum  "If not set to high quality, the effect will be applied to a low-res copy of the source image"
-#+ * Node|CompositorNode|CompositorNodeGlare.size -> size:   int  "Glow/glare size (not actual size; relative to initial size of bright area of pixels)"
-#+ * Node|CompositorNode|CompositorNodeGlare.streaks -> streaks:   int  "Total number of streaks"
-#+ * Node|CompositorNode|CompositorNodeGlare.threshold -> threshold:   float  "The glare filter will only be applied to pixels brighter than this value"
-#Node|CompositorNode|CompositorNodeGlare.use_rotate_45 -> use_rotate_45:   boolean  "Simple star filter: add 45 degree rotation offset"
-#+ * Node|CompositorNode|CompositorNodeHueCorrect.mapping -> mapping:   pointer,  "(read-only)"
-#Node|CompositorNode|CompositorNodeHueSat.color_hue -> color_hue:   float  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeHueSat.color_saturation -> color_saturation:   float  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeHueSat.color_value -> color_value:   float  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeIDMask.index -> index:   int  "Pass index number to convert to alpha"
-#Node|CompositorNode|CompositorNodeImage.frame_duration -> frame_duration:   int  "Number of images used in animation"
-#Node|CompositorNode|CompositorNodeImage.frame_offset -> frame_offset:   int  "Offsets the number of the frame to use in the animation"
-#Node|CompositorNode|CompositorNodeImage.frame_start -> frame_start:   int  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeImage.image -> image:   pointer  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeImage.layer -> layer:   enum  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeImage.use_auto_refresh -> use_auto_refresh:   boolean  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeImage.use_cyclic -> use_cyclic:   boolean  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeInvert.invert_alpha -> invert_alpha:   boolean  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeInvert.invert_rgb -> invert_rgb:   boolean  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeLensdist.use_fit -> use_fit:   boolean  "For positive distortion factor only: scale image such that black areas are not visible"
-#Node|CompositorNode|CompositorNodeLensdist.use_jitter -> use_jitter:   boolean  "Enable/disable jittering; faster, but also noisier"
-#Node|CompositorNode|CompositorNodeLensdist.use_projector -> use_projector:   boolean  "Enable/disable projector mode. Effect is applied in horizontal direction only"
-#+ * Node|CompositorNode|CompositorNodeLevels.channel -> channel:   enum  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeLumaMatte.limit_max -> limit_max:   float  "Values higher than this setting are 100% opaque"
-#Node|CompositorNode|CompositorNodeLumaMatte.limit_min -> limit_min:   float  "Values lower than this setting are 100% keyed"
-#+ * Node|CompositorNode|CompositorNodeMapUV.alpha -> alpha:   int  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeMapValue.max -> max:   float[1]  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeMapValue.min -> min:   float[1]  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeMapValue.offset -> offset:   float[1]  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeMapValue.size -> size:   float[1]  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeMapValue.use_max -> use_max:   boolean  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeMapValue.use_min -> use_min:   boolean  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeMath.operation -> operation:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeMixRGB.blend_type -> blend_type:   enum  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeMixRGB.use_alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
-#+ * Node|CompositorNode|CompositorNodeOutputFile.exr_codec -> exr_codec:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeOutputFile.filepath -> filepath:   string  "Output path for the image, same functionality as render output."
-#+ * Node|CompositorNode|CompositorNodeOutputFile.frame_end -> frame_end:   int  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeOutputFile.frame_start -> frame_start:   int  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeOutputFile.image_type -> image_type:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeOutputFile.quality -> quality:   int  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeOutputFile.use_exr_half -> use_exr_half:   boolean  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodePremulKey.mapping -> mapping:   enum  "Conversion between premultiplied alpha and key alpha"
-#+ * Node|CompositorNode|CompositorNodeRLayers.layer -> layer:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeRLayers.scene -> scene:   pointer  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeRotate.filter_type -> filter_type:   enum  "Method to use to filter rotation"
-#+ * Node|CompositorNode|CompositorNodeScale.space -> space:   enum  "Coordinate space to scale relative to"
-#+ * Node|CompositorNode|CompositorNodeSplitViewer.axis -> axis:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeSplitViewer.factor -> factor:   int  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeTexture.node_output -> node_output:   int  "For node-based textures, which output node to use"
-#+ * Node|CompositorNode|CompositorNodeTexture.texture -> texture:   pointer  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeTime.curve -> curve:   pointer,  "(read-only)"
-#Node|CompositorNode|CompositorNodeTime.frame_end -> frame_end:   int  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeTime.frame_start -> frame_start:   int  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeTonemap.adaptation -> adaptation:   float  "If 0, global; if 1, based on pixel intensity"
-#+ * Node|CompositorNode|CompositorNodeTonemap.contrast -> contrast:   float  "Set to 0 to use estimate from input image"
-#+ * Node|CompositorNode|CompositorNodeTonemap.correction -> correction:   float  "If 0, same for all channels; if 1, each independent"
-#+ * Node|CompositorNode|CompositorNodeTonemap.gamma -> gamma:   float  "If not used, set to 1"
-#+ * Node|CompositorNode|CompositorNodeTonemap.intensity -> intensity:   float  "If less than zero, darkens image; otherwise, makes it brighter"
-#+ * Node|CompositorNode|CompositorNodeTonemap.key -> key:   float  "The value the average luminance is mapped to"
-#+ * Node|CompositorNode|CompositorNodeTonemap.offset -> offset:   float  "Normally always 1, but can be used as an extra control to alter the brightness curve"
-#+ * Node|CompositorNode|CompositorNodeTonemap.tonemap_type -> tonemap_type:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeValToRGB.color_ramp -> color_ramp:   pointer,  "(read-only)"
-#+ * Node|CompositorNode|CompositorNodeVecBlur.factor -> factor:   float  "Scaling factor for motion vectors; actually shutter speed in frames"
-#+ * Node|CompositorNode|CompositorNodeVecBlur.samples -> samples:   int  "NO DESCRIPTION"
-#Node|CompositorNode|CompositorNodeVecBlur.speed_max -> speed_max:   int  "Maximum speed, or zero for none"
-#Node|CompositorNode|CompositorNodeVecBlur.speed_min -> speed_min:   int  "Minimum speed for a pixel to be blurred; used to separate background from foreground"
-#Node|CompositorNode|CompositorNodeVecBlur.use_curved -> use_curved:   boolean  "Interpolate between frames in a bezier curve, rather than linearly"
-#+ * Node|NodeGroup.nodetree -> nodetree:   pointer  "NO DESCRIPTION"
-#+ * Node|ShaderNode.type -> type:   enum,  "(read-only)"
-#+ * Node|ShaderNode|ShaderNodeExtendedMaterial.invert_normal -> invert_normal:   boolean  "Material Node uses inverted normal"
-#+ * Node|ShaderNode|ShaderNodeExtendedMaterial.material -> material:   pointer  "NO DESCRIPTION"
-#Node|ShaderNode|ShaderNodeExtendedMaterial.use_diffuse -> use_diffuse:   boolean  "Material Node outputs Diffuse"
-#Node|ShaderNode|ShaderNodeExtendedMaterial.use_specular -> use_specular:   boolean  "Material Node outputs Specular"
-#+ * Node|ShaderNode|ShaderNodeGeometry.color_layer -> color_layer:   string  "NO DESCRIPTION"
-#+ * Node|ShaderNode|ShaderNodeGeometry.uv_layer -> uv_layer:   string  "NO DESCRIPTION"
-#+ * Node|ShaderNode|ShaderNodeMapping.location -> location:   float[3]  "Location offset for the input coordinate"
-#Node|ShaderNode|ShaderNodeMapping.max -> max:   float[3]  "Maximum value to clamp coordinate to"
-#Node|ShaderNode|ShaderNodeMapping.min -> min:   float[3]  "Minimum value to clamp coordinate to"
-#+ * Node|ShaderNode|ShaderNodeMapping.rotation -> rotation:   float[3]  "Rotation offset for the input coordinate"
-#+ * Node|ShaderNode|ShaderNodeMapping.scale -> scale:   float[3]  "Scale adjustment for the input coordinate"
-#Node|ShaderNode|ShaderNodeMapping.use_max -> use_max:   boolean  "Clamp the output coordinate to a maximum value"
-#Node|ShaderNode|ShaderNodeMapping.use_min -> use_min:   boolean  "Clamp the output coordinate to a minimum value"
-#+ * Node|ShaderNode|ShaderNodeMaterial.invert_normal -> invert_normal:   boolean  "Material Node uses inverted normal"
-#+ * Node|ShaderNode|ShaderNodeMaterial.material -> material:   pointer  "NO DESCRIPTION"
-#Node|ShaderNode|ShaderNodeMaterial.use_diffuse -> use_diffuse:   boolean  "Material Node outputs Diffuse"
-#Node|ShaderNode|ShaderNodeMaterial.use_specular -> use_specular:   boolean  "Material Node outputs Specular"
-#+ * Node|ShaderNode|ShaderNodeMath.operation -> operation:   enum  "NO DESCRIPTION"
-#+ * Node|ShaderNode|ShaderNodeMixRGB.blend_type -> blend_type:   enum  "NO DESCRIPTION"
-#Node|ShaderNode|ShaderNodeMixRGB.use_alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
-#+ * Node|ShaderNode|ShaderNodeRGBCurve.mapping -> mapping:   pointer,  "(read-only)"
-#+ * Node|ShaderNode|ShaderNodeTexture.node_output -> node_output:   int  "For node-based textures, which output node to use"
-#+ * Node|ShaderNode|ShaderNodeTexture.texture -> texture:   pointer  "NO DESCRIPTION"
-#+ * Node|ShaderNode|ShaderNodeValToRGB.color_ramp -> color_ramp:   pointer,  "(read-only)"
-#+ * Node|ShaderNode|ShaderNodeVectorCurve.mapping -> mapping:   pointer,  "(read-only)"
-#+ * Node|ShaderNode|ShaderNodeVectorMath.operation -> operation:   enum  "NO DESCRIPTION"
-#+ * Node|TextureNode.type -> type:   enum,  "(read-only)"
-#+ * Node|TextureNode|TextureNodeBricks.offset -> offset:   float  "NO DESCRIPTION"
-#+ * Node|TextureNode|TextureNodeBricks.offset_frequency -> offset_frequency:   int  "Offset every N rows"
-#+ * Node|TextureNode|TextureNodeBricks.squash -> squash:   float  "NO DESCRIPTION"
-#+ * Node|TextureNode|TextureNodeBricks.squash_frequency -> squash_frequency:   int  "Squash every N rows"
-#+ * Node|TextureNode|TextureNodeCurveRGB.mapping -> mapping:   pointer,  "(read-only)"
-#+ * Node|TextureNode|TextureNodeCurveTime.curve -> curve:   pointer,  "(read-only)"
-#Node|TextureNode|TextureNodeCurveTime.frame_end -> frame_end:   int  "NO DESCRIPTION"
-#Node|TextureNode|TextureNodeCurveTime.frame_start -> frame_start:   int  "NO DESCRIPTION"
-#+ * Node|TextureNode|TextureNodeImage.image -> image:   pointer  "NO DESCRIPTION"
-#+ * Node|TextureNode|TextureNodeMath.operation -> operation:   enum  "NO DESCRIPTION"
-#+ * Node|TextureNode|TextureNodeMixRGB.blend_type -> blend_type:   enum  "NO DESCRIPTION"
-#Node|TextureNode|TextureNodeMixRGB.use_alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
-#Node|TextureNode|TextureNodeOutput.filepath -> filepath:   string  "NO DESCRIPTION"
-#+ * Node|TextureNode|TextureNodeTexture.node_output -> node_output:   int  "For node-based textures, which output node to use"
-#+ * Node|TextureNode|TextureNodeTexture.texture -> texture:   pointer  "NO DESCRIPTION"
-#+ * Node|TextureNode|TextureNodeValToRGB.color_ramp -> color_ramp:   pointer,  "(read-only)"
-#+ * ObjectBase.layers -> layers:   boolean[20]  "Layers the object base is on"
-#+ * ObjectBase.object -> object:   pointer,  "(read-only)    Object this base links to"
-#+ * ObjectBase.select -> select:   boolean  "Object base selection state"
-#+ * ObjectConstraints.active -> active:   pointer  "Active Object constraint"
-#+ * Operator.bl_description -> bl_description:   string  "NO DESCRIPTION"
-#+ * Operator.bl_idname -> bl_idname:   string  "NO DESCRIPTION"
-#+ * Operator.bl_label -> bl_label:   string  "NO DESCRIPTION"
-#+ * Operator.bl_options -> bl_options:   enum  "Options for this operator type"
-#+ * Operator.has_reports -> has_reports:   boolean,  "(read-only)    Operator has a set of reports (warnings and errors) from last execution"
-#+ * Operator.layout -> layout:   pointer,  "(read-only)"
-#+ * Operator.name -> name:   string,  "(read-only)"
-#+ * Operator.properties -> properties:   pointer,  "(read-only)"
-#+ * OperatorTypeMacro.properties -> properties:   pointer,  "(read-only)"
-#+ * PackedFile.size -> size:   int,  "(read-only)    Size of packed file in bytes"
-#+ * Paint.brush -> brush:   pointer  "Active Brush"
-#+ * Paint.show_brush -> show_brush:   boolean  "NO DESCRIPTION"
-#+ * Paint.show_brush_on_surface -> show_brush_on_surface:   boolean  "NO DESCRIPTION"
-#Paint.show_low_resolution -> show_low_resolution:   boolean  "For multires, show low resolution while navigating the view"
-#+ * Paint|ImagePaint.invert_stencil -> invert_stencil:   boolean  "Invert the stencil layer"
-#+ * Paint|ImagePaint.normal_angle -> normal_angle:   int  "Paint most on faces pointing towards the view according to this angle"
-#+ * Paint|ImagePaint.screen_grab_size -> screen_grab_size:   int[2]  "Size to capture the image for re-projecting"
-#+ * Paint|ImagePaint.seam_bleed -> seam_bleed:   int  "Extend paint beyond the faces UVs to reduce seams (in pixels, slower)"
-#+ * Paint|ImagePaint.show_brush -> show_brush:   boolean  "Enables brush shape while not drawing"
-#+ * Paint|ImagePaint.show_brush_draw -> show_brush_draw:   boolean  "Enables brush shape while drawing"
-#Paint|ImagePaint.use_backface_culling -> use_backface_culling:   boolean  "Ignore faces pointing away from the view (faster)"
-#+ * Paint|ImagePaint.use_clone_layer -> use_clone_layer:   boolean  "Use another UV layer as clone source, otherwise use 3D the cursor as the source"
-#+ * Paint|ImagePaint.use_normal_falloff -> use_normal_falloff:   boolean  "Paint most on faces pointing towards the view"
-#+ * Paint|ImagePaint.use_occlude -> use_occlude:   boolean  "Only paint onto the faces directly under the brush (slower)"
-#+ * Paint|ImagePaint.use_projection -> use_projection:   boolean  "Use projection painting for improved consistency in the brush strokes"
-#+ * Paint|ImagePaint.use_stencil_layer -> use_stencil_layer:   boolean  "Set the mask layer from the UV layer buttons"
-#+ * Paint|Sculpt.lock_x -> lock_x:   boolean  "Disallow changes to the X axis of vertices"
-#+ * Paint|Sculpt.lock_y -> lock_y:   boolean  "Disallow changes to the Y axis of vertices"
-#+ * Paint|Sculpt.lock_z -> lock_z:   boolean  "Disallow changes to the Z axis of vertices"
-#Paint|Sculpt.radial_symmetry -> radial_symmetry:   int[3]  "Number of times to copy strokes across the surface"
-#+ * Paint|Sculpt.use_symmetry_feather -> use_symmetry_feather:   boolean  "Reduce the strength of the brush where it overlaps symmetrical daubs"
-#Paint|Sculpt.use_symmetry_x -> use_symmetry_x:   boolean  "Mirror brush across the X axis"
-#Paint|Sculpt.use_symmetry_y -> use_symmetry_y:   boolean  "Mirror brush across the Y axis"
-#Paint|Sculpt.use_symmetry_z -> use_symmetry_z:   boolean  "Mirror brush across the Z axis"
-#Paint|Sculpt.use_threaded -> use_threaded:   boolean  "Take advantage of multiple CPU cores to improve sculpting performance"
-#Paint|VertexPaint.use_all_faces -> use_all_faces:   boolean  "Paint on all faces inside brush"
-#Paint|VertexPaint.use_normal -> use_normal:   boolean  "Applies the vertex normal before painting"
-#Paint|VertexPaint.use_spray -> use_spray:   boolean  "Keep applying paint effect while holding mouse"
-#+ * Panel.bl_context -> bl_context:   string  "The context in which the panel belongs to. (TODO: explain the possible combinations bl_context/bl_region_type/bl_space_type)"
-#+ * Panel.bl_idname -> bl_idname:   string  "If this is set, the panel gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is OBJECT_PT_hello, and bl_idname is not set by the script, then bl_idname = OBJECT_PT_hello"
-#+ * Panel.bl_label -> bl_label:   string  "The panel label, shows up in the panel header at the right of the triangle used to collapse the panel."
-#+ * Panel.bl_region_type -> bl_region_type:   enum  "The region where the panel is going to be used in."
-#+ * Panel.bl_show_header -> bl_show_header:   boolean  "If set to True, the panel shows a header, which contains a clickable arrow to collapse the panel and the label (see bl_label)."
-#+ * Panel.bl_space_type -> bl_space_type:   enum  "The space where the panel is going to be used in."
- + * Panel.bl_default_closed -> bl_use_closed:   boolean  "Defines if the panel has to be open or collapsed at the time of its creation. Note that once the panel has been created with bl_default_closed = True, at reload (F8) it stays open."
-#+ * Panel.layout -> layout:   pointer,  "(read-only)    Defines the structure of the panel in the UI."
-#TODO SHOULD THIS BE HERE * Panel.text -> text:   string  "XXX todo"
-#+ * Particle.alive_state -> alive_state:   enum  "NO DESCRIPTION"
-#+ * Particle.angular_velocity -> angular_velocity:   float[3]  "NO DESCRIPTION"
-#Particle.birth_time -> birth_time:   float  "NO DESCRIPTION"
-#+ * Particle.die_time -> die_time:   float  "NO DESCRIPTION"
-#Particle.is_exist -> is_exist:   boolean,  "(read-only)"
-#Particle.is_hair -> is_hair:   collection,  "(read-only)"
-#+ * Particle.is_visible -> is_visible:   boolean,  "(read-only)"
-#+ * Particle.keys -> keys:   collection,  "(read-only)"
-#+ * Particle.lifetime -> lifetime:   float  "NO DESCRIPTION"
-#+ * Particle.location -> location:   float[3]  "NO DESCRIPTION"
-#+ * Particle.prev_angular_velocity -> prev_angular_velocity:   float[3]  "NO DESCRIPTION"
-#+ * Particle.prev_location -> prev_location:   float[3]  "NO DESCRIPTION"
-#+ * Particle.prev_rotation -> prev_rotation:   float[4]  "NO DESCRIPTION"
-#+ * Particle.prev_velocity -> prev_velocity:   float[3]  "NO DESCRIPTION"
-#+ * Particle.rotation -> rotation:   float[4]  "NO DESCRIPTION"
-#+ * Particle.size -> size:   float  "NO DESCRIPTION"
-#+ * Particle.velocity -> velocity:   float[3]  "NO DESCRIPTION"
-#+ * ParticleBrush.count -> count:   int  "Particle count"
-#+ * ParticleBrush.curve -> curve:   pointer,  "(read-only)"
-#+ * ParticleBrush.length_mode -> length_mode:   enum  "NO DESCRIPTION"
-#+ * ParticleBrush.puff_mode -> puff_mode:   enum  "NO DESCRIPTION"
-#+ * ParticleBrush.size -> size:   int  "Brush size"
-#+ * ParticleBrush.steps -> steps:   int  "Brush steps"
-#+ * ParticleBrush.strength -> strength:   float  "Brush strength"
-#+ * ParticleBrush.use_puff_volume -> use_puff_volume:   boolean  "Apply puff to unselected end-points, (helps maintain hair volume when puffing root)"
-#+ * ParticleDupliWeight.count -> count:   int  "The number of times this object is repeated with respect to other objects"
-#+ * ParticleDupliWeight.name -> name:   string,  "(read-only)    Particle dupliobject&