Cleanup: comments causing bad clang-format output
authorCampbell Barton <ideasman42@gmail.com>
Mon, 7 Jan 2019 23:28:20 +0000 (10:28 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 7 Jan 2019 23:37:43 +0000 (10:37 +1100)
18 files changed:
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/particle_system.c
source/blender/blenlib/BLI_kdopbvh.h
source/blender/blenlib/BLI_voronoi_2d.h
source/blender/bmesh/tools/bmesh_decimate_collapse.c
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
source/blender/draw/engines/eevee/eevee_private.h
source/blender/draw/engines/workbench/workbench_private.h
source/blender/editors/armature/armature_intern.h
source/blender/editors/armature/pose_edit.c
source/blender/editors/armature/pose_lib.c
source/blender/editors/gpencil/annotate_paint.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/sculpt_paint/paint_image_proj.c
source/blender/editors/space_view3d/view3d_camera_control.c
source/blender/editors/transform/transform.h
source/blender/freestyle/intern/stroke/Stroke.h
source/blender/modifiers/intern/MOD_screw.c

index 42b187ec57fd4681fd7261e9ab89a7d7209466ff..8ce43049265d990f6bf0e9844d45e7b204da9c03 100644 (file)
@@ -1144,7 +1144,8 @@ static void copy_object_pose(Object *obn, const Object *ob, const int flag)
 {
        bPoseChannel *chan;
 
-       /* note: need to clear obn->pose pointer first, so that BKE_pose_copy_data works (otherwise there's a crash) */
+       /* note: need to clear obn->pose pointer first,
+        * so that BKE_pose_copy_data works (otherwise there's a crash) */
        obn->pose = NULL;
        BKE_pose_copy_data_ex(&obn->pose, ob->pose, flag, true);  /* true = copy constraints */
 
@@ -1626,7 +1627,8 @@ void BKE_object_make_proxy(Main *bmain, Object *ob, Object *target, Object *cob)
                ob->mat = MEM_dupallocN(target->mat);
                ob->matbits = MEM_dupallocN(target->matbits);
                for (i = 0; i < target->totcol; i++) {
-                       /* don't need to run test_object_materials since we know this object is new and not used elsewhere */
+                       /* don't need to run test_object_materials
+                        * since we know this object is new and not used elsewhere */
                        id_us_plus((ID *)ob->mat[i]);
                }
        }
@@ -2788,15 +2790,24 @@ void BKE_scene_foreach_display_point(
 /* copied from DNA_object_types.h */
 typedef struct ObTfmBack {
        float loc[3], dloc[3], orig[3];
-       float size[3], dscale[3];   /* scale and delta scale */
-       float rot[3], drot[3];      /* euler rotation */
-       float quat[4], dquat[4];    /* quaternion rotation */
-       float rotAxis[3], drotAxis[3];  /* axis angle rotation - axis part */
-       float rotAngle, drotAngle;  /* axis angle rotation - angle part */
-       float obmat[4][4];      /* final worldspace matrix with constraints & animsys applied */
-       float parentinv[4][4]; /* inverse result of parent, so that object doesn't 'stick' to parent */
-       float constinv[4][4]; /* inverse result of constraints. doesn't include effect of parent or object local transform */
-       float imat[4][4];   /* inverse matrix of 'obmat' for during render, temporally: ipokeys of transform  */
+       /** scale and delta scale. */
+       float size[3], dscale[3];
+       /** euler rotation. */
+       float rot[3], drot[3];
+       /** quaternion rotation. */
+       float quat[4], dquat[4];
+       /** axis angle rotation - axis part. */
+       float rotAxis[3], drotAxis[3];
+       /** axis angle rotation - angle part. */
+       float rotAngle, drotAngle;
+       /** final worldspace matrix with constraints & animsys applied. */
+       float obmat[4][4];
+       /** inverse result of parent, so that object doesn't 'stick' to parent. */
+       float parentinv[4][4];
+       /** inverse result of constraints. doesn't include effect of parent or object local transform. */
+       float constinv[4][4];
+       /** inverse matrix of 'obmat' for during render, temporally: ipokeys of transform. */
+       float imat[4][4];
 } ObTfmBack;
 
 void *BKE_object_tfm_backup(Object *ob)
index 8d09215c56498f8034d84b81ef54f741e5492f7d..86d2ceddced6fecc0a8020709930e7bd0da102b6 100644 (file)
@@ -1688,7 +1688,8 @@ static void sph_force_cb(void *sphdata_v, ParticleKey *state, float *force, floa
        /* 4.0 seems to be a pretty good value */
        float interaction_radius = fluid->radius * (fluid->flag & SPH_FAC_RADIUS ? 4.0f * pa->size : 1.0f);
        float h = interaction_radius * sphdata->hfac;
-       float rest_density = fluid->rest_density * (fluid->flag & SPH_FAC_DENSITY ? 4.77f : 1.f); /* 4.77 is an experimentally determined density factor */
+       /* 4.77 is an experimentally determined density factor */
+       float rest_density = fluid->rest_density * (fluid->flag & SPH_FAC_DENSITY ? 4.77f : 1.f);
        float rest_length = fluid->rest_length * (fluid->flag & SPH_FAC_REST_LENGTH ? 2.588f * pa->size : 1.f);
 
        float stiffness = fluid->stiffness_k;
@@ -2657,12 +2658,18 @@ static int collision_response(ParticleSimulationData *sim, ParticleData *pa, Par
        ParticleCollisionElement *pce = &col->pce;
        PartDeflect *pd = col->hit->pd;
        RNG *rng = sim->rng;
-       float co[3];                                                                            /* point of collision */
-       float x = hit->dist/col->original_ray_length;           /* location factor of collision between this iteration */
-       float f = col->f + x * (1.0f - col->f);                         /* time factor of collision between timestep */
-       float dt1 = (f - col->f) * col->total_time;                     /* time since previous collision (in seconds) */
-       float dt2 = (1.0f - f) * col->total_time;                       /* time left after collision (in seconds) */
-       int through = (BLI_rng_get_float(rng) < pd->pdef_perm) ? 1 : 0; /* did particle pass through the collision surface? */
+       /* point of collision */
+       float co[3];
+       /* location factor of collision between this iteration */
+       float x = hit->dist/col->original_ray_length;
+       /* time factor of collision between timestep */
+       float f = col->f + x * (1.0f - col->f);
+       /* time since previous collision (in seconds) */
+       float dt1 = (f - col->f) * col->total_time;
+       /* time left after collision (in seconds) */
+       float dt2 = (1.0f - f) * col->total_time;
+       /* did particle pass through the collision surface? */
+       int through = (BLI_rng_get_float(rng) < pd->pdef_perm) ? 1 : 0;
 
        /* calculate exact collision location */
        interp_v3_v3v3(co, col->co1, col->co2, x);
@@ -2682,10 +2689,14 @@ static int collision_response(ParticleSimulationData *sim, ParticleData *pa, Par
        }
        /* figure out velocity and other data after collision */
        else {
-               float v0[3];    /* velocity directly before collision to be modified into velocity directly after collision */
-               float v0_nor[3];/* normal component of v0 */
-               float v0_tan[3];/* tangential component of v0 */
-               float vc_tan[3];/* tangential component of collision surface velocity */
+               /* velocity directly before collision to be modified into velocity directly after collision */
+               float v0[3];
+               /* normal component of v0 */
+               float v0_nor[3];
+               /* tangential component of v0 */
+               float v0_tan[3];
+               /* tangential component of collision surface velocity */
+               float vc_tan[3];
                float v0_dot, vc_dot;
                float damp = pd->pdef_damp + pd->pdef_rdamp * 2 * (BLI_rng_get_float(rng) - 0.5f);
                float frict = pd->pdef_frict + pd->pdef_rfrict * 2 * (BLI_rng_get_float(rng) - 0.5f);
@@ -2728,7 +2739,8 @@ static int collision_response(ParticleSimulationData *sim, ParticleData *pa, Par
                                madd_v3_v3fl(v1_tan, vr_tan, -0.4);
                                mul_v3_fl(v1_tan, 1.0f/1.4f); /* 1/(1+0.4) */
 
-                               /* rolling friction is around 0.01 of sliding friction (could be made a parameter) */
+                               /* rolling friction is around 0.01 of sliding friction
+                                * (could be made a parameter) */
                                mul_v3_fl(v1_tan, 1.0f - 0.01f * frict);
 
                                /* surface_velocity is opposite to cm velocity */
@@ -3185,7 +3197,8 @@ static void do_hair_dynamics(ParticleSimulationData *sim)
                }
        }
 
-       realloc_roots = false; /* whether hair root info array has to be reallocated */
+       /* whether hair root info array has to be reallocated */
+       realloc_roots = false;
        if (psys->hair_in_mesh) {
                Mesh *mesh = psys->hair_in_mesh;
                if (totpoint != mesh->totvert || totedge != mesh->totedge) {
index e4203a01b17ccb5b7c88787aa8a4e938758c5e4e..d83de68169e903077dd051facd536ec3c2ac20b3 100644 (file)
@@ -61,27 +61,41 @@ typedef struct BVHTreeOverlap {
 } BVHTreeOverlap;
 
 typedef struct BVHTreeNearest {
-       int index;          /* the index of the nearest found (untouched if none is found within a dist radius from the given coordinates) */
-       float co[3];        /* nearest coordinates (untouched it none is found within a dist radius from the given coordinates) */
-       float no[3];        /* normal at nearest coordinates (untouched it none is found within a dist radius from the given coordinates) */
-       float dist_sq;      /* squared distance to search around */
+       /** The index of the nearest found
+        * (untouched if none is found within a dist radius from the given coordinates) */
+       int index;
+       /** Nearest coordinates
+        * (untouched it none is found within a dist radius from the given coordinates). */
+       float co[3];
+       /** Normal at nearest coordinates
+        * (untouched it none is found within a dist radius from the given coordinates). */
+       float no[3];
+       /** squared distance to search around */
+       float dist_sq;
        int flags;
 } BVHTreeNearest;
 
 typedef struct BVHTreeRay {
-       float origin[3];    /* ray origin */
-       float direction[3]; /* ray direction */
-       float radius;       /* radius around ray */
+       /** ray origin */
+       float origin[3];
+       /** ray direction */
+       float direction[3];
+       /** radius around ray */
+       float radius;
 #ifdef USE_KDOPBVH_WATERTIGHT
        struct IsectRayPrecalc *isect_precalc;
 #endif
 } BVHTreeRay;
 
 typedef struct BVHTreeRayHit {
-       int index;          /* index of the tree node (untouched if no hit is found) */
-       float co[3];        /* coordinates of the hit point */
-       float no[3];        /* normal on hit point */
-       float dist;         /* distance to the hit point */
+       /** Index of the tree node (untouched if no hit is found). */
+       int index;
+       /** Coordinates of the hit point. */
+       float co[3];
+       /** Normal on hit point. */
+       float no[3];
+       /** Distance to the hit point. */
+       float dist;
 } BVHTreeRayHit;
 
 enum {
index 8d1ff2d4c2b2c0a4eb82d79bd3ed97d7af68b021..7caba2b0692463bb0dd6d2fc83e6d7b520ba16fe 100644 (file)
@@ -40,18 +40,24 @@ typedef struct VoronoiSite {
 typedef struct VoronoiEdge {
        struct VoronoiEdge *next, *prev;
 
-       float start[2], end[2]; /* start and end points */
+       /* start and end points */
+       float start[2], end[2];
 
        /* this fields are used during diagram computation only */
 
-       float direction[2];             /* directional vector, from "start", points to "end", normal of |left, right| */
+       /* directional vector, from "start", points to "end", normal of |left, right| */
+       float direction[2];
 
-       float left[2];                  /* point on Voronoi place on the left side of edge */
-       float right[2];                 /* point on Voronoi place on the right side of edge */
+       /* point on Voronoi place on the left side of edge */
+       float left[2];
+       /* point on Voronoi place on the right side of edge */
+       float right[2];
 
-       float f, g;                             /* directional coeffitients satisfying equation y = f * x + g (edge lies on this line) */
+       /* directional coeffitients satisfying equation y = f * x + g (edge lies on this line) */
+       float f, g;
 
-       /* some edges consist of two parts, so we add the pointer to another part to connect them at the end of an algorithm */
+       /* some edges consist of two parts,
+        * so we add the pointer to another part to connect them at the end of an algorithm */
        struct VoronoiEdge *neighbor;
 } VoronoiEdge;
 
index 3c399f8fe7d9b8d0ebe9289c942ee093c1d1080e..47bd018736c20e3784cda83775769ceb664aecc2 100644 (file)
@@ -157,7 +157,8 @@ static void bm_decim_calc_target_co_db(
                &vquadrics[BM_elem_index_get(e->v2)]);
 
        if (BLI_quadric_optimize(&q, optimize_co, OPTIMIZE_EPS)) {
-               return;  /* all is good */
+               /* all is good */
+               return;
        }
        else {
                optimize_co[0] = 0.5 * ((double)e->v1->co[0] + (double)e->v2->co[0]);
@@ -194,9 +195,12 @@ static bool bm_edge_collapse_is_degenerate_flip(BMEdge *e, const float optimize_
                                float cross_optim[3];
 
 #if 1
-                               float vec_other[3];  /* line between the two outer verts, re-use for both cross products */
-                               float vec_exist[3];  /* before collapse */
-                               float vec_optim[3];  /* after collapse */
+                               /* line between the two outer verts, re-use for both cross products */
+                               float vec_other[3];
+                               /* before collapse */
+                               float vec_exist[3];
+                               /* after collapse */
+                               float vec_optim[3];
 
                                sub_v3_v3v3(vec_other, co_prev, co_next);
                                sub_v3_v3v3(vec_exist, co_prev, v->co);
@@ -369,7 +373,8 @@ static void bm_decim_build_edge_cost(
        uint i;
 
        BM_ITER_MESH_INDEX (e, &iter, bm, BM_EDGES_OF_MESH, i) {
-               eheap_table[i] = NULL;  /* keep sanity check happy */
+               /* keep sanity check happy */
+               eheap_table[i] = NULL;
                bm_decim_build_edge_cost_single(e, vquadrics, vweights, vweight_factor, eheap, eheap_table);
        }
 }
@@ -722,7 +727,8 @@ static void bm_edge_collapse_loop_customdata(
 
        BLI_assert(l_clear->v == v_clear);
        BLI_assert(l_other->v == v_other);
-       (void)v_other;  /* quiet warnings for release */
+       /* quiet warnings for release */
+       (void)v_other;
 
        /* now we have both corners of the face 'l->f' */
        for (side = 0; side < 2; side++) {
@@ -1147,7 +1153,8 @@ static bool bm_decim_edge_collapse(
        int e_clear_other[2];
        BMVert *v_other = e->v1;
        const int v_other_index = BM_elem_index_get(e->v1);
-       const int v_clear_index = BM_elem_index_get(e->v2);  /* the vert is removed so only store the index */
+       /* the vert is removed so only store the index */
+       const int v_clear_index = BM_elem_index_get(e->v2);
        float customdata_fac;
 
 #ifdef USE_VERT_NORMAL_INTERP
@@ -1159,7 +1166,8 @@ static bool bm_decim_edge_collapse(
        if (optimize_co_calc) {
                /* disallow collapsing which results in degenerate cases */
                if (UNLIKELY(bm_edge_collapse_is_degenerate_topology(e))) {
-                       bm_decim_invalid_edge_cost_single(e, eheap, eheap_table);  /* add back with a high cost */
+                       /* add back with a high cost */
+                       bm_decim_invalid_edge_cost_single(e, eheap, eheap_table);
                        return false;
                }
 
@@ -1167,7 +1175,8 @@ static bool bm_decim_edge_collapse(
 
                /* check if this would result in an overlapping face */
                if (UNLIKELY(bm_edge_collapse_is_degenerate_flip(e, optimize_co))) {
-                       bm_decim_invalid_edge_cost_single(e, eheap, eheap_table);  /* add back with a high cost */
+                       /* add back with a high cost */
+                       bm_decim_invalid_edge_cost_single(e, eheap, eheap_table);
                        return false;
                }
        }
@@ -1203,7 +1212,8 @@ static bool bm_decim_edge_collapse(
                        vweights[v_other_index] = v_other_weight;
                }
 
-               e = NULL;  /* paranoid safety check */
+               /* paranoid safety check */
+               e = NULL;
 
                copy_v3_v3(v_other->co, optimize_co);
 
@@ -1295,9 +1305,12 @@ void BM_mesh_decimate_collapse(
         const bool do_triangulate,
         const int symmetry_axis, const float symmetry_eps)
 {
-       Heap *eheap;             /* edge heap */
-       HeapNode **eheap_table;  /* edge index aligned table pointing to the eheap */
-       Quadric *vquadrics;      /* vert index aligned quadrics */
+       /* edge heap */
+       Heap *eheap;
+       /* edge index aligned table pointing to the eheap */
+       HeapNode **eheap_table;
+       /* vert index aligned quadrics */
+       Quadric *vquadrics;
        int tot_edge_orig;
        int face_tot_target;
 
@@ -1359,7 +1372,8 @@ void BM_mesh_decimate_collapse(
                        // const float value = BLI_heap_node_value(BLI_heap_top(eheap));
                        BMEdge *e = BLI_heap_pop_min(eheap);
                        float optimize_co[3];
-                       BLI_assert(BM_elem_index_get(e) < tot_edge_orig);  /* handy to detect corruptions elsewhere */
+                       /* handy to detect corruptions elsewhere */
+                       BLI_assert(BM_elem_index_get(e) < tot_edge_orig);
 
                        /* under normal conditions wont be accessed again,
                         * but NULL just incase so we don't use freed node */
@@ -1511,5 +1525,6 @@ invalidate:
        /* testing only */
        // BM_mesh_validate(bm);
 
-       (void)tot_edge_orig;  /* quiet release build warning */
+       /* quiet release build warning */
+       (void)tot_edge_orig;
 }
index fdfbd4679f387d5faf8918bda882ce87973857fc..0acd3e3307557d28f53f71b6e207b3c98a6a9b5f 100644 (file)
@@ -1194,7 +1194,8 @@ void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float
                        else {                               // "bleed out" buffer edge mode is turned on
                                do_adjacentBleedBorders(t, rw, limask, lomask, lres, res, rsize);
                        }
-                       isz = rsize[0];                      // set up inner edge, outer edge, and gradient buffer sizes after border pass
+                       // set up inner edge, outer edge, and gradient buffer sizes after border pass
+                       isz = rsize[0];
                        osz = rsize[1];
                        gsz = rsize[2];
                        // detect edges in all non-border pixels in the buffer
@@ -1207,24 +1208,31 @@ void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float
                        else {                               // "bleed out" buffer edge mode is turned on
                                do_allBleedBorders(t, rw, limask, lomask, lres, res, rsize);
                        }
-                       isz = rsize[0];                      // set up inner edge, outer edge, and gradient buffer sizes after border pass
+                       // set up inner edge, outer edge, and gradient buffer sizes after border pass
+                       isz = rsize[0];
                        osz = rsize[1];
                        gsz = rsize[2];
                        // detect edges in all non-border pixels in the buffer
                        do_allEdgeDetection(t, rw, limask, lomask, lres, res, rsize, isz, osz, gsz);
                }
 
-               isz = rsize[0];                          // set edge and gradient buffer sizes once again...
-               osz = rsize[1];                          // the sizes in rsize[] may have been modified
-               gsz = rsize[2];                          // by the do_*EdgeDetection() function.
+               // set edge and gradient buffer sizes once again...
+               // the sizes in rsize[] may have been modified
+               // by the do_*EdgeDetection() function.
+               isz = rsize[0];
+               osz = rsize[1];
+               gsz = rsize[2];
 
-               fsz = gsz + isz + osz;                                   // calculate size of pixel index buffer needed
-               gbuf = (unsigned short *)MEM_callocN(sizeof(unsigned short) * fsz * 2, "DEM"); // allocate edge/gradient pixel index buffer
+               // calculate size of pixel index buffer needed
+               fsz = gsz + isz + osz;
+               // allocate edge/gradient pixel index buffer
+               gbuf = (unsigned short *)MEM_callocN(sizeof(unsigned short) * fsz * 2, "DEM");
 
                do_createEdgeLocationBuffer(t, rw, lres, res, gbuf, &innerEdgeOffset, &outerEdgeOffset, isz, gsz);
                do_fillGradientBuffer(rw, res, gbuf, isz, osz, gsz, innerEdgeOffset, outerEdgeOffset);
 
-               MEM_freeN(gbuf);                         // free the gradient index buffer
+               // free the gradient index buffer
+               MEM_freeN(gbuf);
        }
 }
 
index 9fc0a304c0b157f3b5c046970e129a7d281a63f8..f7578182c159e7ea3d15a83117089e460712e8ac 100644 (file)
@@ -372,7 +372,8 @@ typedef struct EEVEE_ShadowCube {
 } EEVEE_ShadowCube;
 
 typedef struct EEVEE_ShadowCascade {
-       float shadowmat[MAX_CASCADE_NUM][4][4]; /* World->Lamp->NDC->Tex : used for sampling the shadow map. */
+       /* World->Lamp->NDC->Tex : used for sampling the shadow map. */
+       float shadowmat[MAX_CASCADE_NUM][4][4];
        float split_start[4];
        float split_end[4];
 } EEVEE_ShadowCascade;
@@ -729,7 +730,8 @@ typedef struct EEVEE_ShadowCubeData {
 
 typedef struct EEVEE_ShadowCascadeData {
        short light_id, shadow_id, cascade_id, layer_id;
-       float viewprojmat[MAX_CASCADE_NUM][4][4]; /* World->Lamp->NDC : used for rendering the shadow map. */
+       /* World->Lamp->NDC : used for rendering the shadow map. */
+       float viewprojmat[MAX_CASCADE_NUM][4][4];
        float projmat[MAX_CASCADE_NUM][4][4];
        float viewmat[4][4], viewinv[4][4];
        float radius[MAX_CASCADE_NUM];
index a4dbd9a931e8ff7bd4ea168661ecd6ee349e4b12..832f755b612ba09cf458029834181dce0169cc7e 100644 (file)
@@ -188,11 +188,15 @@ typedef struct WORKBENCH_PrivateData {
        float cached_shadow_direction[3];
        float shadow_mat[4][4];
        float shadow_inv[4][4];
-       float shadow_far_plane[4]; /* Far plane of the view frustum. */
-       float shadow_near_corners[4][3]; /* Near plane corners in shadow space. */
-       float shadow_near_min[3]; /* min and max of shadow_near_corners. allow fast test */
+       /* Far plane of the view frustum. */
+       float shadow_far_plane[4];
+       /* Near plane corners in shadow space. */
+       float shadow_near_corners[4][3];
+       /* min and max of shadow_near_corners. allow fast test */
+       float shadow_near_min[3];
        float shadow_near_max[3];
-       float shadow_near_sides[2][4]; /* This is a parallelogram, so only 2 normal and distance to the edges. */
+       /* This is a parallelogram, so only 2 normal and distance to the edges. */
+       float shadow_near_sides[2][4];
        bool shadow_changed;
        bool is_playback;
 
@@ -243,7 +247,8 @@ typedef struct WORKBENCH_ObjectData {
 
        /* Shadow direction in local object space. */
        float shadow_dir[3], shadow_depth;
-       float shadow_min[3], shadow_max[3]; /* Min, max in shadow space */
+       /* Min, max in shadow space */
+       float shadow_min[3], shadow_max[3];
        BoundBox shadow_bbox;
        bool shadow_bbox_dirty;
 
index da24787fc180c1b2b5a3c42c827cd2ab9b3da991..0f4fc4832b822c4dd92fbb47b96c03d5ebc0a248 100644 (file)
@@ -147,27 +147,35 @@ void POSE_OT_bone_layers(struct wmOperatorType *ot);
 typedef struct tPChanFCurveLink {
        struct tPChanFCurveLink *next, *prev;
 
-       struct Object *ob;              /* Object this Pose Channel belongs to. */
+       /** Object this Pose Channel belongs to. */
+       struct Object *ob;
 
-       ListBase fcurves;               /* F-Curves for this PoseChannel (wrapped with LinkData) */
-       struct bPoseChannel *pchan;     /* Pose Channel which data is attached to */
+       /** F-Curves for this PoseChannel (wrapped with LinkData) */
+       ListBase fcurves;
+       /** Pose Channel which data is attached to */
+       struct bPoseChannel *pchan;
 
-       char *pchan_path;               /* RNA Path to this Pose Channel (needs to be freed when we're done) */
+       /** RNA Path to this Pose Channel (needs to be freed when we're done) */
+       char *pchan_path;
 
-       float oldloc[3];                /* transform values at start of operator (to be restored before each modal step) */
+       /** transform values at start of operator (to be restored before each modal step) */
+       float oldloc[3];
        float oldrot[3];
        float oldscale[3];
        float oldquat[4];
        float oldangle;
        float oldaxis[3];
 
-       float roll1, roll2;             /* old bbone values (to be restored along with the transform properties) */
-       float curveInX, curveInY;       /* (NOTE: we haven't renamed these this time, as their names are already long enough) */
+       /** old bbone values (to be restored along with the transform properties) */
+       float roll1, roll2;
+       /** (NOTE: we haven't renamed these this time, as their names are already long enough) */
+       float curveInX, curveInY;
        float curveOutX, curveOutY;
        float ease1, ease2;
        float scaleIn, scaleOut;
 
-       struct IDProperty *oldprops;    /* copy of custom properties at start of operator (to be restored before each modal step) */
+       /** copy of custom properties at start of operator (to be restored before each modal step) */
+       struct IDProperty *oldprops;
 } tPChanFCurveLink;
 
 /* ----------- */
index 4b069deefa380adcce9999349725981c2929af43..4014d7e972890c697897be0536e940b37165cc1a 100644 (file)
@@ -926,7 +926,8 @@ static int pose_armature_layers_showall_exec(bContext *C, wmOperator *op)
        bArmature *arm = armature_layers_get_data(&ob);
        PointerRNA ptr;
        int maxLayers = (RNA_boolean_get(op->ptr, "all")) ? 32 : 16;
-       bool layers[32] = {false}; /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       bool layers[32] = {false};
        int i;
 
        /* sanity checking */
@@ -978,7 +979,8 @@ static int armature_layers_invoke(bContext *C, wmOperator *op, const wmEvent *ev
        Object *ob = CTX_data_active_object(C);
        bArmature *arm = armature_layers_get_data(&ob);
        PointerRNA ptr;
-       bool layers[32]; /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       bool layers[32];
 
        /* sanity checking */
        if (arm == NULL)
@@ -999,7 +1001,8 @@ static int armature_layers_exec(bContext *C, wmOperator *op)
        Object *ob = CTX_data_active_object(C);
        bArmature *arm = armature_layers_get_data(&ob);
        PointerRNA ptr;
-       bool layers[32]; /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       bool layers[32];
 
        if (arm == NULL) {
                return OPERATOR_CANCELLED;
@@ -1043,7 +1046,8 @@ void ARMATURE_OT_armature_layers(wmOperatorType *ot)
 /* Present a popup to get the layers that should be used */
 static int pose_bone_layers_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 {
-       bool layers[32] = {0}; /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       bool layers[32] = {0};
 
        /* get layers that are active already */
        CTX_DATA_BEGIN (C, bPoseChannel *, pchan, selected_pose_bones)
@@ -1068,7 +1072,8 @@ static int pose_bone_layers_invoke(bContext *C, wmOperator *op, const wmEvent *e
 static int pose_bone_layers_exec(bContext *C, wmOperator *op)
 {
        PointerRNA ptr;
-       bool layers[32]; /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       bool layers[32];
 
        /* get the values set in the operator properties */
        RNA_boolean_get_array(op->ptr, "layers", layers);
@@ -1117,7 +1122,8 @@ void POSE_OT_bone_layers(wmOperatorType *ot)
 /* Present a popup to get the layers that should be used */
 static int armature_bone_layers_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 {
-       bool layers[32] = {0}; /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       bool layers[32] = {0};
 
        /* get layers that are active already */
        CTX_DATA_BEGIN (C, EditBone *, ebone, selected_editable_bones)
@@ -1145,7 +1151,8 @@ static int armature_bone_layers_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
        PointerRNA ptr;
-       bool layers[32]; /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
+       bool layers[32];
 
        /* get the values set in the operator properties */
        RNA_boolean_get_array(op->ptr, "layers", layers);
index 14706f8960714ee4d413dec7bc3884f6d0f887d9..c8ce0774208c0f431781d800f2fc2f5ad61bbeb6 100644 (file)
@@ -825,30 +825,49 @@ void POSELIB_OT_pose_move(wmOperatorType *ot)
 
 /* Simple struct for storing settings/data for use during PoseLib preview */
 typedef struct tPoseLib_PreviewData {
-       ListBase backups;       /* tPoseLib_Backup structs for restoring poses */
-       ListBase searchp;       /* LinkData structs storing list of poses which match the current search-string */
-
-       Scene *scene;           /* active scene */
-       ScrArea *sa;            /* active area */
-
-       PointerRNA rna_ptr;     /* RNA-Pointer to Object 'ob' */
-       Object *ob;             /* object to work on */
-       bArmature *arm;         /* object's armature data */
-       bPose *pose;            /* object's pose */
-       bAction *act;           /* poselib to use */
-       TimeMarker *marker;     /* 'active' pose */
-
-       int totcount;           /* total number of elements to work on */
-
-       short state;            /* state of main loop */
-       short redraw;           /* redraw/update settings during main loop */
-       short flag;             /* flags for various settings */
+       /** tPoseLib_Backup structs for restoring poses. */
+       ListBase backups;
+       /** LinkData structs storing list of poses which match the current search-string. */
+       ListBase searchp;
+
+       /** active scene. */
+       Scene *scene;
+       /** active area. */
+       ScrArea *sa;
 
-       short search_cursor;    /* position of cursor in searchstr (cursor occurs before the item at the nominated index) */
-       char searchstr[64];     /* (Part of) Name to search for to filter poses that get shown */
-       char searchold[64];     /* Previously set searchstr (from last loop run), so that we can detected when to rebuild searchp */
+       /** RNA-Pointer to Object 'ob' .*/
+       PointerRNA rna_ptr;
+       /** object to work on. */
+       Object *ob;
+       /** object's armature data. */
+       bArmature *arm;
+       /** object's pose. */
+       bPose *pose;
+       /** poselib to use. */
+       bAction *act;
+       /** 'active' pose. */
+       TimeMarker *marker;
 
-       char headerstr[UI_MAX_DRAW_STR];    /* Info-text to print in header */
+       /** total number of elements to work on. */
+       int totcount;
+
+       /** state of main loop. */
+       short state;
+       /** redraw/update settings during main loop. */
+       short redraw;
+       /** flags for various settings. */
+       short flag;
+
+       /** position of cursor in searchstr (cursor occurs before the item at the nominated index) */
+       short search_cursor;
+       /** (Part of) Name to search for to filter poses that get shown. */
+       char searchstr[64];
+       /** Previously set searchstr (from last loop run),
+        * so that we can detected when to rebuild searchp. */
+       char searchold[64];
+
+       /** Info-text to print in header. */
+       char headerstr[UI_MAX_DRAW_STR];
 } tPoseLib_PreviewData;
 
 /* defines for tPoseLib_PreviewData->state values */
index b6f81c818239983f98385e369572453f23c0d07b..c6f88287e3efc18821ec6571c3fa175e11509115 100644 (file)
@@ -116,56 +116,84 @@ typedef enum eGPencil_PaintFlags {
  */
 typedef struct tGPsdata {
        Main *bmain;
-       Scene *scene;       /* current scene from context */
+       /** current scene from context. */
+       Scene *scene;
        struct Depsgraph *depsgraph;
 
-       wmWindow *win;      /* window where painting originated */
-       ScrArea *sa;        /* area where painting originated */
-       ARegion *ar;        /* region where painting originated */
-       View2D *v2d;        /* needed for GP_STROKE_2DSPACE */
-       rctf *subrect;      /* for using the camera rect within the 3d view */
+       /** window where painting originated. */
+       wmWindow *win;
+       /** area where painting originated. */
+       ScrArea *sa;
+       /** region where painting originated. */
+       ARegion *ar;
+       /** needed for GP_STROKE_2DSPACE. */
+       View2D *v2d;
+       /** for using the camera rect within the 3d view. */
+       rctf *subrect;
        rctf subrect_data;
 
-       GP_SpaceConversion gsc; /* settings to pass to gp_points_to_xy() */
-
-       PointerRNA ownerPtr; /* pointer to owner of gp-datablock */
-       bGPdata *gpd;       /* gp-datablock layer comes from */
-       bGPDlayer *gpl;     /* layer we're working on */
-       bGPDframe *gpf;     /* frame we're working on */
-
-       char *align_flag;   /* projection-mode flags (toolsettings - eGPencil_Placement_Flags) */
-
-       eGPencil_PaintStatus status;     /* current status of painting */
-       eGPencil_PaintModes  paintmode;  /* mode for painting */
-       eGPencil_PaintFlags  flags;      /* flags that can get set during runtime (eGPencil_PaintFlags) */
-
-       short radius;       /* radius of influence for eraser */
-
-       float mval[2];        /* current mouse-position */
-       float mvalo[2];       /* previous recorded mouse-position */
-
-       float pressure;     /* current stylus pressure */
-       float opressure;    /* previous stylus pressure */
+       /** settings to pass to gp_points_to_xy(). */
+       GP_SpaceConversion gsc;
+
+       /** pointer to owner of gp-datablock. */
+       PointerRNA ownerPtr;
+       /** gp-datablock layer comes from. */
+       bGPdata *gpd;
+       /** layer we're working on. */
+       bGPDlayer *gpl;
+       /** frame we're working on. */
+       bGPDframe *gpf;
+
+       /** projection-mode flags (toolsettings - eGPencil_Placement_Flags) */
+       char *align_flag;
+
+       /** current status of painting. */
+       eGPencil_PaintStatus status;
+       /** mode for painting. */
+       eGPencil_PaintModes  paintmode;
+       /** flags that can get set during runtime (eGPencil_PaintFlags) */
+       eGPencil_PaintFlags  flags;
+
+       /** radius of influence for eraser. */
+       short radius;
+
+       /** current mouse-position. */
+       float mval[2];
+       /** previous recorded mouse-position. */
+       float mvalo[2];
+
+       /** current stylus pressure. */
+       float pressure;
+       /** previous stylus pressure. */
+       float opressure;
 
        /* These need to be doubles, as (at least under unix) they are in seconds since epoch,
         * float (and its 7 digits precision) is definitively not enough here!
         * double, with its 15 digits precision, ensures us millisecond precision for a few centuries at least.
         */
-       double inittime;    /* Used when converting to path */
-       double curtime;     /* Used when converting to path */
-       double ocurtime;    /* Used when converting to path */
-
-       float imat[4][4];   /* inverted transformation matrix applying when converting coords from screen-space
-                            * to region space */
+       /** Used when converting to path. */
+       double inittime;
+       /** Used when converting to path. */
+       double curtime;
+       /** Used when converting to path. */
+       double ocurtime;
+
+       /** Inverted transformation matrix applying when converting coords from screen-space
+        * to region space. */
+       float imat[4][4];
        float mat[4][4];
 
-       float custom_color[4]; /* custom color - hack for enforcing a particular color for track/mask editing */
+       /** custom color - hack for enforcing a particular color for track/mask editing. */
+       float custom_color[4];
 
-       void *erasercursor; /* radial cursor data for drawing eraser */
+       /** radial cursor data for drawing eraser. */
+       void *erasercursor;
 
-       short straight[2];   /* 1: line horizontal, 2: line vertical, other: not defined, second element position */
+       /** 1: line horizontal, 2: line vertical, other: not defined, second element position. */
+       short straight[2];
 
-       short keymodifier;   /* key used for invoking the operator */
+       /** key used for invoking the operator. */
+       short keymodifier;
 } tGPsdata;
 
 /* ------ */
@@ -348,7 +376,8 @@ static short gp_stroke_addpoint(
 
                        /* store settings */
                        copy_v2_v2(&pt->x, mval);
-                       pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */
+                       /* T44932 - Pressure vals are unreliable, so ignore for now */
+                       pt->pressure = 1.0f;
                        pt->strength = 1.0f;
                        pt->time = (float)(curtime - p->inittime);
 
@@ -363,7 +392,8 @@ static short gp_stroke_addpoint(
 
                        /* store settings */
                        copy_v2_v2(&pt->x, mval);
-                       pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */
+                       /* T44932 - Pressure vals are unreliable, so ignore for now */
+                       pt->pressure = 1.0f;
                        pt->strength = 1.0f;
                        pt->time = (float)(curtime - p->inittime);
 
@@ -385,7 +415,8 @@ static short gp_stroke_addpoint(
                /* store settings */
                copy_v2_v2(&pt->x, mval);
                pt->pressure = pressure;
-               pt->strength = 1.0f;  /* unused for annotations, but initialise for easier conversions to GP Object */
+               /* unused for annotations, but initialise for easier conversions to GP Object */
+               pt->strength = 1.0f;
 
                /* point time */
                pt->time = (float)(curtime - p->inittime);
@@ -405,7 +436,8 @@ static short gp_stroke_addpoint(
 
                /* store settings */
                copy_v2_v2(&pt->x, mval);
-               pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */
+               /* T44932 - Pressure vals are unreliable, so ignore for now */
+               pt->pressure = 1.0f;
                pt->strength = 1.0f;
                pt->time = (float)(curtime - p->inittime);
 
@@ -1297,7 +1329,8 @@ static void gp_paint_initstroke(tGPsdata *p, eGPencil_PaintModes paintmode, Deps
 
                        /* for camera view set the subrect */
                        if (rv3d->persp == RV3D_CAMOB) {
-                               ED_view3d_calc_camera_border(p->scene, depsgraph, p->ar, v3d, rv3d, &p->subrect_data, true); /* no shift */
+                               /* no shift */
+                               ED_view3d_calc_camera_border(p->scene, depsgraph, p->ar, v3d, rv3d, &p->subrect_data, true);
                                p->subrect = &p->subrect_data;
                        }
                }
@@ -1689,7 +1722,8 @@ static void gpencil_draw_apply_event(wmOperator *op, const wmEvent *event, Depsg
        int tablet = 0;
 
        /* convert from window-space to area-space mouse coordinates
-        * NOTE: float to ints conversions, +1 factor is probably used to ensure a bit more accurate rounding...
+        * NOTE: float to ints conversions,
+        * +1 factor is probably used to ensure a bit more accurate rounding...
         */
        p->mval[0] = event->mval[0] + 1;
        p->mval[1] = event->mval[1] + 1;
@@ -1789,7 +1823,8 @@ static void gpencil_draw_apply_event(wmOperator *op, const wmEvent *event, Depsg
        gpencil_draw_apply(op, p, depsgraph);
 
        /* force refresh */
-       ED_region_tag_redraw(p->ar); /* just active area for now, since doing whole screen is too slow */
+       /* just active area for now, since doing whole screen is too slow */
+       ED_region_tag_redraw(p->ar);
 }
 
 /* ------------------------------- */
@@ -2006,7 +2041,8 @@ static void gpencil_stroke_end(wmOperator *op)
 static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
 {
        tGPsdata *p = op->customdata;
-       int estate = OPERATOR_PASS_THROUGH; /* default exit state - pass through to support MMB view nav, etc. */
+       /* default exit state - pass through to support MMB view nav, etc. */
+       int estate = OPERATOR_PASS_THROUGH;
 
        /* if (event->type == NDOF_MOTION)
         *    return OPERATOR_PASS_THROUGH;
@@ -2249,7 +2285,8 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
                        }
 
                        /* force refresh */
-                       ED_region_tag_redraw(p->ar); /* just active area for now, since doing whole screen is too slow */
+                       /* just active area for now, since doing whole screen is too slow */
+                       ED_region_tag_redraw(p->ar);
 
                        /* event handled, so just tag as running modal */
                        estate = OPERATOR_RUNNING_MODAL;
@@ -2269,7 +2306,8 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
        else {
                /* update status indicators - cursor, header, etc. */
                gpencil_draw_status_indicators(C, p);
-               gpencil_draw_cursor_set(p); /* cursor may have changed outside our control - T44084 */
+               /* cursor may have changed outside our control - T44084 */
+               gpencil_draw_cursor_set(p);
        }
 
        /* process last operations before exiting */
index 204d6fe267ae4ea965a60352b628e87571d69c0a..6543a65f67f2d5c39bbcc90bc2ef2013a3fa84ae 100644 (file)
@@ -128,70 +128,107 @@ typedef enum eGPencil_PaintFlags {
 typedef struct tGPsdata {
        bContext *C;
 
-       Main *bmain;        /* main database pointer */
-       Scene *scene;       /* current scene from context */
+       /** main database pointer. */
+       Main *bmain;
+       /** current scene from context. */
+       Scene *scene;
        struct Depsgraph *depsgraph;
 
-       Object *ob;         /* current object */
-       wmWindow *win;      /* window where painting originated */
-       ScrArea *sa;        /* area where painting originated */
-       ARegion *ar;        /* region where painting originated */
-       View2D *v2d;        /* needed for GP_STROKE_2DSPACE */
-       rctf *subrect;      /* for using the camera rect within the 3d view */
+       /** current object. */
+       Object *ob;
+       /** window where painting originated. */
+       wmWindow *win;
+       /** area where painting originated. */
+       ScrArea *sa;
+       /** region where painting originated. */
+       ARegion *ar;
+       /** needed for GP_STROKE_2DSPACE. */
+       View2D *v2d;
+       /** for using the camera rect within the 3d view. */
+       rctf *subrect;
        rctf subrect_data;
 
-       GP_SpaceConversion gsc; /* settings to pass to gp_points_to_xy() */
+       /** settings to pass to gp_points_to_xy(). */
+       GP_SpaceConversion gsc;
 
-       PointerRNA ownerPtr; /* pointer to owner of gp-datablock */
-       bGPdata *gpd;       /* gp-datablock layer comes from */
-       bGPDlayer *gpl;     /* layer we're working on */
-       bGPDframe *gpf;     /* frame we're working on */
+       /** pointer to owner of gp-datablock. */
+       PointerRNA ownerPtr;
+       /** gp-datablock layer comes from. */
+       bGPdata *gpd;
+       /** layer we're working on. */
+       bGPDlayer *gpl;
+       /** frame we're working on. */
+       bGPDframe *gpf;
 
-       char *align_flag;   /* projection-mode flags (toolsettings - eGPencil_Placement_Flags) */
+       /** projection-mode flags (toolsettings - eGPencil_Placement_Flags) */
+       char *align_flag;
 
-       eGPencil_PaintStatus status;     /* current status of painting */
-       eGPencil_PaintModes  paintmode;  /* mode for painting */
-       eGPencil_PaintFlags  flags;      /* flags that can get set during runtime (eGPencil_PaintFlags) */
+       /** current status of painting. */
+       eGPencil_PaintStatus status;
+       /** mode for painting. */
+       eGPencil_PaintModes  paintmode;
+       /** flags that can get set during runtime (eGPencil_PaintFlags) */
+       eGPencil_PaintFlags  flags;
 
-       short radius;       /* radius of influence for eraser */
+       /** radius of influence for eraser. */
+       short radius;
 
-       float mval[2];        /* current mouse-position */
-       float mvalo[2];       /* previous recorded mouse-position */
+       /** current mouse-position. */
+       float mval[2];
+       /** previous recorded mouse-position. */
+       float mvalo[2];
 
-       float pressure;     /* current stylus pressure */
-       float opressure;    /* previous stylus pressure */
+       /** current stylus pressure. */
+       float pressure;
+       /** previous stylus pressure. */
+       float opressure;
 
        /* These need to be doubles, as (at least under unix) they are in seconds since epoch,
         * float (and its 7 digits precision) is definitively not enough here!
         * double, with its 15 digits precision, ensures us millisecond precision for a few centuries at least.
         */
-       double inittime;    /* Used when converting to path */
-       double curtime;     /* Used when converting to path */
-       double ocurtime;    /* Used when converting to path */
-
-       float imat[4][4];   /* inverted transformation matrix applying when converting coords from screen-space
-                                                * to region space */
+       /** Used when converting to path. */
+       double inittime;
+       /** Used when converting to path. */
+       double curtime;
+       /** Used when converting to path. */
+       double ocurtime;
+
+       /** Inverted transformation matrix applying when converting coords from screen-space
+        * to region space. */
+       float imat[4][4];
        float mat[4][4];
 
-       float custom_color[4]; /* custom color - hack for enforcing a particular color for track/mask editing */
+       /** custom color - hack for enforcing a particular color for track/mask editing. */
+       float custom_color[4];
 
-       void *erasercursor; /* radial cursor data for drawing eraser */
+       /** radial cursor data for drawing eraser. */
+       void *erasercursor;
 
        /* mat settings are only used for 3D view */
-       Material *material;   /* current material */
-
-       Brush *brush;    /* current drawing brush */
-       Brush *eraser;   /* default eraser brush */
-       short straight[2];   /* 1: line horizontal, 2: line vertical, other: not defined, second element position */
-       int lock_axis;       /* lock drawing to one axis */
-       bool disable_fill;   /* the stroke is no fill mode */
+       /** current material. */
+       Material *material;
+
+       /** current drawing brush. */
+       Brush *brush;
+       /** default eraser brush. */
+       Brush *eraser;
+       /** 1: line horizontal, 2: line vertical, other: not defined, second element position. */
+       short straight[2];
+       /** lock drawing to one axis. */
+       int lock_axis;
+       /** the stroke is no fill mode. */
+       bool disable_fill;
 
        RNG *rng;
 
-       short keymodifier;   /* key used for invoking the operator */
-       short shift;         /* shift modifier flag */
+       /** key used for invoking the operator. */
+       short keymodifier;
+       /** shift modifier flag. */
+       short shift;
 
-       float totpixlen;     /* size in pixels for uv calculation */
+       /** size in pixels for uv calculation. */
+       float totpixlen;
 
        ReportList *reports;
 } tGPsdata;
@@ -430,7 +467,8 @@ static void gp_brush_jitter(
                float curvef = curvemapping_evaluateF(brush->gpencil_settings->curve_jitter, 0, pressure);
                tmp_pressure = curvef * brush->gpencil_settings->draw_sensitivity;
        }
-       const float exfactor = (brush->gpencil_settings->draw_jitter + 2.0f) * (brush->gpencil_settings->draw_jitter + 2.0f); /* exponential value */
+       /* exponential value */
+       const float exfactor = (brush->gpencil_settings->draw_jitter + 2.0f) * (brush->gpencil_settings->draw_jitter + 2.0f);
        const float fac = BLI_rng_get_float(rng) * exfactor * tmp_pressure;
        /* Jitter is applied perpendicular to the mouse movement vector (2D space) */
        float mvec[2], svec[2];
@@ -468,8 +506,10 @@ static void gp_brush_angle(bGPdata *gpd, Brush *brush, tGPspoint *pt, const floa
        float fac;
        float mpressure;
 
-       float angle = brush->gpencil_settings->draw_angle; /* default angle of brush in radians */;
-       float v0[2] = { cos(angle), sin(angle) }; /* angle vector of the brush with full thickness */
+       /* default angle of brush in radians */;
+       float angle = brush->gpencil_settings->draw_angle;
+       /* angle vector of the brush with full thickness */
+       float v0[2] = { cos(angle), sin(angle) };
 
        /* Apply to first point (only if there are 2 points because before no data to do it ) */
        if (gpd->runtime.sbuffer_size == 1) {
@@ -582,7 +622,8 @@ static short gp_stroke_addpoint(
 
                        /* store settings */
                        copy_v2_v2(&pt->x, mval);
-                       pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */
+                       /* T44932 - Pressure vals are unreliable, so ignore for now */
+                       pt->pressure = 1.0f;
                        pt->strength = 1.0f;
                        pt->time = (float)(curtime - p->inittime);
 
@@ -597,7 +638,8 @@ static short gp_stroke_addpoint(
 
                        /* store settings */
                        copy_v2_v2(&pt->x, mval);
-                       pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */
+                       /* T44932 - Pressure vals are unreliable, so ignore for now */
+                       pt->pressure = 1.0f;
                        pt->strength = 1.0f;
                        pt->time = (float)(curtime - p->inittime);
 
@@ -754,7 +796,8 @@ static short gp_stroke_addpoint(
 
                /* store settings */
                copy_v2_v2(&pt->x, mval);
-               pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */
+               /* T44932 - Pressure vals are unreliable, so ignore for now */
+               pt->pressure = 1.0f;
                pt->strength = 1.0f;
                pt->time = (float)(curtime - p->inittime);
 
@@ -2121,7 +2164,8 @@ static void gp_paint_initstroke(tGPsdata *p, eGPencil_PaintModes paintmode, Deps
 
                        /* for camera view set the subrect */
                        if (rv3d->persp == RV3D_CAMOB) {
-                               ED_view3d_calc_camera_border(p->scene, depsgraph, p->ar, v3d, rv3d, &p->subrect_data, true); /* no shift */
+                               /* no shift */
+                               ED_view3d_calc_camera_border(p->scene, depsgraph, p->ar, v3d, rv3d, &p->subrect_data, true);
                                p->subrect = &p->subrect_data;
                        }
                }
@@ -2979,7 +3023,8 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
 {
        tGPsdata *p = op->customdata;
        ToolSettings *ts = CTX_data_tool_settings(C);
-       int estate = OPERATOR_PASS_THROUGH; /* default exit state - pass through to support MMB view nav, etc. */
+       /* default exit state - pass through to support MMB view nav, etc. */
+       int estate = OPERATOR_PASS_THROUGH;
 
        /* if (event->type == NDOF_MOTION)
         *    return OPERATOR_PASS_THROUGH;
@@ -3254,7 +3299,8 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
                        }
 
                        /* force refresh */
-                       ED_region_tag_redraw(p->ar); /* just active area for now, since doing whole screen is too slow */
+                       /* just active area for now, since doing whole screen is too slow */
+                       ED_region_tag_redraw(p->ar);
 
                        /* event handled, so just tag as running modal */
                        estate = OPERATOR_RUNNING_MODAL;
index e366246efbc166ddad56e2828d483c783aa9bc77..1285616e6a21d3fdb038bdf6199bd0b096c4c8fd 100644 (file)
@@ -188,17 +188,20 @@ BLI_INLINE unsigned char f_to_char(const float val)
 /* to avoid locking in tile initialization */
 #define TILE_PENDING POINTER_FROM_INT(-1)
 
-/* This is mainly a convenience struct used so we can keep an array of images we use -
+/** This is mainly a convenience struct used so we can keep an array of images we use -
  * their imbufs, etc, in 1 array, When using threads this array is copied for each thread
  * because 'partRedrawRect' and 'touch' values would not be thread safe */
 typedef struct ProjPaintImage {
        Image *ima;
        ImBuf *ibuf;
        ImagePaintPartialRedraw *partRedrawRect;
-       volatile void **undoRect; /* only used to build undo tiles during painting */
-       unsigned short **maskRect; /* the mask accumulation must happen on canvas, not on space screen bucket.
-                                   * Here we store the mask rectangle */
-       bool **valid; /* store flag to enforce validation of undo rectangle */
+       /** Only used to build undo tiles during painting. */
+       volatile void **undoRect;
+       /** The mask accumulation must happen on canvas, not on space screen bucket.
+        * Here we store the mask rectangle. */
+       unsigned short **maskRect;
+       /** Store flag to enforce validation of undo rectangle. */
+       bool **valid;
        bool touch;
 } ProjPaintImage;
 
@@ -232,7 +235,8 @@ typedef struct ProjPaintState {
        ARegion *ar;
        Depsgraph *depsgraph;
        Scene *scene;
-       int source; /* PROJ_SRC_**** */
+       /* PROJ_SRC_**** */
+       int source;
 
        /* the paint color. It can change depending of inverted mode or not */
        float paint_color[3];
@@ -255,25 +259,37 @@ typedef struct ProjPaintState {
        float stencil_value;
 
        /* projection painting only */
-       MemArena *arena_mt[BLENDER_MAX_THREADS]; /* for multithreading, the first item is sometimes used for non threaded cases too */
-       LinkNode **bucketRect;              /* screen sized 2D array, each pixel has a linked list of ProjPixel's */
-       LinkNode **bucketFaces;             /* bucketRect aligned array linkList of faces overlapping each bucket */
-       unsigned char *bucketFlags;         /* store if the bucks have been initialized  */
-
-       char *vertFlags;                    /* store options per vert, now only store if the vert is pointing away from the view */
-       int buckets_x;                      /* The size of the bucket grid, the grid span's screenMin/screenMax so you can paint outsize the screen or with 2 brushes at once */
+       /** for multithreading, the first item is sometimes used for non threaded cases too. */
+       MemArena *arena_mt[BLENDER_MAX_THREADS];
+       /** screen sized 2D array, each pixel has a linked list of ProjPixel's */
+       LinkNode **bucketRect;
+       /** bucketRect aligned array linkList of faces overlapping each bucket. */
+       LinkNode **bucketFaces;
+       /** store if the bucks have been initialized. */
+       unsigned char *bucketFlags;
+
+       /** store options per vert, now only store if the vert is pointing away from the view. */
+       char *vertFlags;
+       /** The size of the bucket grid, the grid span's screenMin/screenMax so you can paint outsize the screen or with 2 brushes at once. */
+       int buckets_x;
        int buckets_y;
 
-       int pixel_sizeof;           /* result of project_paint_pixel_sizeof(), constant per stroke */
+       /** result of project_paint_pixel_sizeof(), constant per stroke. */
+       int pixel_sizeof;
 
-       int image_tot;              /* size of projectImages array */
+       /** size of projectImages array. */
+       int image_tot;
 
-       float (*screenCoords)[4];   /* verts projected into floating point screen space */
-       float screenMin[2];         /* 2D bounds for mesh verts on the screen's plane (screenspace) */
+       /** verts projected into floating point screen space. */
+       float (*screenCoords)[4];
+       /** 2D bounds for mesh verts on the screen's plane (screenspace). */
+       float screenMin[2];
        float screenMax[2];
-       float screen_width;         /* Calculated from screenMin & screenMax */
+       /** Calculated from screenMin & screenMax. */
+       float screen_width;
        float screen_height;
-       int winx, winy;             /* from the carea or from the projection render */
+       /** from the carea or from the projection render. */
+       int winx, winy;
 
        /* options for projection painting */
        bool  do_layer_clone;
@@ -282,32 +298,49 @@ typedef struct ProjPaintState {
        bool  do_stencil_brush;
        bool  do_material_slots;
 
-       bool  do_occlude;               /* Use raytraced occlusion? - ortherwise will paint right through to the back*/
-       bool  do_backfacecull;          /* ignore faces with normals pointing away, skips a lot of raycasts if your normals are correctly flipped */
-       bool  do_mask_normal;           /* mask out pixels based on their normals */
-       bool  do_mask_cavity;           /* mask out pixels based on cavity */
-       float normal_angle;             /* what angle to mask at */
-       float normal_angle__cos;         /* cos(normal_angle), faster to compare */
+       /** Use raytraced occlusion? - ortherwise will paint right through to the back. */
+       bool  do_occlude;
+       /** ignore faces with normals pointing away,
+        * skips a lot of raycasts if your normals are correctly flipped. */
+       bool  do_backfacecull;
+       /** mask out pixels based on their normals. */
+       bool  do_mask_normal;
+       /** mask out pixels based on cavity. */
+       bool  do_mask_cavity;
+       /** what angle to mask at. */
+       float normal_angle;
+       /** cos(normal_angle), faster to compare. */
+       float normal_angle__cos;
        float normal_angle_inner;
        float normal_angle_inner__cos;
-       float normal_angle_range;       /* difference between normal_angle and normal_angle_inner, for easy access */
+       /** difference between normal_angle and normal_angle_inner, for easy access. */
+       float normal_angle_range;
 
-       bool do_face_sel;               /* quick access to (me->editflag & ME_EDIT_PAINT_FACE_SEL) */
+       /** quick access to (me->editflag & ME_EDIT_PAINT_FACE_SEL) */
+       bool do_face_sel;
        bool is_ortho;
-       bool is_flip_object;            /* the object is negative scaled */
-       bool do_masking;              /* use masking during painting. Some operations such as airbrush may disable */
-       bool is_texbrush;              /* only to avoid running  */
-       bool is_maskbrush;            /* mask brush is applied before masking */
+       /** the object is negative scaled. */
+       bool is_flip_object;
+       /** use masking during painting. Some operations such as airbrush may disable. */
+       bool do_masking;
+       /** only to avoid running. */
+       bool is_texbrush;
+       /** mask brush is applied before masking. */
+       bool is_maskbrush;
 #ifndef PROJ_DEBUG_NOSEAMBLEED
        float seam_bleed_px;
 #endif
        /* clone vars */
        float cloneOffset[2];
 
-       float projectMat[4][4];     /* Projection matrix, use for getting screen coords */
-       float projectMatInv[4][4];  /* inverse of projectMat */
-       float viewDir[3];           /* View vector, use for do_backfacecull and for ray casting with an ortho viewport  */
-       float viewPos[3];           /* View location in object relative 3D space, so can compare to verts  */
+       /** Projection matrix, use for getting screen coords. */
+       float projectMat[4][4];
+       /** inverse of projectMat. */
+       float projectMatInv[4][4];
+       /** View vector, use for do_backfacecull and for ray casting with an ortho viewport. */
+       float viewDir[3];
+       /** View location in object relative 3D space, so can compare to verts. */
+       float viewPos[3];
        float clipsta, clipend;
 
        /* reproject vars */
@@ -320,7 +353,8 @@ typedef struct ProjPaintState {
        int thread_tot;
        int bucketMin[2];
        int bucketMax[2];
-       int context_bucket_x, context_bucket_y; /* must lock threads while accessing these */
+       /** must lock threads while accessing these. */
+       int context_bucket_x, context_bucket_y;
 
        struct CurveMapping *cavity_curve;
        BlurKernel *blurkernel;
@@ -343,13 +377,19 @@ typedef struct ProjPaintState {
        bool is_shared_user;
 
        ProjPaintImage *projImages;
-       float *cavities;            /* cavity amount for vertices */
+       /** cavity amount for vertices. */
+       float *cavities;
 
 #ifndef PROJ_DEBUG_NOSEAMBLEED
-       char *faceSeamFlags;                /* store info about faces, if they are initialized etc*/
-       char *faceWindingFlags;             /* save the winding of the face in uv space, helps as an extra validation step for seam detection */
-       float (*faceSeamUVs)[3][2];         /* expanded UVs for faces to use as seams */
-       LinkNode **vertFaces;               /* Only needed for when seam_bleed_px is enabled, use to find UV seams */
+       /** store info about faces, if they are initialized etc*/
+       char *faceSeamFlags;
+       /** save the winding of the face in uv space,
+        * helps as an extra validation step for seam detection. */
+       char *faceWindingFlags;
+       /** expanded UVs for faces to use as seams. */
+       float (*faceSeamUVs)[3][2];
+       /** Only needed for when seam_bleed_px is enabled, use to find UV seams. */
+       LinkNode **vertFaces;
 #endif
 
        SpinLock *tile_lock;
@@ -375,7 +415,8 @@ typedef struct ProjPaintState {
         * so a loop indirection is needed as well.
         */
        const MLoopUV **poly_to_loop_uv;
-       const MLoopUV **poly_to_loop_uv_clone;    /* other UV map, use for cloning between layers */
+       /** other UV map, use for cloning between layers. */
+       const MLoopUV **poly_to_loop_uv_clone;
 
        /* Actual material for each index, either from object or Mesh datablock... */
        Material **mat_array;
@@ -384,8 +425,10 @@ typedef struct ProjPaintState {
 } ProjPaintState;
 
 typedef union pixelPointer {
-       float *f_pt;            /* float buffer */
-       unsigned int *uint_pt; /* 2 ways to access a char buffer */
+       /** float buffer. */
+       float *f_pt;
+       /** 2 ways to access a char buffer. */
+       unsigned int *uint_pt;
        unsigned char *ch_pt;
 } PixelPointer;
 
@@ -396,12 +439,14 @@ typedef union pixelStore {
 } PixelStore;
 
 typedef struct ProjPixel {
-       float projCoSS[2]; /* the floating point screen projection of this pixel */
+       /** the floating point screen projection of this pixel. */
+       float projCoSS[2];
        float worldCoSS[3];
 
        short x_px, y_px;
 
-       unsigned short image_index; /* if anyone wants to paint onto more than 65535 images they can bite me */
+       /** if anyone wants to paint onto more than 65535 images they can bite me. */
+       unsigned short image_index;
        unsigned char bb_cell_index;
 
        /* for various reasons we may want to mask out painting onto this pixel */
@@ -624,7 +669,8 @@ static int project_paint_PickFace(
                }
        }
 
-       return best_tri_index; /* will be -1 or a valid face */
+       /** will be -1 or a valid face. */
+       return best_tri_index;
 }
 
 /* Converts a uv coord into a pixel location wrapping if the uv is outside 0-1 range */
@@ -665,7 +711,8 @@ static bool project_paint_PickColor(
        interp_v2_v2v2v2(uv, UNPACK3(lt_tri_uv), w);
 
        ima = project_paint_face_paint_image(ps, tri_index);
-       ibuf = BKE_image_get_first_ibuf(ima); /* we must have got the imbuf before getting here */
+       /** we must have got the imbuf before getting here. */
+       ibuf = BKE_image_get_first_ibuf(ima);
        if (!ibuf) return 0;
 
        if (interp) {
@@ -745,7 +792,7 @@ static int project_paint_occlude_ptv(
 
        /* do a 2D point in try intersection */
        if (!isect_point_tri_v2(pt, v1, v2, v3))
-               return 0;  /* we know there is  */
+               return 0;
 
 
        /* From here on we know there IS an intersection */
@@ -859,16 +906,19 @@ static int line_isect_y(const float p1[2], const float p2[2], const float y_leve
 {
        float y_diff;
 
-       if (y_level == p1[1]) { /* are we touching the first point? - no interpolation needed */
+       /* are we touching the first point? - no interpolation needed */
+       if (y_level == p1[1]) {
                *x_isect = p1[0];
                return ISECT_TRUE_P1;
        }
-       if (y_level == p2[1]) { /* are we touching the second point? - no interpolation needed */
+       /* are we touching the second point? - no interpolation needed */
+       if (y_level == p2[1]) {
                *x_isect = p2[0];
                return ISECT_TRUE_P2;
        }
 
-       y_diff = fabsf(p1[1] - p2[1]); /* yuck, horizontal line, we cant do much here */
+       /** yuck, horizontal line, we cant do much here. */
+       y_diff = fabsf(p1[1] - p2[1]);
 
        if (y_diff < 0.000001f) {
                *x_isect = (p1[0] + p2[0]) * 0.5f;
@@ -876,11 +926,13 @@ static int line_isect_y(const float p1[2], const float p2[2], const float y_leve
        }
 
        if (p1[1] > y_level && p2[1] < y_level) {
-               *x_isect = (p2[0] * (p1[1] - y_level) + p1[0] * (y_level - p2[1])) / y_diff;  /* (p1[1] - p2[1]); */
+               /* (p1[1] - p2[1]); */
+               *x_isect = (p2[0] * (p1[1] - y_level) + p1[0] * (y_level - p2[1])) / y_diff;
                return ISECT_TRUE;
        }
        else if (p1[1] < y_level && p2[1] > y_level) {
-               *x_isect = (p2[0] * (y_level - p1[1]) + p1[0] * (p2[1] - y_level)) / y_diff;  /* (p2[1] - p1[1]); */
+               /* (p2[1] - p1[1]); */
+               *x_isect = (p2[0] * (y_level - p1[1]) + p1[0] * (p2[1] - y_level)) / y_diff;
                return ISECT_TRUE;
        }
        else {
@@ -901,19 +953,23 @@ static int line_isect_x(const float p1[2], const float p2[2], const float x_leve
                return ISECT_TRUE_P2;
        }
 
-       x_diff = fabsf(p1[0] - p2[0]); /* yuck, horizontal line, we cant do much here */
+       /* yuck, horizontal line, we cant do much here */
+       x_diff = fabsf(p1[0] - p2[0]);
 
-       if (x_diff < 0.000001f) { /* yuck, vertical line, we cant do much here */
+       /* yuck, vertical line, we cant do much here */
+       if (x_diff < 0.000001f) {
                *y_isect = (p1[0] + p2[0]) * 0.5f;
                return ISECT_TRUE;
        }
 
        if (p1[0] > x_level && p2[0] < x_level) {
-               *y_isect = (p2[1] * (p1[0] - x_level) + p1[1] * (x_level - p2[0])) / x_diff;  /* (p1[0] - p2[0]); */
+               /* (p1[0] - p2[0]); */
+               *y_isect = (p2[1] * (p1[0] - x_level) + p1[1] * (x_level - p2[0])) / x_diff;
                return ISECT_TRUE;
        }
        else if (p1[0] < x_level && p2[0] > x_level) {
-               *y_isect = (p2[1] * (x_level - p1[0]) + p1[1] * (p2[0] - x_level)) / x_diff;  /* (p2[0] - p1[0]); */
+               /* (p2[0] - p1[0]); */
+               *y_isect = (p2[1] * (x_level - p1[0]) + p1[1] * (p2[0] - x_level)) / x_diff;
                return ISECT_TRUE;
        }
        else {
@@ -954,7 +1010,8 @@ static bool pixel_bounds_uv(
         const int ibuf_x, const int ibuf_y
         )
 {
-       float min_uv[2], max_uv[2]; /* UV bounds */
+       /* UV bounds */
+       float min_uv[2], max_uv[2];
 
        INIT_MINMAX2(min_uv, max_uv);
 
@@ -978,7 +1035,8 @@ static bool pixel_bounds_uv(
 
 static bool pixel_bounds_array(float (*uv)[2], rcti *bounds_px, const int ibuf_x, const int ibuf_y, int tot)
 {
-       float min_uv[2], max_uv[2]; /* UV bounds */
+       /* UV bounds */
+       float min_uv[2], max_uv[2];
 
        if (tot == 0) {
                return 0;
@@ -1031,7 +1089,8 @@ static bool check_seam(
        const unsigned int i1 = ps->mloop_eval[orig_lt->tri[orig_i1_fidx]].v;
        const unsigned int i2 = ps->mloop_eval[orig_lt->tri[orig_i2_fidx]].v;
        LinkNode *node;
-       int i1_fidx = -1, i2_fidx = -1; /* index in face */
+       /* index in face */
+       int i1_fidx = -1, i2_fidx = -1;
 
        for (node = ps->vertFaces[i1]; node; node = node->next) {
                const int tri_index = POINTER_AS_INT(node->link);
@@ -1117,8 +1176,10 @@ static void uv_image_outset(
        const float scale_clamp = 5.0f;
 
        float a1, a2, a3;
-       float puv[3][2]; /* pixelspace uv's */
-       float no1[2], no2[2], no3[2]; /* normals */
+       /* pixelspace uv's */
+       float puv[3][2];
+       /* normals */
+       float no1[2], no2[2], no3[2];
        float dir1[2], dir2[2], dir3[2];
        float ibuf_inv[2];
 
@@ -1190,9 +1251,11 @@ static void uv_image_outset(
  */
 static void project_face_seams_init(const ProjPaintState *ps, const int tri_index)
 {
-       int other_face, other_fidx; /* vars for the other face, we also set its flag */
+       /* vars for the other face, we also set its flag */
+       int other_face, other_fidx;
        int fidx1 = 2;
-       int fidx2 = 0; /* next fidx in the face (0,1,2,3) -> (1,2,3,0) or (0,1,2) -> (1,2,0) for a tri */
+       /* next fidx in the face (0,1,2,3) -> (1,2,3,0) or (0,1,2) -> (1,2,0) for a tri */
+       int fidx2 = 0;
 
        /* initialize face winding if needed */
        if ((ps->faceWindingFlags[tri_index] & PROJ_FACE_WINDING_INIT) == 0)
@@ -1207,8 +1270,10 @@ static void project_face_seams_init(const ProjPaintState *ps, const int tri_inde
                        }
                        else {
                                ps->faceSeamFlags[tri_index] |= 16 << fidx1;
-                               if (other_face != -1)
-                                       ps->faceSeamFlags[other_face] |= 16 << other_fidx;  /* second 4 bits for disabled */
+                               if (other_face != -1) {
+                                       /* second 4 bits for disabled */
+                                       ps->faceSeamFlags[other_face] |= 16 << other_fidx;
+                               }
                        }
                }
 
@@ -1261,7 +1326,8 @@ static void screen_px_from_persp(
        }
        else {
                w[0] = w[1] = w[2] =
-               w_int[0] = w_int[1] = w_int[2] = 1.0f / 3.0f;  /* dummy values for zero area face */
+               /* dummy values for zero area face */
+               w_int[0] = w_int[1] = w_int[2] = 1.0f / 3.0f;
        }
        /* done re-weighting */
 
@@ -1467,7 +1533,8 @@ static float project_paint_uvpixel_mask(
                }
 
                if (angle_cos <= ps->normal_angle__cos) {
-                       return 0.0f; /* outsize the normal limit*/
+                       /* outsize the normal limit*/
+                       return 0.0f;
                }
                else if (angle_cos < ps->normal_angle_inner__cos) {
                        mask *= (ps->normal_angle - acosf(angle_cos)) / ps->normal_angle_range;
@@ -1686,12 +1753,14 @@ static ProjPixel *project_paint_uvpixel_init(
                         * the faces are already initialized in project_paint_delayed_face_init(...) */
                        if (ibuf->rect_float) {
                                if (!project_paint_PickColor(ps, co, ((ProjPixelClone *)projPixel)->clonepx.f, NULL, 1)) {
-                                       ((ProjPixelClone *)projPixel)->clonepx.f[3] = 0; /* zero alpha - ignore */
+                                       /* zero alpha - ignore */
+                                       ((ProjPixelClone *)projPixel)->clonepx.f[3] = 0;
                                }
                        }
                        else {
                                if (!project_paint_PickColor(ps, co, NULL, ((ProjPixelClone *)projPixel)->clonepx.ch, 1)) {
-                                       ((ProjPixelClone *)projPixel)->clonepx.ch[3] = 0; /* zero alpha - ignore */
+                                       /* zero alpha - ignore */
+                                       ((ProjPixelClone *)projPixel)->clonepx.ch[3] = 0;
                                }
                        }
                }
@@ -2249,22 +2318,25 @@ static void project_bucket_clip_face(
        else {
                /* The Complicated Case!
                 *
-                * The 2 cases above are where the face is inside the bucket or the bucket is inside the face.
+                * The 2 cases above are where the face is inside the bucket
+                * or the bucket is inside the face.
                 *
                 * we need to make a convex polyline from the intersection between the screenspace face
                 * and the bucket bounds.
                 *
-                * There are a number of ways this could be done, currently it just collects all intersecting verts,
-                * and line intersections,  then sorts them clockwise, this is a lot easier then evaluating the geometry to
-                * do a correct clipping on both shapes. */
-
-
-               /* add a bunch of points, we know must make up the convex hull which is the clipped rect and triangle */
+                * There are a number of ways this could be done, currently it just collects all
+                * intersecting verts, and line intersections, then sorts them clockwise, this is
+                * a lot easier then evaluating the geometry to do a correct clipping on both shapes.
+                */
 
 
+               /* Add a bunch of points, we know must make up the convex hull
+                * which is the clipped rect and triangle */
 
                /* Maximum possible 6 intersections when using a rectangle and triangle */
-               float isectVCosSS[8][3]; /* The 3rd float is used to store angle for qsort(), NOT as a Z location */
+
+               /* The 3rd float is used to store angle for qsort(), NOT as a Z location */
+               float isectVCosSS[8][3];
                float v1_clipSS[2], v2_clipSS[2];
                float w[3];
 
@@ -2332,7 +2404,8 @@ static void project_bucket_clip_face(
                }
 #endif
 
-               v1_clipSS[0] = cent[0]; /* Abuse this var for the loop below */
+               /* Abuse this var for the loop below */
+               v1_clipSS[0] = cent[0];
                v1_clipSS[1] = cent[1] + 1.0f;
 
                for (i = 0; i < (*tot); i++) {
@@ -2358,7 +2431,8 @@ static void project_bucket_clip_face(
                                                isectVCosSS[j][0] = isectVCosSS[j + 1][0];
                                                isectVCosSS[j][1] = isectVCosSS[j + 1][1];
                                        }
-                                       doubles = true; /* keep looking for more doubles */
+                                       /* keep looking for more doubles */
+                                       doubles = true;
                                        (*tot)--;
                                }
                        }
@@ -2523,29 +2597,36 @@ static void project_paint_face_init(
        const float *lt_tri_uv[3] = { PS_LOOPTRI_AS_UV_3(ps->poly_to_loop_uv, lt) };
 
        /* UV/pixel seeking data */
-       int x; /* Image X-Pixel */
-       int y; /* Image Y-Pixel */
+       /* Image X/Y-Pixel */
+       int x, y;
        float mask;
-       float uv[2]; /* Image floating point UV - same as x, y but from 0.0-1.0 */
+       /* Image floating point UV - same as x, y but from 0.0-1.0 */
+       float uv[2];
 
-       const float *v1coSS, *v2coSS, *v3coSS; /* vert co screen-space, these will be assigned to lt_vtri[0-2] */
+       /* vert co screen-space, these will be assigned to lt_vtri[0-2] */
+       const float *v1coSS, *v2coSS, *v3coSS;
 
-       const float *vCo[3]; /* vertex screenspace coords */
+       /* vertex screenspace coords */
+       const float *vCo[3];
 
        float w[3], wco[3];
 
-       float *uv1co, *uv2co, *uv3co; /* for convenience only, these will be assigned to lt_tri_uv[0],1,2 or lt_tri_uv[0],2,3 */
+       /* for convenience only, these will be assigned to lt_tri_uv[0],1,2 or lt_tri_uv[0],2,3 */
+       float *uv1co, *uv2co, *uv3co;
        float pixelScreenCo[4];
        bool do_3d_mapping = ps->brush->mtex.brush_map_mode == MTEX_MAP_MODE_3D;
 
-       rcti bounds_px; /* ispace bounds */
+       /* ispace bounds */
+       rcti bounds_px;
        /* vars for getting uvspace bounds */
 
-       float lt_uv_pxoffset[3][2]; /* bucket bounds in UV space so we can init pixels only for this face,  */
+       /* bucket bounds in UV space so we can init pixels only for this face,  */
+       float lt_uv_pxoffset[3][2];
        float xhalfpx, yhalfpx;
        const float ibuf_xf = (float)ibuf->x, ibuf_yf = (float)ibuf->y;
 
-       int has_x_isect = 0, has_isect = 0; /* for early loop exit */
+       /* for early loop exit */
+       int has_x_isect = 0, has_isect = 0;
 
        float uv_clip[8][2];
        int uv_clip_tot;
@@ -2619,12 +2700,14 @@ static void project_paint_face_init(
                        has_isect = 0;
                        for (y = bounds_px.ymin; y < bounds_px.ymax; y++) {
                                //uv[1] = (((float)y) + 0.5f) / (float)ibuf->y;
-                               uv[1] = (float)y / ibuf_yf; /* use pixel offset UV coords instead */
+                               /* use pixel offset UV coords instead */
+                               uv[1] = (float)y / ibuf_yf;
 
                                has_x_isect = 0;
                                for (x = bounds_px.xmin; x < bounds_px.xmax; x++) {
                                        //uv[0] = (((float)x) + 0.5f) / ibuf->x;
-                                       uv[0] = (float)x / ibuf_xf; /* use pixel offset UV coords instead */
+                                       /* use pixel offset UV coords instead */
+                                       uv[0] = (float)x / ibuf_xf;
 
                                        /* Note about IsectPoly2Df_twoside, checking the face or uv flipping doesn't work,
                                         * could check the poly direction but better to do this */
@@ -2646,7 +2729,8 @@ static void project_paint_face_init(
                                                                ps->mvert_eval[lt_vtri[2]].co,
                                                                w);
                                                        if (do_clip && ED_view3d_clipping_test(ps->rv3d, wco, true)) {
-                                                               continue; /* Watch out that no code below this needs to run */
+                                                               /* Watch out that no code below this needs to run */
+                                                               continue;
                                                        }
                                                }
 
@@ -2693,8 +2777,10 @@ static void project_paint_face_init(
        if (ps->seam_bleed_px > 0.0f) {
                int face_seam_flag;
 
-               if (threaded)
-                       BLI_thread_lock(LOCK_CUSTOM1);  /* Other threads could be modifying these vars */
+               if (threaded) {
+                       /* Other threads could be modifying these vars. */
+                       BLI_thread_lock(LOCK_CUSTOM1);
+               }
 
                face_seam_flag = ps->faceSeamFlags[tri_index];
 
@@ -2710,8 +2796,10 @@ static void project_paint_face_init(
 
                if ((face_seam_flag & (PROJ_FACE_SEAM1 | PROJ_FACE_SEAM2 | PROJ_FACE_SEAM3)) == 0) {
 
-                       if (threaded)
-                               BLI_thread_unlock(LOCK_CUSTOM1);  /* Other threads could be modifying these vars */
+                       if (threaded) {
+                               /* Other threads could be modifying these vars. */
+                               BLI_thread_unlock(LOCK_CUSTOM1);
+                       }
 
                }
                else {
@@ -2719,13 +2807,19 @@ static void project_paint_face_init(
 
                        /* Now create new UV's for the seam face */
                        float (*outset_uv)[2] = ps->faceSeamUVs[tri_index];
-                       float insetCos[3][3]; /* inset face coords.  NOTE!!! ScreenSace for ortho, Worldspace in perspective view */
+                       /* inset face coords.  NOTE!!! ScreenSace for ortho, Worldspace in perspective view */
+                       float insetCos[3][3];
 
-                       const float *vCoSS[3]; /* vertex screenspace coords */
+                       /* vertex screenspace coords */
+                       const float *vCoSS[3];
 
-                       float bucket_clip_edges[2][2]; /* store the screenspace coords of the face, clipped by the bucket's screen aligned rectangle */
+                       /* Store the screenspace coords of the face,
+                        * clipped by the bucket's screen aligned rectangle. */
+                       float bucket_clip_edges[2][2];
                        float edge_verts_inset_clip[2][3];
-                       int fidx1, fidx2; /* face edge pairs - loop throuh these ((0,1), (1,2), (2,3), (3,0)) or ((0,1), (1,2), (2,0)) for a tri */
+                       /* face edge pairs - loop throuh these:
+                        * ((0,1), (1,2), (2,3), (3,0)) or ((0,1), (1,2), (2,0)) for a tri */
+                       int fidx1, fidx2;
 
                        float seam_subsection[4][2];
                        float fac1, fac2;
@@ -2735,9 +2829,11 @@ static void project_paint_face_init(
                                        lt_uv_pxoffset, outset_uv, ps->seam_bleed_px,
                                        ibuf->x, ibuf->y, (ps->faceWindingFlags[tri_index] & PROJ_FACE_WINDING_CW) == 0);
 
-                       /* ps->faceSeamUVs cant be modified when threading, now this is done we can unlock */
-                       if (threaded)
-                               BLI_thread_unlock(LOCK_CUSTOM1);  /* Other threads could be modifying these vars */
+                       /* ps->faceSeamUVs cant be modified when threading, now this is done we can unlock. */
+                       if (threaded) {
+                               /* Other threads could be modifying these vars */
+                               BLI_thread_unlock(LOCK_CUSTOM1);
+                       }
 
                        vCoSS[0] = ps->screenCoords[lt_vtri[0]];
                        vCoSS[1] = ps->screenCoords[lt_vtri[1]];
@@ -2752,12 +2848,14 @@ static void project_paint_face_init(
                        }
 
                        for (fidx1 = 0; fidx1 < 3; fidx1++) {
-                               fidx2 = (fidx1 == 2) ? 0 : fidx1 + 1;  /* next fidx in the face (0,1,2) -> (1,2,0) */
+                               /* next fidx in the face (0,1,2) -> (1,2,0) */
+                               fidx2 = (fidx1 == 2) ? 0 : fidx1 + 1;
 
                                if ((face_seam_flag & (1 << fidx1)) && /* 1<<fidx1 -> PROJ_FACE_SEAM# */
                                    line_clip_rect2f(clip_rect, bucket_bounds, vCoSS[fidx1], vCoSS[fidx2], bucket_clip_edges[0], bucket_clip_edges[1]))
                                {
-                                       if (len_squared_v2v2(vCoSS[fidx1], vCoSS[fidx2]) > FLT_EPSILON) { /* avoid div by zero */
+                                       /* Avoid div by zero. */
+                                       if (len_squared_v2v2(vCoSS[fidx1], vCoSS[fidx2]) > FLT_EPSILON) {
 
                                                if (is_ortho) {
                                                        fac1 = line_point_factor_v2(bucket_clip_edges[0], vCoSS[fidx1], vCoSS[fidx2]);
@@ -2786,12 +2884,14 @@ static void project_paint_face_init(
                                                        has_isect = 0;
                                                        for (y = bounds_px.ymin; y < bounds_px.ymax; y++) {
                                                                // uv[1] = (((float)y) + 0.5f) / (float)ibuf->y;
-                                                               uv[1] = (float)y / ibuf_yf; /* use offset uvs instead */
+                                                               /* use offset uvs instead */
+                                                               uv[1] = (float)y / ibuf_yf;
 
                                                                has_x_isect = 0;
                                                                for (x = bounds_px.xmin; x < bounds_px.xmax; x++) {
                                                                        //uv[0] = (((float)x) + 0.5f) / (float)ibuf->x;
-                                                                       uv[0] = (float)x / ibuf_xf; /* use offset uvs instead */
+                                                                       /* use offset uvs instead */
+                                                                       uv[0] = (float)x / ibuf_xf;
 
                                                                        /* test we're inside uvspace bucket and triangle bounds */
                                                                        if (isect_point_quad_v2(uv, UNPACK4(seam_subsection))) {
@@ -2813,10 +2913,12 @@ static void project_paint_face_init(
 
                                                                                if (!is_ortho) {
                                                                                        pixelScreenCo[3] = 1.0f;
-                                                                                       mul_m4_v4((float(*)[4])ps->projectMat, pixelScreenCo); /* cast because of const */
+                                                                                       /* cast because of const */
+                                                                                       mul_m4_v4((float(*)[4])ps->projectMat, pixelScreenCo);
                                                                                        pixelScreenCo[0] = (float)(ps->winx * 0.5f) + (ps->winx * 0.5f) * pixelScreenCo[0] / pixelScreenCo[3];
                                                                                        pixelScreenCo[1] = (float)(ps->winy * 0.5f) + (ps->winy * 0.5f) * pixelScreenCo[1] / pixelScreenCo[3];
-                                                                                       pixelScreenCo[2] = pixelScreenCo[2] / pixelScreenCo[3]; /* Use the depth for bucket point occlusion */
+                                                                                       /* Use the depth for bucket point occlusion */
+                                                                                       pixelScreenCo[2] = pixelScreenCo[2] / pixelScreenCo[3];
                                                                                }
 
                                                                                if ((ps->do_occlude == false) ||
@@ -2844,7 +2946,8 @@ static void project_paint_face_init(
                                                                                                interp_v3_v3v3v3(wco, vCo[0], vCo[1], vCo[2], w);
 
                                                                                                if (do_clip && ED_view3d_clipping_test(ps->rv3d, wco, true)) {
-                                                                                                       continue; /* Watch out that no code below this needs to run */
+                                                                                                       /* Watch out that no code below this needs to run */
+                                                                                                       continue;
                                                                                                }
                                                                                        }
 
@@ -2886,12 +2989,16 @@ static void project_paint_face_init(
 }
 
 
-/* takes floating point screenspace min/max and returns int min/max to be used as indices for ps->bucketRect, ps->bucketFlags */
+/**
+ * Takes floating point screenspace min/max and
+ * returns int min/max to be used as indices for ps->bucketRect, ps->bucketFlags
+ */
 static void project_paint_bucket_bounds(const ProjPaintState *ps, const float min[2], const float max[2], int bucketMin[2], int bucketMax[2])
 {
        /* divide by bucketWidth & bucketHeight so the bounds are offset in bucket grid units */
        /* XXX: the offset of 0.5 is always truncated to zero and the offset of 1.5f is always truncated to 1, is this really correct?? - jwilkins */
-       bucketMin[0] = (int)((int)(((float)(min[0] - ps->screenMin[0]) / ps->screen_width) * ps->buckets_x) + 0.5f); /* these offsets of 0.5 and 1.5 seem odd but they are correct */
+       /* these offsets of 0.5 and 1.5 seem odd but they are correct */
+       bucketMin[0] = (int)((int)(((float)(min[0] - ps->screenMin[0]) / ps->screen_width) * ps->buckets_x) + 0.5f);
        bucketMin[1] = (int)((int)(((float)(min[1] - ps->screenMin[1]) / ps->screen_height) * ps->buckets_y) + 0.5f);
 
        bucketMax[0] = (int)((int)(((float)(max[0] - ps->screenMin[0]) / ps->screen_width) * ps->buckets_x) + 1.5f);
@@ -2906,13 +3013,22 @@ static void project_paint_bucket_bounds(const ProjPaintState *ps, const float mi
 }
 
 /* set bucket_bounds to a screen space-aligned floating point bound-box */
-static void project_bucket_bounds(const ProjPaintState *ps, const int bucket_x, const int bucket_y, rctf *bucket_bounds)
+static void project_bucket_bounds(
+        const ProjPaintState *ps, const int bucket_x, const int bucket_y, rctf *bucket_bounds)
 {
-       bucket_bounds->xmin = ps->screenMin[0] + ((bucket_x) * (ps->screen_width / ps->buckets_x));     /* left */
-       bucket_bounds->xmax = ps->screenMin[0] + ((bucket_x + 1) * (ps->screen_width / ps->buckets_x)); /* right */
-
-       bucket_bounds->ymin = ps->screenMin[1] + ((bucket_y) * (ps->screen_height / ps->buckets_y));      /* bottom */
-       bucket_bounds->ymax = ps->screenMin[1] + ((bucket_y + 1) * (ps->screen_height  / ps->buckets_y)); /* top */
+       /* left */
+       bucket_bounds->xmin = (
+               ps->screenMin[0] + ((bucket_x) * (ps->screen_width / ps->buckets_x)));
+       /* right */
+       bucket_bounds->xmax = (
+               ps->screenMin[0] + ((bucket_x + 1) * (ps->screen_width / ps->buckets_x)));
+
+       /* bottom */
+       bucket_bounds->ymin = (
+               ps->screenMin[1] + ((bucket_y) * (ps->screen_height / ps->buckets_y)));
+       /* top */
+       bucket_bounds->ymax = (
+               ps->screenMin[1] + ((bucket_y + 1) * (ps->screen_height  / ps->buckets_y)));
 }
 
 /* Fill this bucket with pixels from the faces that intersect it.
@@ -3024,15 +3140,19 @@ static bool project_bucket_face_isect(ProjPaintState *ps, int bucket_x, int buck
 }
 
 /* Add faces to the bucket but don't initialize its pixels
- * TODO - when painting occluded, sort the faces on their min-Z and only add faces that faces that are not occluded */
+ * TODO - when painting occluded, sort the faces on their min-Z
+ * and only add faces that faces that are not occluded */
 static void project_paint_delayed_face_init(ProjPaintState *ps, const MLoopTri *lt, const int tri_index)
 {
        const int lt_vtri[3] = { PS_LOOPTRI_AS_VERT_INDEX_3(ps, lt) };
        float min[2], max[2], *vCoSS;
-       int bucketMin[2], bucketMax[2]; /* for  ps->bucketRect indexing */
+       /* for ps->bucketRect indexing */
+       int bucketMin[2], bucketMax[2];
        int fidx, bucket_x, bucket_y;
-       int has_x_isect = -1, has_isect = 0; /* for early loop exit */
-       MemArena *arena = ps->arena_mt[0]; /* just use the first thread arena since threading has not started yet */
+       /* for early loop exit */
+       int has_x_isect = -1, has_isect = 0;
+       /* just use the first thread arena since threading has not started yet */
+       MemArena *arena = ps->arena_mt[0];
 
        INIT_MINMAX2(min, max);
 
@@ -3051,7 +3171,8 @@ static void project_paint_delayed_face_init(ProjPaintState *ps, const MLoopTri *
                                int bucket_index = bucket_x + (bucket_y * ps->buckets_x);
                                BLI_linklist_prepend_arena(
                                        &ps->bucketFaces[bucket_index],
-                                       POINTER_FROM_INT(tri_index), /* cast to a pointer to shut up the compiler */
+                                       /* cast to a pointer to shut up the compiler */
+                                       POINTER_FROM_INT(tri_index),
                                        arena
                                        );
 
@@ -3071,7 +3192,8 @@ static void project_paint_delayed_face_init(ProjPaintState *ps, const MLoopTri *
 
 #ifndef PROJ_DEBUG_NOSEAMBLEED
        if (ps->seam_bleed_px > 0.0f) {
-               **ps->faceSeamUVs[tri_index] = FLT_MAX; /* set as uninitialized */
+               /* set as uninitialized */
+               **ps->faceSeamUVs[tri_index] = FLT_MAX;
        }
 #endif
 }
@@ -3218,7 +3340,8 @@ static void proj_paint_state_screen_coords_init(ProjPaintState *ps, const int di
                                /* screen space, not clamped */
                                projScreenCo[0] = (float)(ps->winx * 0.5f) + (ps->winx * 0.5f) * projScreenCo[0] / projScreenCo[3];
                                projScreenCo[1] = (float)(ps->winy * 0.5f) + (ps->winy * 0.5f) * projScreenCo[1] / projScreenCo[3];
-                               projScreenCo[2] = projScreenCo[2] / projScreenCo[3]; /* Use the depth for bucket point occlusion */
+                               /* Use the depth for bucket point occlusion */
+                               projScreenCo[2] = projScreenCo[2] / projScreenCo[3];
                                minmax_v2v2_v2(ps->screenMin, ps->screenMax, projScreenCo);
                        }
                        else {
@@ -3434,7 +3557,8 @@ static bool proj_paint_state_mesh_eval_init(const bContext *C, ProjPaintState *p
        }
 
        /* Build final material array, we use this a lot here. */
-       const int totmat = ob->totcol + 1; /* materials start from 1, default material is 0 */
+       /* materials start from 1, default material is 0 */
+       const int totmat = ob->totcol + 1;
        ps->mat_array = MEM_malloc_arrayN(totmat, sizeof(*ps->mat_array), __func__);
        /* We leave last material as empty - rationale here is being able to index
         * the materials by using the mf->mat_nr directly and leaving the last
@@ -3814,7 +3938,8 @@ static void project_paint_begin(
        ProjPaintFaceLookup face_lookup;
        const MLoopUV *mloopuv_base = NULL;
 
-       MemArena *arena; /* at the moment this is just ps->arena_mt[0], but use this to show were not multithreading */
+       /* at the moment this is just ps->arena_mt[0], but use this to show were not multithreading */
+       MemArena *arena;
 
        const int diameter = 2 * BKE_brush_size_get(ps->scene, ps->brush);
 
@@ -3822,8 +3947,10 @@ static void project_paint_begin(
 
        /* ---- end defines ---- */
 
-       if (ps->source == PROJ_SRC_VIEW)
-               ED_view3d_clipping_local(ps->rv3d, ps->ob->obmat);  /* faster clipping lookups */
+       if (ps->source == PROJ_SRC_VIEW) {
+               /* faster clipping lookups */
+               ED_view3d_clipping_local(ps->rv3d, ps->ob->obmat);
+       }
 
        ps->do_face_sel = ((((Mesh *)ps->ob->data)->editflag & ME_EDIT_PAINT_FACE_SEL) != 0);
        ps->is_flip_object = (ps->ob->transflag & OB_NEG_SCALE) != 0;
@@ -4057,7 +4184,8 @@ static bool project_image_refresh_tagged(ProjPaintState *ps)
                                partial_redraw_single_init(pr);
                        }
 
-                       projIma->touch = 0; /* clear for reuse */
+                       /* clear for reuse */
+                       projIma->touch = 0;
                }
        }
 
@@ -4149,8 +4277,11 @@ typedef struct ProjectHandle {
        float prevmval[2];
        float mval[2];
 
-       /* annoying but we need to have image bounds per thread, then merge into ps->projectPartialRedraws */
-       ProjPaintImage *projImages; /* array of partial redraws */
+       /* Annoying but we need to have image bounds per thread,
+        * then merge into ps->projectPartialRedraws. */
+
+       /* array of partial redraws */
+       ProjPaintImage *projImages;
 
        /* thread settings */
        int thread_index;
@@ -4292,7 +4423,8 @@ static void do_projectpaint_soften(
        float accum_tot = 0;
        int xk, yk;
        BlurKernel *kernel = ps->blurkernel;
-       float rgba[4];  /* convert to byte after */
+       /* convert to byte after */
+       float rgba[4];
 
        /* rather then painting, accumulate surrounding colors */
        zero_v4(rgba);
@@ -4479,18 +4611,21 @@ static void *do_projectpaint_thread(void *ph_v)
        unsigned short mask_short;
        const float brush_alpha = BKE_brush_alpha_get(ps->scene, brush);
        const float brush_radius = ps->brush_size;
-       const float brush_radius_sq = brush_radius * brush_radius; /* avoid a square root with every dist comparison */
+       /* avoid a square root with every dist comparison */
+       const float brush_radius_sq = brush_radius * brush_radius;
 
        const bool lock_alpha = ELEM(brush->blend, IMB_BLEND_ERASE_ALPHA, IMB_BLEND_ADD_ALPHA) ?
                0 : (brush->flag & BRUSH_LOCK_ALPHA) != 0;
 
        LinkNode *smearPixels = NULL;
        LinkNode *smearPixels_f = NULL;
-       MemArena *smearArena = NULL; /* mem arena for this brush projection only */
+       /* mem arena for this brush projection only */
+       MemArena *smearArena = NULL;
 
        LinkNode *softenPixels = NULL;
        LinkNode *softenPixels_f = NULL;
-       MemArena *softenArena = NULL; /* mem arena for this brush projection only */
+       /* mem arena for this brush projection only */
+       MemArena *softenArena = NULL;
 
        if (tool == PAINT_TOOL_SMEAR) {
                pos_ofs[0] = pos[0] - lastpos[0];
@@ -5082,7 +5217,8 @@ static void project_state_init(bContext *C, Object *ob, ProjPaintState *ps, int
 
        ps->depsgraph = CTX_data_depsgraph(C);
        ps->scene = scene;
-       ps->ob = ob; /* allow override of active object */
+       /* allow override of active object */
+       ps->ob = ob;
 
        ps->do_material_slots = (settings->imapaint.mode == IMAGEPAINT_MODE_MATERIAL);
        ps->stencil_ima = settings->imapaint.stencil;
@@ -5116,7 +5252,8 @@ static void project_state_init(bContext *C, Object *ob, ProjPaintState *ps, int
 
 
 #ifndef PROJ_DEBUG_NOSEAMBLEED
-       ps->seam_bleed_px = settings->imapaint.seam_bleed; /* pixel num to bleed */
+       /* pixel num to bleed */
+       ps->seam_bleed_px = settings->imapaint.seam_bleed;
 #endif
 
        if (ps->do_mask_normal) {
@@ -5131,8 +5268,10 @@ static void project_state_init(bContext *C, Object *ob, ProjPaintState *ps, int
        ps->normal_angle *=         (float)(M_PI_2 / 90);
        ps->normal_angle_range = ps->normal_angle - ps->normal_angle_inner;
 
-       if (ps->normal_angle_range <= 0.0f)
-               ps->do_mask_normal = false;  /* no need to do blending */
+       if (ps->normal_angle_range <= 0.0f) {
+               /* no need to do blending */
+               ps->do_mask_normal = false;
+       }
 
        ps->normal_angle__cos       = cosf(ps->normal_angle);
        ps->normal_angle_inner__cos = cosf(ps->normal_angle_inner);
@@ -5368,9 +5507,11 @@ static int texture_paint_camera_project_exec(bContext *C, wmOperator *op)
        ps.is_maskbrush = false;
        ps.do_masking = false;
        orig_brush_size = BKE_brush_size_get(scene, ps.brush);
-       BKE_brush_size_set(scene, ps.brush, 32 * U.pixelsize); /* cover the whole image */
+       /* cover the whole image */
+       BKE_brush_size_set(scene, ps.brush, 32 * U.pixelsize);
 
-       ps.tool = PAINT_TOOL_DRAW; /* so pixels are initialized with minimal info */
+       /* so pixels are initialized with minimal info */
+       ps.tool = PAINT_TOOL_DRAW;
 
        scene->toolsettings->imapaint.flag |= IMAGEPAINT_DRAWING;
 
index d8b7d449c36a53d7d6d59869615009f80f6f7092..d2239b9b8ba9b9baa9f7ccf1f8af4f571c6de57c 100644 (file)
@@ -94,20 +94,24 @@ typedef struct View3DCameraControl {
        Object *root_parent;
 
        /* backup values */
-       float dist_backup; /* backup the views distance since we use a zero dist for fly mode */
-       float ofs_backup[3]; /* backup the views offset in case the user cancels flying in non camera mode */
+       float dist_backup;
+       /* backup the views distance since we use a zero dist for fly mode */
+       float ofs_backup[3];
+       /* backup the views offset in case the user cancels flying in non camera mode */
 
        /* backup the views quat in case the user cancels flying in non camera mode.
         * (quat for view, eul for camera) */
        float rot_backup[4];
-       char persp_backup;  /* remember if were ortho or not, only used for restoring the view if it was a ortho view */
+       /* remember if were ortho or not, only used for restoring the view if it was a ortho view */
+       char persp_backup;
 
        /* are we flying an ortho camera in perspective view,
         * which was originally in ortho view?
         * could probably figure it out but better be explicit */
        bool is_ortho_cam;
 
-       void *obtfm; /* backup the objects transform */
+       /* backup the objects transform */
+       void *obtfm;
 } View3DCameraControl;
 
 
@@ -185,8 +189,10 @@ struct View3DCameraControl *ED_view3d_cameracontrol_acquire(
        }
        else {
                /* perspective or ortho */
-               if (rv3d->persp == RV3D_ORTHO)
-                       rv3d->persp = RV3D_PERSP;  /* if ortho projection, make perspective */
+               if (rv3d->persp == RV3D_ORTHO) {
+                       /* if ortho projection, make perspective */
+                       rv3d->persp = RV3D_PERSP;
+               }
 
                copy_qt_qt(vctrl->rot_backup, rv3d->viewquat);
                copy_v3_v3(vctrl->ofs_backup, rv3d->ofs);
index fc52f5e723cd86b87ba2f731472f2b345c58f9fc..f9304f67f0b0722f628f7260317e35d5264d9030 100644 (file)
@@ -95,8 +95,10 @@ typedef struct TransSnap {
        bool    peel;
        bool    snap_spatial_grid;
        short   status;
-       float   snapPoint[3]; /* snapping from this point (in global-space)*/
-       float   snapTarget[3]; /* to this point (in global-space)*/
+       /** snapping from this point (in global-space). */
+       float   snapPoint[3];
+       /** to this point (in global-space). */
+       float   snapTarget[3];
        float   snapNormal[3];
        char    snapNodeBorder;
        ListBase points;
@@ -120,59 +122,91 @@ typedef struct TransSnap {
 } TransSnap;
 
 typedef struct TransCon {
-       short orientation;       /**/
-       char  text[50];      /* Description of the Constraint for header_print                            */
-       float mtx[3][3];     /* Matrix of the Constraint space                                            */
-       float imtx[3][3];    /* Inverse Matrix of the Constraint space                                    */
-       float pmtx[3][3];    /* Projection Constraint Matrix (same as imtx with some axis == 0)           */
-       int   imval[2];      /* initial mouse value for visual calculation                                */
-                            /* the one in TransInfo is not guarantee to stay the same (Rotates change it)  */
-       int   mode;          /* Mode flags of the Constraint                                              */
+       short orientation;
+       /** Description of the Constraint for header_print. */
+       char  text[50];
+       /** Matrix of the Constraint space. */
+       float mtx[3][3];
+       /** Inverse Matrix of the Constraint space. */
+       float imtx[3][3];
+       /** Projection Constraint Matrix (same as imtx with some axis == 0). */
+       float pmtx[3][3];
+       /** Initial mouse value for visual calculation
+        * the one in TransInfo is not guarantee to stay the same (Rotates change it). */
+       int   imval[2];
+       /** Mode flags of the Constraint. */
+       int   mode;
        void  (*drawExtra)(struct TransInfo *t);
 
-                            /* Note: if 'tc' is NULL, 'td' must also be NULL. */
-                            /* For constraints that needs to draw differently from the other
-                             * uses this instead of the generic draw function                            */
+       /* Note: if 'tc' is NULL, 'td' must also be NULL.
+        * For constraints that needs to draw differently from the other
+        * uses this instead of the generic draw function. */
+
+       /** Apply function pointer for linear vectorial transformation
+        * The last three parameters are pointers to the in/out/printable vectors. */
        void  (*applyVec)(struct TransInfo *t, struct TransDataContainer *tc, struct TransData *td, const float in[3], float out[3], float pvec[3]);
-                            /* Apply function pointer for linear vectorial transformation                */
-                            /* The last three parameters are pointers to the in/out/printable vectors    */
+       /** Apply function pointer for size transformation. */
        void  (*applySize)(struct TransInfo *t, struct TransDataContainer *tc, struct TransData *td, float smat[3][3]);
-                            /* Apply function pointer for size transformation */
+       /** Apply function pointer for rotation transformation */
        void  (*applyRot)(struct TransInfo *t, struct TransDataContainer *tc, struct TransData *td, float vec[3], float *angle);
-                            /* Apply function pointer for rotation transformation */
 } TransCon;
 
 typedef struct TransDataExtension {
-       float drot[3];           /* Initial object drot */
-       // float drotAngle;      /* Initial object drotAngle,    TODO: not yet implemented */
-       // float drotAxis[3];    /* Initial object drotAxis, TODO: not yet implemented */
-       float dquat[4];          /* Initial object dquat */
-       float dscale[3];     /* Initial object dscale */
-       float *rot;          /* Rotation of the data to transform                                              */
-       float  irot[3];      /* Initial rotation                                                               */
-       float *quat;         /* Rotation quaternion of the data to transform                                   */
-       float  iquat[4];         /* Initial rotation quaternion                                                    */
-       float *rotAngle;         /* Rotation angle of the data to transform                                        */
-       float  irotAngle;        /* Initial rotation angle                                                         */
-       float *rotAxis;          /* Rotation axis of the data to transform                                         */
-       float  irotAxis[4];      /* Initial rotation axis                                                          */
-       float *size;         /* Size of the data to transform                                                  */
-       float  isize[3];         /* Initial size                                                                   */
-       float  obmat[4][4];      /* Object matrix */
-       float  l_smtx[3][3]; /* use instead of td->smtx, It is the same but without the 'bone->bone_mat', see TD_PBONE_LOCAL_MTX_C */
-       float  r_mtx[3][3];  /* The rotscale matrix of pose bone, to allow using snap-align in translation mode,
-                             * when td->mtx is the loc pose bone matrix (and hence can't be used to apply rotation in some cases,
-                             * namely when a bone is in "NoLocal" or "Hinge" mode)... */
-       float  r_smtx[3][3]; /* Inverse of previous one. */
-       int    rotOrder;        /* rotation mode,  as defined in eRotationModes (DNA_action_types.h) */
-       float oloc[3], orot[3], oquat[4], orotAxis[3], orotAngle; /* Original object transformation used for rigid bodies */
+       /** Initial object drot. */
+       float drot[3];
+       // /* Initial object drotAngle,    TODO: not yet implemented */
+       // float drotAngle;
+       // /* Initial object drotAxis, TODO: not yet implemented */
+       // float drotAxis[3];
+       /** Initial object dquat. */
+       float dquat[4];
+       /** Initial object dscale. */
+       float dscale[3];
+       /** Rotation of the data to transform. */
+       float *rot;
+       /** Initial rotation. */
+       float  irot[3];
+       /** Rotation quaternion of the data to transform. */
+       float *quat;
+       /** Initial rotation quaternion. */
+       float  iquat[4];
+       /** Rotation angle of the data to transform. */
+       float *rotAngle;
+       /** Initial rotation angle. */
+       float  irotAngle;
+       /** Rotation axis of the data to transform. */
+       float *rotAxis;
+       /** Initial rotation axis. */
+       float  irotAxis[4];
+       /** Size of the data to transform. */
+       float *size;
+       /** Initial size. */
+       float  isize[3];
+       /** Object matrix. */
+       float  obmat[4][4];
+       /** Use instead of td->smtx,
+        * It is the same but without the 'bone->bone_mat', see TD_PBONE_LOCAL_MTX_C. */
+       float  l_smtx[3][3];
+       /** The rotscale matrix of pose bone, to allow using snap-align in translation mode,
+        * when td->mtx is the loc pose bone matrix (and hence can't be used to apply
+        * rotation in some cases, namely when a bone is in "NoLocal" or "Hinge" mode)... */
+       float  r_mtx[3][3];
+       /** Inverse of previous one. */
+       float  r_smtx[3][3];
+       /** rotation mode, as defined in eRotationModes (DNA_action_types.h). */
+       int    rotOrder;
+       /** Original object transformation used for rigid bodies. */
+       float oloc[3], orot[3], oquat[4], orotAxis[3], orotAngle;
 } TransDataExtension;
 
 typedef struct TransData2D {
-       float loc[3];           /* Location of data used to transform (x,y,0) */
-       float *loc2d;           /* Pointer to real 2d location of data */
+       /** Location of data used to transform (x,y,0). */
+       float loc[3];
+       /** Pointer to real 2d location of data. */
+       float *loc2d;
 
-       float *h1, *h2;     /* Pointer to handle locations, if handles aren't being moved independently */
+       /** Pointer to handle locations, if handles aren't being moved independently. */
+       float *h1, *h2;
        float ih1[2], ih2[2];
 } TransData2D;
 
@@ -185,9 +219,13 @@ typedef struct TransDataCurveHandleFlags {
 /* for sequencer transform */
 typedef struct TransDataSeq {
        struct Sequence *seq;
-       int flag;               /* a copy of seq->flag that may be modified for nested strips */
-       int start_offset; /* use this so we can have transform data at the strips start, but apply correctly to the start frame  */
-       short sel_flag; /* one of SELECT, SEQ_LEFTSEL and SEQ_RIGHTSEL */
+       /** A copy of seq->flag that may be modified for nested strips. */
+       int flag;
+       /** Use this so we can have transform data at the strips start,
+        * but apply correctly to the start frame. */
+       int start_offset;
+       /** one of SELECT, SEQ_LEFTSEL and SEQ_RIGHTSEL. */
+       short sel_flag;
 
 } TransDataSeq;
 
@@ -200,19 +238,27 @@ typedef struct TransSeq {
 
 /* for NLA transform (stored in td->extra pointer) */
 typedef struct TransDataNla {
-       ID *id;                                         /* ID-block NLA-data is attached to */
+       /** ID-block NLA-data is attached to. */
+       ID *id;
 
-       struct NlaTrack *oldTrack;      /* Original NLA-Track that the strip belongs to */
-       struct NlaTrack *nlt;           /* Current NLA-Track that the strip belongs to */
+       /** Original NLA-Track that the strip belongs to. */
+       struct NlaTrack *oldTrack;
+       /** Current NLA-Track that the strip belongs to. */
+       struct NlaTrack *nlt;
 
-       struct NlaStrip *strip;         /* NLA-strip this data represents */
+       /** NLA-strip this data represents. */
+       struct NlaStrip *strip;
 
        /* dummy values for transform to write in - must have 3 elements... */
-       float h1[3];                            /* start handle */
-       float h2[3];                            /* end handle */
-
-       int trackIndex;                         /* index of track that strip is currently in */
-       int handle;                                     /* handle-index: 0 for dummy entry, -1 for start, 1 for end, 2 for both ends */
+       /** start handle. */
+       float h1[3];
+       /** end handle. */
+       float h2[3];
+
+       /** index of track that strip is currently in. */
+       int trackIndex;
+       /** handle-index: 0 for dummy entry, -1 for start, 1 for end, 2 for both ends. */
+       int handle;
 } TransDataNla;
 
 struct LinkNode;
@@ -249,18 +295,19 @@ typedef struct SlideOrigData {
        bool use_origfaces;
        int cd_loop_mdisp_offset;
 
-       struct GHash    *origverts;  /* map {BMVert: TransDataGenericSlideVert} */
+       /** map {BMVert: TransDataGenericSlideVert} */
+       struct GHash    *origverts;
        struct GHash    *origfaces;
        struct BMesh *bm_origfaces;
 
        struct MemArena *arena;
-       /* number of math BMLoop layers */
+       /** Number of math BMLoop layers. */
        int  layer_math_map_num;
-       /* array size of 'layer_math_map_num'
+       /** Array size of 'layer_math_map_num'
         * maps TransDataVertSlideVert.cd_group index to absolute CustomData layer index */
        int *layer_math_map;
 
-       /* array of slide vert data especially for mirror verts */
+       /** Array of slide vert data especially for mirror verts. */
        TransDataGenericSlideVert *sv_mirror;
        int totsv_mirror;
 } SlideOrigData;
@@ -333,36 +380,58 @@ typedef struct BoneInitData {
 } BoneInitData;
 
 typedef struct TransData {
-       float  dist;         /* Distance needed to affect element (for Proportionnal Editing)                  */
-       float  rdist;        /* Distance to the nearest element (for Proportionnal Editing)                    */
-       float  factor;       /* Factor of the transformation (for Proportionnal Editing)                       */
-       float *loc;          /* Location of the data to transform                                              */
-       float  iloc[3];      /* Initial location                                                               */
-       float *val;          /* Value pointer for special transforms */
-       float  ival;         /* Old value*/
-       float  center[3];        /* Individual data center                                                         */
-       float  mtx[3][3];    /* Transformation matrix from data space to global space                          */
-       float  smtx[3][3];   /* Transformation matrix from global space to data space                          */
-       float  axismtx[3][3];/* Axis orientation matrix of the data                                            */
+       /** Distance needed to affect element (for Proportionnal Editing). */
+       float  dist;
+       /** Distance to the nearest element (for Proportionnal Editing). */
+       float  rdist;
+       /** Factor of the transformation (for Proportionnal Editing). */
+       float  factor;
+       /** Location of the data to transform. */
+       float *loc;
+       /** Initial location. */
+       float  iloc[3];
+       /** Value pointer for special transforms. */
+       float *val;
+       /** Old value. */
+       float  ival;
+       /** Individual data center. */
+       float  center[3];
+       /** Transformation matrix from data space to global space. */
+       float  mtx[3][3];
+       /** Transformation matrix from global space to data space. */
+       float  smtx[3][3];
+       /** Axis orientation matrix of the data. */
+       float  axismtx[3][3];
        struct Object *ob;
-       struct bConstraint *con;        /* for objects/bones, the first constraint in its constraint stack */
-       TransDataExtension *ext;        /* for objects, poses. 1 single malloc per TransInfo! */
-       TransDataCurveHandleFlags *hdata; /* for curves, stores handle flags for modification/cancel */
-       void  *extra;            /* extra data (mirrored element pointer, in editmode mesh to BMVert) (editbone for roll fixing) (...) */
-       int  flag;           /* Various flags */
-       short  protectflag;      /* If set, copy of Object or PoseChannel protection */
+       /** For objects/bones, the first constraint in its constraint stack. */
+       struct bConstraint *con;
+       /** For objects, poses. 1 single malloc per TransInfo! */
+       TransDataExtension *ext;
+       /** for curves, stores handle flags for modification/cancel. */
+       TransDataCurveHandleFlags *hdata;
+       /**
+        * Extra data (mirrored element pointer, in editmode mesh to BMVert)
+        * (editbone for roll fixing) (...).
+        */
+       void  *extra;
+       /** Various flags. */
+       int  flag;
+       /** If set, copy of Object or PoseChannel protection. */
+       short  protectflag;
 } TransData;
 
 typedef struct MouseInput {
        void    (*apply)(struct TransInfo *t, struct MouseInput *mi, const double mval[2], float output[3]);
        void    (*post)(struct TransInfo *t, float values[3]);
 
-       int     imval[2];               /* initial mouse position                */
+       /** Initial mouse position. */
+       int     imval[2];
        bool    precision;
        float   precision_factor;
        float   center[2];
        float   factor;
-       void    *data; /* additional data, if needed by the particular function */
+       /** Additional data, if needed by the particular function. */
+       void *data;
 
        /**
         * Use virtual cursor, which takes precision into account
@@ -455,53 +524,85 @@ typedef struct TransInfo {
         * Use to check if nothing is selected or if we have a single selection. */
        int data_len_all;
 
-       int         mode;           /* current mode                         */
-       int             flag;           /* generic flags for special behaviors  */
-       int                     modifiers;              /* special modifiers, by function, not key */
-       short           state;                  /* current state (running, canceled,...)*/
-       int         options;        /* current context/options for transform                      */
-       float       val;            /* init value for some transformations (and rotation angle)  */
+       /** Current mode. */
+       int         mode;
+       /** Generic flags for special behaviors. */
+       int             flag;
+       /** Special modifiers, by function, not key. */
+       int                     modifiers;
+       /** Current state (running, canceled. */
+       short           state;
+       /** Current context/options for transform. */
+       int         options;
+       /** Init value for some transformations (and rotation angle). */
+       float       val;
        void      (*transform)(struct TransInfo *, const int[2]);
-                                                               /* transform function pointer           */
+       /** Transform function pointer. */
        eRedrawFlag (*handleEvent)(struct TransInfo *, const struct wmEvent *);
                                                                /* event handler function pointer  RETURN 1 if redraw is needed */
-       TransCon    con;            /* transformed constraint               */
+       /** transformed constraint. */
+       TransCon    con;
        TransSnap       tsnap;
-       NumInput    num;            /* numerical input                      */
-       MouseInput      mouse;                  /* mouse input                          */
-       eRedrawFlag redraw;         /* redraw flag                          */
-       float           prop_size;              /* proportional circle radius           */
-       char            proptext[20];   /* proportional falloff text                    */
-       float       aspect[3];      /* spaces using non 1:1 aspect, (uv's, f-curve, movie-clip... etc)
-                                    * use for conversion and snapping. */
-       float       center_global[3];  /* center of transformation (in global-space) */
-       float       center2d[2];    /* center in screen coordinates         */
+       /** numerical input. */
+       NumInput    num;
+       /** mouse input. */
+       MouseInput      mouse;
+       /** redraw flag. */
+       eRedrawFlag redraw;
+       /** proportional circle radius. */
+       float           prop_size;
+       /** proportional falloff text. */
+       char            proptext[20];
+       /**
+        * Spaces using non 1:1 aspect, (uv's, f-curve, movie-clip... etc)
+        * use for conversion and snapping.
+        */
+       float       aspect[3];
+       /** center of transformation (in global-space) */
+       float       center_global[3];
+       /** center in screen coordinates. */
+       float       center2d[2];
        /* Lazy initialize center data for when we need other center values.
         * V3D_AROUND_ACTIVE + 1 (static assert checks this) */
        TransCenterData center_cache[5];
-       short       idx_max;            /* maximum index on the input vector    */
-       float           snap[3];                /* Snapping Gears                                               */
-       float           snap_spatial[3]; /* Spatial snapping gears(even when rotating, scaling... etc) */
-       char            frame_side;             /* Mouse side of the cfra, 'L', 'R' or 'B' */
-
-       float           viewmat[4][4];  /* copy from G.vd, prevents feedback,   */
-       float           viewinv[4][4];  /* and to make sure we don't have to    */
-       float           persmat[4][4];  /* access G.vd from other space types   */
+       /** maximum index on the input vector. */
+       short       idx_max;
+       /** Snapping Gears. */
+       float           snap[3];
+       /** Spatial snapping gears(even when rotating, scaling... etc). */
+       float           snap_spatial[3];
+       /** Mouse side of the cfra, 'L', 'R' or 'B' */
+       char            frame_side;
+
+       /** copy from G.vd, prevents feedback. */
+       float           viewmat[4][4];
+       /** and to make sure we don't have to. */
+       float           viewinv[4][4];
+       /** access G.vd from other space types. */
+       float           persmat[4][4];
        float           persinv[4][4];
        short           persp;
        short           around;
-       char            spacetype;              /* spacetype where transforming is      */
-       char            helpline;               /* Choice of custom cursor with or without a help line from the gizmo to the mouse position. */
-       short           obedit_type;    /* Avoid looking inside TransDataContainer obedit. */
-
-       float           vec[3];                 /* translation, to show for widget      */
-       float           mat[3][3];              /* rot/rescale, to show for widget      */
-
-       float           spacemtx[3][3]; /* orientation matrix of the current space      */
-       char            spacename[64];  /* name of the current space, MAX_NAME          */
+       /** spacetype where transforming is. */
+       char            spacetype;
+       /** Choice of custom cursor with or without a help line from the gizmo to the mouse position. */
+       char            helpline;
+       /** Avoid looking inside TransDataContainer obedit. */
+       short           obedit_type;
+
+       /** translation, to show for widget. */
+       float           vec[3];
+       /** rot/rescale, to show for widget. */
+       float           mat[3][3];
+
+       /** orientation matrix of the current space. */
+       float           spacemtx[3][3];
+       /** name of the current space, MAX_NAME. */
+       char            spacename[64];
 
        /*************** NEW STUFF *********************/
-       short           launch_event;   /* event type used to launch transform */
+       /** event type used to launch transform. */
+       short           launch_event;
 
        struct {
                short           user;
@@ -512,23 +613,28 @@ typedef struct TransInfo {
                /* this gets used when custom_orientation is V3D_MANIP_CUSTOM */
                TransformOrientation *custom;
        } orientation;
-       short           gizmo_flag;                     /* backup from view3d, to restore on end */
+       /** backup from view3d, to restore on end. */
+       short           gizmo_flag;
 
        short           prop_mode;
 
        short           mirror;
 
        float           values[4];
-       float           values_modal_offset[4];  /* Offset applied ontop of modal input. */
+       /** Offset applied ontop of modal input. */
+       float           values_modal_offset[4];
        float           auto_values[4];
        float           axis[3];
-       float           axis_orig[3];   /* TransCon can change 'axis', store the original value here */
+       /** TransCon can change 'axis', store the original value here. */
+       float           axis_orig[3];
        float           axis_ortho[3];
 
-       bool            remove_on_cancel; /* remove elements if operator is canceled */
+       /** remove elements if operator is canceled. */
+       bool            remove_on_cancel;
 
        void            *view;
-       struct bContext *context; /* Only valid (non null) during an operator called function. */
+       /** Only valid (non null) during an operator called function. */
+       struct bContext *context;
        struct ScrArea  *sa;
        struct ARegion  *ar;
        struct Depsgraph *depsgraph;
@@ -536,10 +642,14 @@ typedef struct TransInfo {
        struct ViewLayer *view_layer;
        struct ToolSettings *settings;
        struct wmTimer *animtimer;
-       struct wmKeyMap *keymap;  /* so we can do lookups for header text */
-       struct ReportList *reports;  /* assign from the operator, or can be NULL */
-       int         mval[2];        /* current mouse position               */
-       float       zfac;           /* use for 3d view */
+       /** so we can do lookups for header text. */
+       struct wmKeyMap *keymap;
+       /** assign from the operator, or can be NULL. */
+       struct ReportList *reports;
+       /** current mouse position. */
+       int         mval[2];
+       /** use for 3d view. */
+       float       zfac;
        void            *draw_handle_apply;
        void            *draw_handle_view;
        void            *draw_handle_pixel;
index 74c72e159b477e468ac492822fb684a7f30f081e..746b27bd9b3584b55debe226823532ad70618e66 100644 (file)
@@ -303,9 +303,12 @@ private:
        typedef std::map<const char *, Vec2f, StringUtils::ltstr> Vec2fMap;
        typedef std::map<const char *, Vec3f, StringUtils::ltstr> Vec3fMap;
 
-       float _color[3];      //! the color
-       float _alpha;         //! alpha
-       float _thickness[2];  //! the thickness on the right and on the left of the backbone vertex (the stroke is oriented)
+       //! the color
+       float _color[3];
+       //! alpha
+       float _alpha;
+       //! the thickness on the right and on the left of the backbone vertex (the stroke is oriented)
+       float _thickness[2];
        bool _visible;
        realMap *_userAttributesReal;
        Vec2fMap *_userAttributesVec2f;
index 2c795a8d9ad76369ff8492173956bf8cc565eae8..9629b0924adb05e20cee18483c1c738b208ce641 100644 (file)
@@ -231,7 +231,8 @@ static Mesh *applyModifier(
        float axis_vec[3] = {0.0f, 0.0f, 0.0f};
        float tmp_vec1[3], tmp_vec2[3];
        float mat3[3][3];
-       float mtx_tx[4][4]; /* transform the coords by an object relative to this objects transformation */
+       /* transform the coords by an object relative to this objects transformation */
+       float mtx_tx[4][4];
        float mtx_tx_inv[4][4]; /* inverted */
        float mtx_tmp_a[4][4];