style cleanup
authorCampbell Barton <ideasman42@gmail.com>
Sat, 27 Oct 2012 10:42:28 +0000 (10:42 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sat, 27 Oct 2012 10:42:28 +0000 (10:42 +0000)
30 files changed:
doc/python_api/rst/info_overview.rst
source/blender/blenkernel/intern/blender.c
source/blender/blenkernel/intern/curve.c
source/blender/blenkernel/intern/fmodifier.c
source/blender/blenkernel/intern/multires.c
source/blender/blenkernel/intern/nla.c
source/blender/blenkernel/intern/ocean.c
source/blender/blenkernel/intern/particle_system.c
source/blender/blenkernel/intern/seqeffects.c
source/blender/blenlib/BLI_voronoi.h
source/blender/blenlib/intern/math_geom.c
source/blender/blenlib/intern/scanfill.c
source/blender/blenlib/intern/voxel.c
source/blender/blenloader/intern/readfile.c
source/blender/editors/animation/keyingsets.c
source/blender/editors/curve/editcurve.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/interface/interface_handlers.c
source/blender/editors/object/object_vgroup.c
source/blender/editors/physics/physics_fluid.c
source/blender/editors/sculpt_paint/paint_image.c
source/blender/editors/space_view3d/view3d_draw.c
source/blender/editors/space_view3d/view3d_intern.h
source/blender/editors/space_view3d/view3d_view.c
source/blender/editors/util/editmode_undo.c
source/blender/makesrna/intern/makesrna.c
source/blender/modifiers/intern/MOD_laplaciansmooth.c
source/blender/render/intern/source/occlusion.c
source/gameengine/GameLogic/Joystick/SCA_Joystick.cpp
source/gameengine/Ketsji/KX_CameraActuator.cpp

index 30c4521..818eb69 100644 (file)
@@ -71,7 +71,7 @@ The only difference between addons and built-in python modules is that addons mu
 
 The user preferences addon listing uses **bl_info** to display information about each addon.
 
-`See Addons <http://wiki.blender.org/index.php/Dev:2.6/Py/Scripts/Guidelines/Addons>`_ for details on the **bl_info** dictionary.
+`See Addons <http://wiki.blender.org/index.php/Dev:2.5/Py/Scripts/Guidelines/Addons>`_ for details on the **bl_info** dictionary.
 
 
 Integration through Classes
index 5257137..c6fa2de 100644 (file)
@@ -612,7 +612,7 @@ void BKE_write_undo(bContext *C, const char *name)
        }
 }
 
-/* 1= an undo, -1 is a redo. we have to make sure 'curundo' remains at current situation */
+/* 1 = an undo, -1 is a redo. we have to make sure 'curundo' remains at current situation */
 void BKE_undo_step(bContext *C, int step)
 {
        
index 90a07b2..06dad49 100644 (file)
@@ -1050,10 +1050,13 @@ void BKE_nurb_makeFaces(Nurb *nu, float *coord_array, int rowstride, int resolu,
        MEM_freeN(jend);
 }
 
+/**
+ * \param coord_array Has to be 3 * 4 * pntsu * resolu in size and zero-ed
+ * \param tilt_array   set when non-NULL
+ * \param radius_array set when non-NULL
+ */
 void BKE_nurb_makeCurve(Nurb *nu, float *coord_array, float *tilt_array, float *radius_array, float *weight_array,
                         int resolu, int stride)
-/* coord_array has to be 3*4*pntsu*resolu in size and zero-ed
- * tilt_array and radius_array will be written to if valid */
 {
        BPoint *bp;
        float u, ustart, uend, ustep, sumdiv;
index dbdf798..2b393b4 100644 (file)
@@ -276,7 +276,7 @@ static FModifierTypeInfo FMI_GENERATOR = {
 /* Built-In Function Generator F-Curve Modifier --------------------------- */
 
 /* This uses the general equation for equations:
- *   y = amplitude * fn(phase_multiplier*x + phase_offset) + y_offset
+ *   y = amplitude * fn(phase_multiplier * x + phase_offset) + y_offset
  *
  * where amplitude, phase_multiplier/offset, y_offset are user-defined coefficients,
  * x is the evaluation 'time', and 'y' is the resultant value
index 33d68cc..d34bb99 100644 (file)
@@ -1045,7 +1045,7 @@ static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, DerivedMesh *dm
 
        k = 0; /*current loop/mdisp index within the mloop array*/
 
-       #pragma omp parallel for private(i) if (totloop*gridSize*gridSize >= CCG_OMP_LIMIT)
+       #pragma omp parallel for private(i) if (totloop * gridSize * gridSize >= CCG_OMP_LIMIT)
 
        for (i = 0; i < totpoly; ++i) {
                const int numVerts = mpoly[i].totloop;
@@ -1325,7 +1325,7 @@ void multires_set_space(DerivedMesh *dm, Object *ob, int from, int to)
 
        k = 0; /*current loop/mdisp index within the mloop array*/
 
-       //#pragma omp parallel for private(i) if (dm->numLoopData*gridSize*gridSize >= CCG_OMP_LIMIT)
+       //#pragma omp parallel for private(i) if (dm->numLoopData * gridSize * gridSize >= CCG_OMP_LIMIT)
 
        for (i = 0; i < dm->numPolyData; ++i) {
                const int numVerts = mpoly[i].totloop;
@@ -2200,7 +2200,7 @@ static void multires_apply_smat(Scene *scene, Object *ob, float smat[3][3])
        dGridSize = multires_side_tot[high_mmd.totlvl];
        dSkip = (dGridSize - 1) / (gridSize - 1);
 
-       #pragma omp parallel for private(i) if (me->totface*gridSize*gridSize*4 >= CCG_OMP_LIMIT)
+       #pragma omp parallel for private(i) if (me->totface * gridSize * gridSize * 4 >= CCG_OMP_LIMIT)
        for (i = 0; i < me->totpoly; ++i) {
                const int numVerts = mpoly[i].totloop;
                MDisps *mdisp = &mdisps[mpoly[i].loopstart];
index 19c9de1..6f58519 100644 (file)
@@ -423,7 +423,7 @@ static float nlastrip_get_frame_actionclip(NlaStrip *strip, float cframe, short
                                return strip->actstart;
                        }
                        else {
-                               /* - the 'fmod(..., actlength*scale)' is needed to get the repeats working
+                               /* - the 'fmod(..., actlength * scale)' is needed to get the repeats working
                                 * - the '/ scale' is needed to ensure that scaling influences the timing within the repeat
                                 */
                                return strip->actend - fmodf(cframe - strip->start, actlength * scale) / scale;
@@ -446,7 +446,7 @@ static float nlastrip_get_frame_actionclip(NlaStrip *strip, float cframe, short
                                return strip->actend;
                        }
                        else {
-                               /* - the 'fmod(..., actlength*scale)' is needed to get the repeats working
+                               /* - the 'fmod(..., actlength * scale)' is needed to get the repeats working
                                 * - the '/ scale' is needed to ensure that scaling influences the timing within the repeat
                                 */
                                return strip->actstart + fmodf(cframe - strip->start, actlength * scale) / scale;
index 4f39219..7bc736d 100644 (file)
@@ -475,7 +475,7 @@ void BKE_ocean_eval_ij(struct Ocean *oc, struct OceanResult *ocr, int i, int j)
 
        if (oc->_do_normals) {
                ocr->normal[0] = oc->_N_x[i * oc->_N + j];
-               ocr->normal[1] = oc->_N_y /*oc->_N_y[i*oc->_N+j] (MEM01)*/;
+               ocr->normal[1] = oc->_N_y  /* oc->_N_y[i * oc->_N + j] (MEM01) */;
                ocr->normal[2] = oc->_N_z[i * oc->_N + j];
 
                normalize_v3(ocr->normal);
index 2490935..19ef83d 100644 (file)
@@ -4119,7 +4119,7 @@ static void particles_fluid_step(ParticleSimulationData *sim, int UNUSED(cfra))
                                int ptype=0;
        
                                gzread(gzf, &ptype, sizeof( ptype )); 
-                               if (ptype&readMask) {
+                               if (ptype & readMask) {
                                        activeParts++;
        
                                        gzread(gzf, &(pa->size), sizeof(float));
index 790bd49..4698810 100644 (file)
@@ -1178,7 +1178,7 @@ static void do_mul_effect_float(float facf0, float facf1, int x, int y, float *r
        fac3 = facf1;
 
        /* formula:
-        *              fac*(a*b) + (1-fac)*a  => fac*a*(b-1)+a
+        * fac * (a * b) + (1 - fac) * a  =>  fac * a * (b - 1) + a
         */
 
        while (y--) {
index a67b01c..68d7398 100644 (file)
@@ -49,7 +49,7 @@ typedef struct VoronoiEdge {
        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 */
 
-       float f, g;                             /* directional coeffitients satisfying equation y = f*x + g (edge lies on this line) */
+       float f, g;                             /* directional coeffitients satisfying equation y = f * x + g (edge lies on this line) */
 
        /* 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 *neighbour;
index 77ae0f1..a01ba84 100644 (file)
@@ -2352,10 +2352,10 @@ void resolve_quad_uv(float r_uv[2], const float st[2], const float st0[2], const
                                   (st2[0] * st3[1] - st2[1] * st3[0]) + (st3[0] * st0[1] - st3[1] * st0[0]);
 
        /* X is 2D cross product (determinant)
-        * A= (p0-p) X (p0-p3)*/
+        * A = (p0 - p) X (p0 - p3)*/
        const double a = (st0[0] - st[0]) * (st0[1] - st3[1]) - (st0[1] - st[1]) * (st0[0] - st3[0]);
 
-       /* B= ( (p0-p) X (p1-p2) + (p1-p) X (p0-p3) ) / 2 */
+       /* B = ( (p0 - p) X (p1 - p2) + (p1 - p) X (p0 - p3) ) / 2 */
        const double b = 0.5 * (((st0[0] - st[0]) * (st1[1] - st2[1]) - (st0[1] - st[1]) * (st1[0] - st2[0])) +
                                ((st1[0] - st[0]) * (st0[1] - st3[1]) - (st1[1] - st[1]) * (st0[0] - st3[0])));
 
index 8a5e8c2..362a877 100644 (file)
@@ -985,12 +985,12 @@ int BLI_scanfill_calc_ex(ScanFillContext *sf_ctx, const short do_quad_tri_speedu
 
 
        /* CURRENT STATUS:
-        * - eve->f       :1= availalble in edges
+        * - eve->f       :1 = availalble in edges
         * - eve->xs      :polynumber
         * - eve->h       :amount of edges connected to vertex
         * - eve->tmp.v   :store! original vertex number
         * 
-        * - eed->f       :1= boundary edge (optionally set by caller)
+        * - eed->f       :1 = boundary edge (optionally set by caller)
         * - eed->poly_nr :poly number
         */
 
index bc775cb..5d58f9e 100644 (file)
@@ -117,19 +117,19 @@ float BLI_voxel_sample_triquadratic(float *data, const int res[3], const float c
                const int zc[3] = {res[0] * res[1] * _clamp(z - 1, 0, res[2] - 1), res[0] * res[1] * _clamp(z, 0, res[2] - 1), res[0] * res[1] * _clamp(z + 1, 0, res[2] - 1)};
 
                const float dx = xf - (float)x, dy = yf - (float)y, dz = zf - (float)z;
-               const float u[3] = {dx*(0.5f*dx - 1.f) + 0.5f, dx*(1.f - dx) + 0.5f, 0.5f*dx*dx};
-               const float v[3] = {dy*(0.5f*dy - 1.f) + 0.5f, dy*(1.f - dy) + 0.5f, 0.5f*dy*dy};
-               const float w[3] = {dz*(0.5f*dz - 1.f) + 0.5f, dz*(1.f - dz) + 0.5f, 0.5f*dz*dz};
+               const float u[3] = {dx * (0.5f * dx - 1.f) + 0.5f, dx * (1.0f - dx) + 0.5f, 0.5f * dx * dx};
+               const float v[3] = {dy * (0.5f * dy - 1.f) + 0.5f, dy * (1.0f - dy) + 0.5f, 0.5f * dy * dy};
+               const float w[3] = {dz * (0.5f * dz - 1.f) + 0.5f, dz * (1.0f - dz) + 0.5f, 0.5f * dz * dz};
 
                return w[0] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[0]] + u[1] * data[xc[1] + yc[0] + zc[0]] + u[2] * data[xc[2] + yc[0] + zc[0]] )
-                                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[0]] + u[1] * data[xc[1] + yc[1] + zc[0]] + u[2] * data[xc[2] + yc[1] + zc[0]] )
-                                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[0]] + u[1] * data[xc[1] + yc[2] + zc[0]] + u[2] * data[xc[2] + yc[2] + zc[0]] ) )
-                        + w[1] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[1]] + u[1] * data[xc[1] + yc[0] + zc[1]] + u[2] * data[xc[2] + yc[0] + zc[1]] )
-                                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[1]] + u[1] * data[xc[1] + yc[1] + zc[1]] + u[2] * data[xc[2] + yc[1] + zc[1]] )
-                                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[1]] + u[1] * data[xc[1] + yc[2] + zc[1]] + u[2] * data[xc[2] + yc[2] + zc[1]] ) )
-                        + w[2] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[2]] + u[1] * data[xc[1] + yc[0] + zc[2]] + u[2] * data[xc[2] + yc[0] + zc[2]] )
-                                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[2]] + u[1] * data[xc[1] + yc[1] + zc[2]] + u[2] * data[xc[2] + yc[1] + zc[2]] )
-                                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[2]] + u[1] * data[xc[1] + yc[2] + zc[2]] + u[2] * data[xc[2] + yc[2] + zc[2]] ) );
+                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[0]] + u[1] * data[xc[1] + yc[1] + zc[0]] + u[2] * data[xc[2] + yc[1] + zc[0]] )
+                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[0]] + u[1] * data[xc[1] + yc[2] + zc[0]] + u[2] * data[xc[2] + yc[2] + zc[0]] ) )
+                    + w[1] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[1]] + u[1] * data[xc[1] + yc[0] + zc[1]] + u[2] * data[xc[2] + yc[0] + zc[1]] )
+                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[1]] + u[1] * data[xc[1] + yc[1] + zc[1]] + u[2] * data[xc[2] + yc[1] + zc[1]] )
+                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[1]] + u[1] * data[xc[1] + yc[2] + zc[1]] + u[2] * data[xc[2] + yc[2] + zc[1]] ) )
+                    + w[2] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[2]] + u[1] * data[xc[1] + yc[0] + zc[2]] + u[2] * data[xc[2] + yc[0] + zc[2]] )
+                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[2]] + u[1] * data[xc[1] + yc[1] + zc[2]] + u[2] * data[xc[2] + yc[1] + zc[2]] )
+                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[2]] + u[1] * data[xc[1] + yc[2] + zc[2]] + u[2] * data[xc[2] + yc[2] + zc[2]] ) );
 
        }
        return 0.f;
@@ -179,21 +179,21 @@ float BLI_voxel_sample_tricubic(float *data, const int res[3], const float co[3]
                }
 
                return w[0] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[0]] + u[1] * data[xc[1] + yc[0] + zc[0]] + u[2] * data[xc[2] + yc[0] + zc[0]] + u[3] * data[xc[3] + yc[0] + zc[0]] )
-                                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[0]] + u[1] * data[xc[1] + yc[1] + zc[0]] + u[2] * data[xc[2] + yc[1] + zc[0]] + u[3] * data[xc[3] + yc[1] + zc[0]] )
-                                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[0]] + u[1] * data[xc[1] + yc[2] + zc[0]] + u[2] * data[xc[2] + yc[2] + zc[0]] + u[3] * data[xc[3] + yc[2] + zc[0]] )
-                                               + v[3] * ( u[0] * data[xc[0] + yc[3] + zc[0]] + u[1] * data[xc[1] + yc[3] + zc[0]] + u[2] * data[xc[2] + yc[3] + zc[0]] + u[3] * data[xc[3] + yc[3] + zc[0]] ) )
-                        + w[1] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[1]] + u[1] * data[xc[1] + yc[0] + zc[1]] + u[2] * data[xc[2] + yc[0] + zc[1]] + u[3] * data[xc[3] + yc[0] + zc[1]] )
-                                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[1]] + u[1] * data[xc[1] + yc[1] + zc[1]] + u[2] * data[xc[2] + yc[1] + zc[1]] + u[3] * data[xc[3] + yc[1] + zc[1]] )
-                                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[1]] + u[1] * data[xc[1] + yc[2] + zc[1]] + u[2] * data[xc[2] + yc[2] + zc[1]] + u[3] * data[xc[3] + yc[2] + zc[1]] )
-                                               + v[3] * ( u[0] * data[xc[0] + yc[3] + zc[1]] + u[1] * data[xc[1] + yc[3] + zc[1]] + u[2] * data[xc[2] + yc[3] + zc[1]] + u[3] * data[xc[3] + yc[3] + zc[1]] ) )
-                        + w[2] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[2]] + u[1] * data[xc[1] + yc[0] + zc[2]] + u[2] * data[xc[2] + yc[0] + zc[2]] + u[3] * data[xc[3] + yc[0] + zc[2]] )
-                                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[2]] + u[1] * data[xc[1] + yc[1] + zc[2]] + u[2] * data[xc[2] + yc[1] + zc[2]] + u[3] * data[xc[3] + yc[1] + zc[2]] )
-                                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[2]] + u[1] * data[xc[1] + yc[2] + zc[2]] + u[2] * data[xc[2] + yc[2] + zc[2]] + u[3] * data[xc[3] + yc[2] + zc[2]] )
-                                               + v[3] * ( u[0] * data[xc[0] + yc[3] + zc[2]] + u[1] * data[xc[1] + yc[3] + zc[2]] + u[2] * data[xc[2] + yc[3] + zc[2]] + u[3] * data[xc[3] + yc[3] + zc[2]] ) )
-                        + w[3] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[3]] + u[1] * data[xc[1] + yc[0] + zc[3]] + u[2] * data[xc[2] + yc[0] + zc[3]] + u[3] * data[xc[3] + yc[0] + zc[3]] )
-                                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[3]] + u[1] * data[xc[1] + yc[1] + zc[3]] + u[2] * data[xc[2] + yc[1] + zc[3]] + u[3] * data[xc[3] + yc[1] + zc[3]] )
-                                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[3]] + u[1] * data[xc[1] + yc[2] + zc[3]] + u[2] * data[xc[2] + yc[2] + zc[3]] + u[3] * data[xc[3] + yc[2] + zc[3]] )
-                                               + v[3] * ( u[0] * data[xc[0] + yc[3] + zc[3]] + u[1] * data[xc[1] + yc[3] + zc[3]] + u[2] * data[xc[2] + yc[3] + zc[3]] + u[3] * data[xc[3] + yc[3] + zc[3]] ) );
+                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[0]] + u[1] * data[xc[1] + yc[1] + zc[0]] + u[2] * data[xc[2] + yc[1] + zc[0]] + u[3] * data[xc[3] + yc[1] + zc[0]] )
+                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[0]] + u[1] * data[xc[1] + yc[2] + zc[0]] + u[2] * data[xc[2] + yc[2] + zc[0]] + u[3] * data[xc[3] + yc[2] + zc[0]] )
+                               + v[3] * ( u[0] * data[xc[0] + yc[3] + zc[0]] + u[1] * data[xc[1] + yc[3] + zc[0]] + u[2] * data[xc[2] + yc[3] + zc[0]] + u[3] * data[xc[3] + yc[3] + zc[0]] ) )
+                    + w[1] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[1]] + u[1] * data[xc[1] + yc[0] + zc[1]] + u[2] * data[xc[2] + yc[0] + zc[1]] + u[3] * data[xc[3] + yc[0] + zc[1]] )
+                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[1]] + u[1] * data[xc[1] + yc[1] + zc[1]] + u[2] * data[xc[2] + yc[1] + zc[1]] + u[3] * data[xc[3] + yc[1] + zc[1]] )
+                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[1]] + u[1] * data[xc[1] + yc[2] + zc[1]] + u[2] * data[xc[2] + yc[2] + zc[1]] + u[3] * data[xc[3] + yc[2] + zc[1]] )
+                               + v[3] * ( u[0] * data[xc[0] + yc[3] + zc[1]] + u[1] * data[xc[1] + yc[3] + zc[1]] + u[2] * data[xc[2] + yc[3] + zc[1]] + u[3] * data[xc[3] + yc[3] + zc[1]] ) )
+                    + w[2] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[2]] + u[1] * data[xc[1] + yc[0] + zc[2]] + u[2] * data[xc[2] + yc[0] + zc[2]] + u[3] * data[xc[3] + yc[0] + zc[2]] )
+                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[2]] + u[1] * data[xc[1] + yc[1] + zc[2]] + u[2] * data[xc[2] + yc[1] + zc[2]] + u[3] * data[xc[3] + yc[1] + zc[2]] )
+                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[2]] + u[1] * data[xc[1] + yc[2] + zc[2]] + u[2] * data[xc[2] + yc[2] + zc[2]] + u[3] * data[xc[3] + yc[2] + zc[2]] )
+                               + v[3] * ( u[0] * data[xc[0] + yc[3] + zc[2]] + u[1] * data[xc[1] + yc[3] + zc[2]] + u[2] * data[xc[2] + yc[3] + zc[2]] + u[3] * data[xc[3] + yc[3] + zc[2]] ) )
+                    + w[3] * (   v[0] * ( u[0] * data[xc[0] + yc[0] + zc[3]] + u[1] * data[xc[1] + yc[0] + zc[3]] + u[2] * data[xc[2] + yc[0] + zc[3]] + u[3] * data[xc[3] + yc[0] + zc[3]] )
+                               + v[1] * ( u[0] * data[xc[0] + yc[1] + zc[3]] + u[1] * data[xc[1] + yc[1] + zc[3]] + u[2] * data[xc[2] + yc[1] + zc[3]] + u[3] * data[xc[3] + yc[1] + zc[3]] )
+                               + v[2] * ( u[0] * data[xc[0] + yc[2] + zc[3]] + u[1] * data[xc[1] + yc[2] + zc[3]] + u[2] * data[xc[2] + yc[2] + zc[3]] + u[3] * data[xc[3] + yc[2] + zc[3]] )
+                               + v[3] * ( u[0] * data[xc[0] + yc[3] + zc[3]] + u[1] * data[xc[1] + yc[3] + zc[3]] + u[2] * data[xc[2] + yc[3] + zc[3]] + u[3] * data[xc[3] + yc[3] + zc[3]] ) );
 
        }
        return 0.f;
index 72f74fb..070c6b2 100644 (file)
@@ -2799,7 +2799,7 @@ static void switch_endian_keyblock(Key *key, KeyBlock *kb)
                        
                        cp += 2;
                }
-               data+= elemsize;
+               data += elemsize;
        }
 }
 
index 95e7dab..ae7abd8 100644 (file)
@@ -377,7 +377,7 @@ void ANIM_OT_keyingset_button_add(wmOperatorType *ot)
        
        /* callbacks */
        ot->exec = add_keyingset_button_exec; 
-       //op->poll= ???
+       //op->poll = ???
        
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
index 685ae34..9ae5d3c 100644 (file)
@@ -3091,7 +3091,7 @@ static void subdividenurb(Object *obedit, int number_cuts)
                                nu->pntsv = (number_cuts + 1) * nu->pntsv - number_cuts;
                                BKE_nurb_knot_calc_u(nu);
                                BKE_nurb_knot_calc_v(nu);
-                       } /* End of 'if (sel == nu->pntsu*nu->pntsv)' (subdivide entire NURB) */
+                       } /* End of 'if (sel == nu->pntsu * nu->pntsv)' (subdivide entire NURB) */
                        else {
                                /* subdivide in v direction? */
                                sel = 0;
index cd6668e..42ea924 100644 (file)
@@ -959,8 +959,8 @@ static int gp_session_initdata(bContext *C, tGPsdata *p)
                /* supported views first */
                case SPACE_VIEW3D:
                {
-                       // View3D *v3d= curarea->spacedata.first;
-                       // RegionView3D *rv3d= ar->regiondata;
+                       // View3D *v3d = curarea->spacedata.first;
+                       // RegionView3D *rv3d = ar->regiondata;
                        
                        /* set current area 
                         *      - must verify that region data is 3D-view (and not something else)
@@ -979,7 +979,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p)
 
                case SPACE_NODE:
                {
-                       //SpaceNode *snode= curarea->spacedata.first;
+                       //SpaceNode *snode = curarea->spacedata.first;
                        
                        /* set current area */
                        p->sa = curarea;
@@ -1007,7 +1007,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p)
                break;
                case SPACE_IMAGE:
                {
-                       //SpaceImage *sima= curarea->spacedata.first;
+                       //SpaceImage *sima = curarea->spacedata.first;
                        
                        /* set the current area */
                        p->sa = curarea;
index 0b66c55..2ebc2f3 100644 (file)
@@ -1784,7 +1784,7 @@ static void ui_textedit_begin(bContext *C, uiBut *but, uiHandleButtonData *data)
        /* optional searchbox */
        if (but->type == SEARCH_MENU) {
                data->searchbox = ui_searchbox_create(C, data->region, but);
-               ui_searchbox_update(C, data->searchbox, but, 1); /* 1= reset */
+               ui_searchbox_update(C, data->searchbox, but, 1); /* 1 = reset */
        }
        
        ui_check_but(but);
index 6c2503e..c0f9ecf 100644 (file)
@@ -1174,8 +1174,8 @@ static void getVerticalAndHorizontalChange(const float norm[3], float d, const f
                                            const float start[3], float distToStart,
                                            float *end, float (*changes)[2], float *dists, int index)
 {
-       // A=Q-((Q-P).N)N
-       // D = (a*x0 + b*y0 +c*z0 +d)
+       /* A = Q - ((Q - P).N)N
+        * D = (a * x0 + b * y0 +c * z0 + d) */
        float projA[3], projB[3];
 
        closest_to_plane_v3(projA, coord, norm, start);
index 1225589..4a31307 100644 (file)
@@ -402,7 +402,7 @@ static void fluid_init_all_channels(bContext *C, Object *UNUSED(fsDomain), Fluid
        }
        
        /* now we loop over the frames and fill the allocated channels with data */
-       for (i=0; i<channels->length; i++) {
+       for (i=0; i < channels->length; i++) {
                FluidObject *fobj;
                float viscosity, gravity[3];
                float timeAtFrame, time;
index 8c8a5ce..91a0a38 100644 (file)
@@ -3561,7 +3561,7 @@ static void project_paint_end(ProjPaintState *ps)
                ps->dm->release(ps->dm);
 }
 
-/* 1= an undo, -1 is a redo. */
+/* 1 = an undo, -1 is a redo. */
 static void partial_redraw_array_init(ImagePaintPartialRedraw *pr)
 {
        int tot = PROJ_BOUNDBOX_SQUARED;
index 0cb4fc0..d61ba5f 100644 (file)
@@ -2133,7 +2133,7 @@ void draw_depth_gpencil(Scene *scene, ARegion *ar, View3D *v3d)
        short zbuf = v3d->zbuf;
        RegionView3D *rv3d = ar->regiondata;
 
-       setwinmatrixview3d(ar, v3d, NULL);  /* 0= no pick rect */
+       setwinmatrixview3d(ar, v3d, NULL);
        setviewmatrixview3d(scene, v3d, rv3d);  /* note: calls BKE_object_where_is_calc for camera... */
 
        mult_m4_m4m4(rv3d->persmat, rv3d->winmat, rv3d->viewmat);
@@ -2168,7 +2168,7 @@ void draw_depth(Scene *scene, ARegion *ar, View3D *v3d, int (*func)(void *))
        U.glalphaclip = 0.5; /* not that nice but means we wont zoom into billboards */
        U.obcenter_dia = 0;
        
-       setwinmatrixview3d(ar, v3d, NULL);  /* 0= no pick rect */
+       setwinmatrixview3d(ar, v3d, NULL);
        setviewmatrixview3d(scene, v3d, rv3d);  /* note: calls BKE_object_where_is_calc for camera... */
        
        mult_m4_m4m4(rv3d->persmat, rv3d->winmat, rv3d->viewmat);
@@ -2456,7 +2456,7 @@ void ED_view3d_update_viewmat(Scene *scene, View3D *v3d, ARegion *ar, float view
        if (winmat)
                copy_m4_m4(rv3d->winmat, winmat);
        else
-               setwinmatrixview3d(ar, v3d, NULL);  /* NULL= no pickrect */
+               setwinmatrixview3d(ar, v3d, NULL);
 
        /* setup view matrix */
        if (viewmat)
index 3017891..5beeda9 100644 (file)
@@ -177,7 +177,7 @@ int ED_view3d_boundbox_clip(RegionView3D * rv3d, float obmat[][4], struct BoundB
 void view3d_smooth_view(struct bContext *C, struct View3D *v3d, struct ARegion *ar, struct Object *, struct Object *,
                         float *ofs, float *quat, float *dist, float *lens);
 
-void setwinmatrixview3d(ARegion *ar, View3D *v3d, rctf *rect);  /* rect: for picking */
+void setwinmatrixview3d(ARegion *ar, View3D *v3d, rctf *rect);
 void setviewmatrixview3d(Scene *scene, View3D *v3d, RegionView3D *rv3d);
 
 void fly_modal_keymap(struct wmKeyConfig *keyconf);
index 7c6645c..c16f04f 100644 (file)
@@ -658,7 +658,10 @@ int ED_view3d_viewplane_get(View3D *v3d, RegionView3D *rv3d, int winx, int winy,
        return params.is_ortho;
 }
 
-void setwinmatrixview3d(ARegion *ar, View3D *v3d, rctf *rect)       /* rect: for picking */
+/*!
+ * \param rect for picking, NULL not to use.
+ */
+void setwinmatrixview3d(ARegion *ar, View3D *v3d, rctf *rect)
 {
        RegionView3D *rv3d = ar->regiondata;
        rctf viewplane;
@@ -691,7 +694,7 @@ void setwinmatrixview3d(ARegion *ar, View3D *v3d, rctf *rect)       /* rect: for
                
                if (orth) wmOrtho(rect->xmin, rect->xmax, rect->ymin, rect->ymax, -clipend, clipend);
                else wmFrustum(rect->xmin, rect->xmax, rect->ymin, rect->ymax, clipsta, clipend);
-               
+
        }
        else {
                if (orth) wmOrtho(x1, x2, y1, y2, clipsta, clipend);
index b645b98..c8c26ed 100644 (file)
@@ -233,7 +233,7 @@ static void undo_clean_stack(bContext *C)
        if (curundo == NULL) curundo = undobase.last;
 }
 
-/* 1= an undo, -1 is a redo. we have to make sure 'curundo' remains at current situation */
+/* 1 = an undo, -1 is a redo. we have to make sure 'curundo' remains at current situation */
 void undo_editmode_step(bContext *C, int step)
 {
        Object *obedit = CTX_data_edit_object(C);
index df51715..d71c279 100644 (file)
@@ -657,17 +657,17 @@ static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                                                                        "get_length");
                                                fprintf(f, "    int i, arraylen[RNA_MAX_ARRAY_DIMENSION];\n");
                                                fprintf(f, "    int len= %s(ptr, arraylen);\n\n", lenfunc);
-                                               fprintf(f, "    for (i=0; i<len; i++) {\n");
+                                               fprintf(f, "    for (i=0; i < len; i++) {\n");
                                                MEM_freeN(lenfunc);
                                        }
                                        else {
                                                fprintf(f, "    int i;\n\n");
-                                               fprintf(f, "    for (i=0; i<%u; i++) {\n", prop->totarraylength);
+                                               fprintf(f, "    for (i=0; i < %u; i++) {\n", prop->totarraylength);
                                        }
 
                                        if (dp->dnaarraylength == 1) {
                                                if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
-                                                       fprintf(f, "            values[i] = %s((data->%s & (%d<<i)) != 0);\n",
+                                                       fprintf(f, "            values[i] = %s((data->%s & (%d << i)) != 0);\n",
                                                                (dp->booleannegative) ? "!" : "", dp->dnaname, dp->booleanbit);
                                                }
                                                else {
@@ -683,7 +683,7 @@ static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                                        fprintf(f, ") != 0);\n");
                                                }
                                                else if (rna_color_quantize(prop, dp)) {
-                                                       fprintf(f, "            values[i] = (%s)(data->%s[i]*(1.0f/255.0f));\n",
+                                                       fprintf(f, "            values[i] = (%s)(data->%s[i]*(1.0f / 255.0f));\n",
                                                                rna_type_type(prop), dp->dnaname);
                                                }
                                                else if (dp->dnatype) {
@@ -908,20 +908,20 @@ static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                                fprintf(f, "    int i, arraylen[RNA_MAX_ARRAY_DIMENSION];\n");
                                                fprintf(f, "    int len= %s(ptr, arraylen);\n\n", lenfunc);
                                                rna_clamp_value_range(f, prop);
-                                               fprintf(f, "    for (i=0; i<len; i++) {\n");
+                                               fprintf(f, "    for (i=0; i < len; i++) {\n");
                                                MEM_freeN(lenfunc);
                                        }
                                        else {
                                                fprintf(f, "    int i;\n\n");
                                                rna_clamp_value_range(f, prop);
-                                               fprintf(f, "    for (i=0; i<%u; i++) {\n", prop->totarraylength);
+                                               fprintf(f, "    for (i=0; i < %u; i++) {\n", prop->totarraylength);
                                        }
 
                                        if (dp->dnaarraylength == 1) {
                                                if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
                                                        fprintf(f, "            if (%svalues[i]) data->%s |= (%d<<i);\n",
                                                                (dp->booleannegative) ? "!" : "", dp->dnaname, dp->booleanbit);
-                                                       fprintf(f, "            else data->%s &= ~(%d<<i);\n", dp->dnaname, dp->booleanbit);
+                                                       fprintf(f, "            else data->%s &= ~(%d << i);\n", dp->dnaname, dp->booleanbit);
                                                }
                                                else {
                                                        fprintf(f, "            (&data->%s)[i] = %s", dp->dnaname, (dp->booleannegative) ? "!" : "");
index d20fd15..83ab238 100644 (file)
@@ -84,10 +84,10 @@ static CustomDataMask required_data_mask(Object *UNUSED(ob), ModifierData *md);
 static int is_disabled(ModifierData *md, int UNUSED(useRenderParams));
 static float compute_volume(float (*vertexCos)[3], MFace *mfaces, int numFaces);
 static float cotan_weight(float *v1, float *v2, float *v3);
-static LaplacianSystem * init_laplacian_system( int a_numEdges, int a_numFaces, int a_numVerts);
+static LaplacianSystem *init_laplacian_system(int a_numEdges, int a_numFaces, int a_numVerts);
 static void copy_data(ModifierData *md, ModifierData *target);
 static void delete_laplacian_system(LaplacianSystem *sys);
-static void delete_void_pointer(void * data);
+static void delete_void_pointer(void *data);
 static void fill_laplacian_matrix(LaplacianSystem *sys);
 static void init_data(ModifierData *md);
 static void init_laplacian_matrix(LaplacianSystem *sys);
@@ -95,7 +95,7 @@ static void memset_laplacian_system(LaplacianSystem *sys, int val);
 static void volume_preservation(LaplacianSystem *sys, float vini, float vend, short flag);
 static void validate_solution(LaplacianSystem *sys, short flag);
 
-static void delete_void_pointer(void * data)
+static void delete_void_pointer(void *data)
 {
        if (data) {
                MEM_freeN(data);
@@ -134,7 +134,7 @@ static void memset_laplacian_system(LaplacianSystem *sys, int val)
        memset(sys->zerola,       val, sizeof(short) * sys->numVerts);
 }
 
-static LaplacianSystem * init_laplacian_system( int a_numEdges, int a_numFaces, int a_numVerts) 
+static LaplacianSystem *init_laplacian_system(int a_numEdges, int a_numFaces, int a_numVerts)
 {
        LaplacianSystem *sys;
        sys = MEM_callocN(sizeof(LaplacianSystem), "ModLaplSmoothSystem");
@@ -147,7 +147,7 @@ static LaplacianSystem * init_laplacian_system( int a_numEdges, int a_numFaces,
                delete_laplacian_system(sys);
                return NULL;
        }
-       
+
        sys->fweights =  MEM_callocN(sizeof(float) * 3 * sys->numFaces, "ModLaplSmoothFWeight");
        if (!sys->fweights) {
                delete_laplacian_system(sys);
@@ -159,19 +159,19 @@ static LaplacianSystem * init_laplacian_system( int a_numEdges, int a_numFaces,
                delete_laplacian_system(sys);
                return NULL;
        }
-       
+
        sys->numNeFa =  MEM_callocN(sizeof(short) * sys->numVerts, "ModLaplSmoothNumNeFa");
        if (!sys->numNeFa) {
                delete_laplacian_system(sys);
                return NULL;
        }
-       
+
        sys->ring_areas =  MEM_callocN(sizeof(float) * sys->numVerts, "ModLaplSmoothRingAreas");
        if (!sys->ring_areas) {
                delete_laplacian_system(sys);
                return NULL;
        }
-       
+
        sys->vlengths =  MEM_callocN(sizeof(float) * sys->numVerts, "ModLaplSmoothVlengths");
        if (!sys->vlengths) {
                delete_laplacian_system(sys);
@@ -223,7 +223,7 @@ static int is_disabled(ModifierData *md, int UNUSED(useRenderParams))
        flag = smd->flag & (MOD_LAPLACIANSMOOTH_X | MOD_LAPLACIANSMOOTH_Y | MOD_LAPLACIANSMOOTH_Z);
 
        /* disable if modifier is off for X, Y and Z or if factor is 0 */
-       if ( flag == 0) return 1;
+       if (flag == 0) return 1;
 
        return 0;
 }
@@ -251,7 +251,7 @@ static float cotan_weight(float *v1, float *v2, float *v3)
 
        if (clen == 0.0f)
                return 0.0f;
-       
+
        return dot_v3v3(a, b) / clen;
 }
 
@@ -261,7 +261,7 @@ static float compute_volume(float (*vertexCos)[3], MFace *mfaces, int numFaces)
        float x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4;
        int i;
        float *vf[4];
-       for (i = 0; i<numFaces; i++) {
+       for (i = 0; i < numFaces; i++) {
                vf[0] = vertexCos[mfaces[i].v1];
                vf[1] = vertexCos[mfaces[i].v2];
                vf[2] = vertexCos[mfaces[i].v3];
@@ -277,18 +277,18 @@ static float compute_volume(float (*vertexCos)[3], MFace *mfaces, int numFaces)
                x3 = vf[2][0];
                y3 = vf[2][1];
                z3 = vf[2][2];
-               
 
-               vol +=  (1.0 / 6.0) * (x2*y3*z1 + x3*y1*z2 - x1*y3*z2 - x2*y1*z3 + x1*y2*z3 - x3*y2*z1);
+
+               vol +=  (1.0 / 6.0) * (x2 * y3 * z1 + x3 * y1 * z2 - x1 * y3 * z2 - x2 * y1 * z3 + x1 * y2 * z3 - x3 * y2 * z1);
                if ((&mfaces[i])->v4) {
                        vf[3] = vertexCos[mfaces[i].v4];
                        x4 = vf[3][0];
                        y4 = vf[3][1];
                        z4 = vf[3][2];
-                       vol += (1.0 / 6.0) * (x1*y3*z4 - x1*y4*z3 - x3*y1*z4 + x3*z1*y4 + y1*x4*z3 - x4*y3*z1);
+                       vol += (1.0 / 6.0) * (x1 * y3 * z4 - x1 * y4 * z3 - x3 * y1 * z4 + x3 * z1 * y4 + y1 * x4 * z3 - x4 * y3 * z1);
                }
        }
-       return fabs(vol);
+       return fabsfvol);
 }
 
 static void volume_preservation(LaplacianSystem *sys, float vini, float vend, short flag)
@@ -296,8 +296,8 @@ static void volume_preservation(LaplacianSystem *sys, float vini, float vend, sh
        float beta;
        int i;
 
-       if (vend != 0.0f) {     
-               beta  = pow (vini / vend, 1.0f / 3.0f);
+       if (vend != 0.0f) {
+               beta  = pow(vini / vend, 1.0f / 3.0f);
                for (i = 0; i < sys->numVerts; i++) {
                        if (flag & MOD_LAPLACIANSMOOTH_X) {
                                sys->vertexCos[i][0] = (sys->vertexCos[i][0] - sys->vert_centroid[0]) * beta + sys->vert_centroid[0];
@@ -308,7 +308,7 @@ static void volume_preservation(LaplacianSystem *sys, float vini, float vend, sh
                        if (flag & MOD_LAPLACIANSMOOTH_Z) {
                                sys->vertexCos[i][2] = (sys->vertexCos[i][2] - sys->vert_centroid[2]) * beta + sys->vert_centroid[2];
                        }
-                       
+
                }
        }
 }
@@ -320,8 +320,8 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
        float areaf;
        int i, j;
        unsigned int idv1, idv2, idv3, idv4, idv[4];
-       int has_4_vert ;
-       for ( i = 0; i < sys->numEdges; i++) {
+       int has_4_vert;
+       for (i = 0; i < sys->numEdges; i++) {
                idv1 = sys->medges[i].v1;
                idv2 = sys->medges[i].v2;
 
@@ -338,17 +338,17 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
                else {
                        w1 = 1.0f / w1;
                }
-               
+
                sys->eweights[i] = w1;
        }
-       for ( i = 0; i < sys->numFaces; i++) {
+       for (i = 0; i < sys->numFaces; i++) {
                has_4_vert = ((&sys->mfaces[i])->v4) ? 1 : 0;
 
                idv1 = sys->mfaces[i].v1;
                idv2 = sys->mfaces[i].v2;
                idv3 = sys->mfaces[i].v3;
                idv4 = has_4_vert ? sys->mfaces[i].v4 : 0;
-               
+
                sys->numNeFa[idv1] += 1;
                sys->numNeFa[idv2] += 1;
                sys->numNeFa[idv3] += 1;
@@ -358,14 +358,14 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
                v2 = sys->vertexCos[idv2];
                v3 = sys->vertexCos[idv3];
                v4 = has_4_vert ? sys->vertexCos[idv4] : 0;
-               
+
                if (has_4_vert) {
                        areaf = area_quad_v3(v1, v2, v3, sys->vertexCos[sys->mfaces[i].v4]);
                }
                else {
                        areaf = area_tri_v3(v1, v2, v3);
                }
-               if (fabs(areaf) < sys->min_area) { 
+               if (fabs(areaf) < sys->min_area) {
                        sys->zerola[idv1] = 1;
                        sys->zerola[idv2] = 1;
                        sys->zerola[idv3] = 1;
@@ -378,7 +378,7 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
                if (has_4_vert) sys->ring_areas[idv4] += areaf;
 
                if (has_4_vert) {
-                       
+
                        idv[0] = idv1;
                        idv[1] = idv2;
                        idv[2] = idv3;
@@ -398,7 +398,7 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
                                w2 = cotan_weight(v4, v1, v2) + cotan_weight(v3, v1, v2);
                                w3 = cotan_weight(v2, v3, v1) + cotan_weight(v4, v1, v3);
                                w4 = cotan_weight(v2, v4, v1) + cotan_weight(v3, v4, v1);
-       
+
                                sys->vweights[idv1] += (w2 + w3 + w4) / 4.0f;
                        }
                }
@@ -410,17 +410,17 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
                        sys->fweights[i][0] = sys->fweights[i][0] + w1;
                        sys->fweights[i][1] = sys->fweights[i][1] + w2;
                        sys->fweights[i][2] = sys->fweights[i][2] + w3;
-                       
+
                        sys->vweights[idv1] = sys->vweights[idv1] + w2 + w3;
                        sys->vweights[idv2] = sys->vweights[idv2] + w1 + w3;
                        sys->vweights[idv3] = sys->vweights[idv3] + w1 + w2;
                }
        }
-       for ( i = 0; i < sys->numEdges; i++) {
+       for (i = 0; i < sys->numEdges; i++) {
                idv1 = sys->medges[i].v1;
                idv2 = sys->medges[i].v2;
                /* if is boundary, apply scale-dependent umbrella operator only with neighboors in boundary */
-               if (sys->numNeEd[idv1] != sys->numNeFa[idv1] && sys->numNeEd[idv2] != sys->numNeFa[idv2]) { 
+               if (sys->numNeEd[idv1] != sys->numNeFa[idv1] && sys->numNeEd[idv2] != sys->numNeFa[idv2]) {
                        sys->vlengths[idv1] += sys->eweights[i];
                        sys->vlengths[idv2] += sys->eweights[i];
                }
@@ -433,10 +433,10 @@ static void fill_laplacian_matrix(LaplacianSystem *sys)
        float *v1, *v2, *v3, *v4;
        float w2, w3, w4;
        int i, j;
-       int has_4_vert ;
+       int has_4_vert;
        unsigned int idv1, idv2, idv3, idv4, idv[4];
-       
-       for ( i = 0; i < sys->numFaces; i++) {
+
+       for (i = 0; i < sys->numFaces; i++) {
                idv1 = sys->mfaces[i].v1;
                idv2 = sys->mfaces[i].v2;
                idv3 = sys->mfaces[i].v3;
@@ -465,8 +465,8 @@ static void fill_laplacian_matrix(LaplacianSystem *sys)
                                w2 = w2 / 4.0f;
                                w3 = w3 / 4.0f;
                                w4 = w4 / 4.0f;
-               
-                               if (sys->numNeEd[idv1] == sys->numNeFa[idv1] && sys->zerola[idv1] == 0) { 
+
+                               if (sys->numNeEd[idv1] == sys->numNeFa[idv1] && sys->zerola[idv1] == 0) {
                                        nlMatrixAdd(idv1, idv2, w2 * sys->vweights[idv1]);
                                        nlMatrixAdd(idv1, idv3, w3 * sys->vweights[idv1]);
                                        nlMatrixAdd(idv1, idv4, w4 * sys->vweights[idv1]);
@@ -475,33 +475,33 @@ static void fill_laplacian_matrix(LaplacianSystem *sys)
                }
                else {
                        /* Is ring if number of faces == number of edges around vertice*/
-                       if (sys->numNeEd[idv1] == sys->numNeFa[idv1] && sys->zerola[idv1] == 0) { 
+                       if (sys->numNeEd[idv1] == sys->numNeFa[idv1] && sys->zerola[idv1] == 0) {
                                nlMatrixAdd(idv1, idv2, sys->fweights[i][2] * sys->vweights[idv1]);
                                nlMatrixAdd(idv1, idv3, sys->fweights[i][1] * sys->vweights[idv1]);
                        }
-                       if (sys->numNeEd[idv2] == sys->numNeFa[idv2] && sys->zerola[idv2] == 0) { 
+                       if (sys->numNeEd[idv2] == sys->numNeFa[idv2] && sys->zerola[idv2] == 0) {
                                nlMatrixAdd(idv2, idv1, sys->fweights[i][2] * sys->vweights[idv2]);
                                nlMatrixAdd(idv2, idv3, sys->fweights[i][0] * sys->vweights[idv2]);
                        }
-                       if (sys->numNeEd[idv3] == sys->numNeFa[idv3] && sys->zerola[idv3] == 0) { 
+                       if (sys->numNeEd[idv3] == sys->numNeFa[idv3] && sys->zerola[idv3] == 0) {
                                nlMatrixAdd(idv3, idv1, sys->fweights[i][1] * sys->vweights[idv3]);
                                nlMatrixAdd(idv3, idv2, sys->fweights[i][0] * sys->vweights[idv3]);
                        }
                }
        }
 
-       for ( i = 0; i < sys->numEdges; i++) {
+       for (i = 0; i < sys->numEdges; i++) {
                idv1 = sys->medges[i].v1;
                idv2 = sys->medges[i].v2;
                /* Is boundary */
-               if (sys->numNeEd[idv1] != sys->numNeFa[idv1] && 
-                       sys->numNeEd[idv2] != sys->numNeFa[idv2] && 
-                       sys->zerola[idv1] == 0 && 
-                       sys->zerola[idv2] == 0) 
+               if (sys->numNeEd[idv1] != sys->numNeFa[idv1] &&
+                   sys->numNeEd[idv2] != sys->numNeFa[idv2] &&
+                   sys->zerola[idv1] == 0 &&
+                   sys->zerola[idv2] == 0)
                {
                        nlMatrixAdd(idv1, idv2, sys->eweights[i] * sys->vlengths[idv1]);
                        nlMatrixAdd(idv2, idv1, sys->eweights[i] * sys->vlengths[idv2]);
-               }       
+               }
        }
 }
 
@@ -514,7 +514,7 @@ static void validate_solution(LaplacianSystem *sys, short flag)
        if (flag & MOD_LAPLACIANSMOOTH_VOLUME_PRESERVATION) {
                vini = compute_volume(sys->vertexCos, sys->mfaces, sys->numFaces);
        }
-       for ( i = 0; i < sys->numEdges; i++) {
+       for (i = 0; i < sys->numEdges; i++) {
                idv1 = sys->medges[i].v1;
                idv2 = sys->medges[i].v2;
                vi1 = sys->vertexCos[idv1];
@@ -527,7 +527,7 @@ static void validate_solution(LaplacianSystem *sys, short flag)
                ve2[2] = nlGetVariable(2, idv2);
                leni = len_v3v3(vi1, vi2);
                lene = len_v3v3(ve1, ve2);
-               if ( lene > leni*MOD_LAPLACIANSMOOTH_MAX_EDGE_PERCENTAGE || lene < leni*MOD_LAPLACIANSMOOTH_MIN_EDGE_PERCENTAGE ){
+               if (lene > leni * MOD_LAPLACIANSMOOTH_MAX_EDGE_PERCENTAGE || lene < leni * MOD_LAPLACIANSMOOTH_MIN_EDGE_PERCENTAGE) {
                        sys->zerola[idv1] = 1;
                        sys->zerola[idv2] = 1;
                }
@@ -552,8 +552,8 @@ static void validate_solution(LaplacianSystem *sys, short flag)
 }
 
 static void laplaciansmoothModifier_do(
-        LaplacianSmoothModifierData *smd, Object *ob, DerivedMesh *dm,
-        float (*vertexCos)[3], int numVerts)
+    LaplacianSmoothModifierData *smd, Object *ob, DerivedMesh *dm,
+    float (*vertexCos)[3], int numVerts)
 {
        LaplacianSystem *sys;
        MDeformVert *dvert = NULL;
@@ -589,7 +589,7 @@ static void laplaciansmoothModifier_do(
 
                init_laplacian_matrix(sys);
 
-               nlBegin(NL_SYSTEM);     
+               nlBegin(NL_SYSTEM);
                for (i = 0; i < numVerts; i++) {
                        nlSetVariable(0, i, vertexCos[i][0]);
                        nlSetVariable(1, i, vertexCos[i][1]);
@@ -622,7 +622,7 @@ static void laplaciansmoothModifier_do(
                                w = sys->vlengths[i];
                                sys->vlengths[i] = (w == 0.0f) ? 0.0f : -smd->lambda_border * wpaint * 2.0f / w;
 
-                               if (sys->numNeEd[i] == sys->numNeFa[i]) { 
+                               if (sys->numNeEd[i] == sys->numNeFa[i]) {
                                        nlMatrixAdd(i, i,  1.0f + smd->lambda * wpaint / (4.0f * sys->ring_areas[i]));
                                }
                                else {
@@ -655,7 +655,7 @@ static void deformVerts(ModifierData *md, Object *ob, DerivedMesh *derivedData,
        DerivedMesh *dm = get_dm(ob, NULL, derivedData, NULL, 0);
 
        laplaciansmoothModifier_do((LaplacianSmoothModifierData *)md, ob, dm,
-                         vertexCos, numVerts);
+                                  vertexCos, numVerts);
 
        if (dm != derivedData)
                dm->release(dm);
@@ -668,7 +668,7 @@ static void deformVertsEM(
        DerivedMesh *dm = get_dm(ob, editData, derivedData, NULL, 0);
 
        laplaciansmoothModifier_do((LaplacianSmoothModifierData *)md, ob, dm,
-                         vertexCos, numVerts);
+                                  vertexCos, numVerts);
 
        if (dm != derivedData)
                dm->release(dm);
index 6e9e45c..a730882 100644 (file)
@@ -1547,7 +1547,7 @@ static int sample_occ_cache(OcclusionTree *tree, float *co, float *n, int x, int
 
        for (i = 0; i < 4; i++) {
                sub_v3_v3v3(d, samples[i]->co, co);
-               //dist2= dot_v3v3(d, d);
+               //dist2 = dot_v3v3(d, d);
 
                wz[i] = 1.0f; //(samples[i]->dist2/(1e-4f + dist2));
                wn[i] = pow(dot_v3v3(samples[i]->n, n), 32.0f);
index 2031409..8b343be 100644 (file)
@@ -88,9 +88,9 @@ SCA_Joystick *SCA_Joystick::GetInstance( short int joyindex )
        if (m_refCount == 0) 
        {
                int i;
-               // The video subsystem is required for joystick input to work. However,
-               // when GHOST is running under SDL, video is initialized elsewhere.
-               // Do this once only.
+               /* The video subsystem is required for joystick input to work. However,
+                * when GHOST is running under SDL, video is initialized elsewhere.
+                * Do this once only. */
 #  ifdef WITH_GHOST_SDL
                if (SDL_InitSubSystem(SDL_INIT_JOYSTICK) == -1 ) {
 #  else
@@ -130,9 +130,9 @@ void SCA_Joystick::ReleaseInstance()
                        m_instance[i] = NULL;
                }
 
-               // The video subsystem is required for joystick input to work. However,
-               // when GHOST is running under SDL, video is freed elsewhere.
-               // Do this once only.
+               /* The video subsystem is required for joystick input to work. However,
+                * when GHOST is running under SDL, video is freed elsewhere.
+                * Do this once only. */
 #  ifdef WITH_GHOST_SDL
                SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
 #  else
@@ -241,10 +241,10 @@ bool SCA_Joystick::CreateJoystickDevice(void)
 #else /* WITH_SDL */
        if (m_isinit == false) {
                if (m_joyindex>=m_joynum) {
-                       // don't print a message, because this is done anyway
+                       /* don't print a message, because this is done anyway */
                        //ECHO("Joystick-Error: " << SDL_NumJoysticks() << " avaiable joystick(s)");
                        
-                       // Need this so python args can return empty lists
+                       /* Need this so python args can return empty lists */
                        m_axismax = m_buttonmax = m_hatmax = 0;
                        return false;
                }
@@ -256,17 +256,17 @@ bool SCA_Joystick::CreateJoystickDevice(void)
                ECHO("Joystick " << m_joyindex << " initialized");
                
                /* must run after being initialized */
-               m_axismax =             SDL_JoystickNumAxes(m_private->m_joystick);
-               m_buttonmax =   SDL_JoystickNumButtons(m_private->m_joystick);
-               m_hatmax =              SDL_JoystickNumHats(m_private->m_joystick);
-               
-               if (m_axismax > JOYAXIS_MAX) m_axismax= JOYAXIS_MAX;            /* very unlikely */
-               else if (m_axismax < 0) m_axismax = 0;
+               m_axismax     = SDL_JoystickNumAxes(m_private->m_joystick);
+               m_buttonmax   = SDL_JoystickNumButtons(m_private->m_joystick);
+               m_hatmax      = SDL_JoystickNumHats(m_private->m_joystick);
+
+               if      (m_axismax > JOYAXIS_MAX) m_axismax = JOYAXIS_MAX;  /* very unlikely */
+               else if (m_axismax < 0)           m_axismax = 0;
                
-               if (m_hatmax > JOYHAT_MAX) m_hatmax= JOYHAT_MAX;                        /* very unlikely */
-               else if (m_hatmax<0) m_hatmax= 0;
+               if      (m_hatmax > JOYHAT_MAX) m_hatmax = JOYHAT_MAX;  /* very unlikely */
+               else if (m_hatmax < 0)          m_hatmax = 0;
                
-               if (m_buttonmax<0) m_buttonmax= 0;
+               if (m_buttonmax < 0) m_buttonmax = 0;
                
        }
        return true;
@@ -307,16 +307,16 @@ int SCA_Joystick::pGetAxis(int axisnum, int udlr)
 int SCA_Joystick::pAxisTest(int axisnum)
 {
 #ifdef WITH_SDL
-       short i1= m_axis_array[(axisnum*2)];
-       short i2= m_axis_array[(axisnum*2)+1];
+       short i1 = m_axis_array[(axisnum * 2)];
+       short i2 = m_axis_array[(axisnum * 2) + 1];
        
-       /* long winded way to do
-        *   return max_ff(absf(i1), absf(i2))
-        * avoid abs from math.h */
+       /* long winded way to do:
+        * return max_ff(absf(i1), absf(i2))
+        * ...avoid abs from math.h */
        if (i1 < 0) i1 = -i1;
        if (i2 < 0) i2 = -i2;
        if (i1 <i2) return i2;
-       else            return i1;
+       else        return i1;
 #else /* WITH_SDL */
        return 0;
 #endif /* WITH_SDL */
index daa3e23..a37b1b0 100644 (file)
@@ -281,13 +281,13 @@ bool KX_CameraActuator::Update(double curtime, bool frame)
                        assert(0);
                        break;
        }
-       
+
        inp = fp1[0]*fp2[0] + fp1[1]*fp2[1] + fp1[2]*fp2[2];
        fac = (-1.0f + inp) * m_damping;
 
-       from[0]+= fac*fp1[0];
-       from[1]+= fac*fp1[1];
-       from[2]+= fac*fp1[2];
+       from[0] += fac * fp1[0];
+       from[1] += fac * fp1[1];
+       from[2] += fac * fp1[2];
        
        /* alleen alstie ervoor ligt: cross testen en loodrechte bijtellen */
        if (inp < 0.0f) {