Cleanup: comment blocks
authorCampbell Barton <ideasman42@gmail.com>
Sun, 2 Sep 2018 08:51:31 +0000 (18:51 +1000)
committerCampbell Barton <ideasman42@gmail.com>
Sun, 2 Sep 2018 08:51:31 +0000 (18:51 +1000)
85 files changed:
intern/ghost/intern/GHOST_Context.h
intern/ghost/intern/GHOST_DropTargetWin32.cpp
intern/ghost/intern/GHOST_System.h
intern/ghost/intern/GHOST_SystemWin32.cpp
intern/ghost/intern/GHOST_SystemX11.h
intern/ghost/intern/GHOST_Window.h
source/blender/blenkernel/BKE_constraint.h
source/blender/blenkernel/intern/bvhutils.c
source/blender/blenkernel/intern/cloth.c
source/blender/blenkernel/intern/dynamicpaint.c
source/blender/blenkernel/intern/fcurve.c
source/blender/blenkernel/intern/fmodifier.c
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/particle.c
source/blender/blenkernel/intern/seqeffects.c
source/blender/blenkernel/intern/sequencer.c
source/blender/blenkernel/intern/smoke.c
source/blender/blenkernel/intern/softbody.c
source/blender/blenlib/BLI_bitmap.h
source/blender/blenlib/intern/DLRB_tree.c
source/blender/blenlib/intern/math_geom.c
source/blender/blenlib/intern/math_interp.c
source/blender/blenlib/intern/string_utils.c
source/blender/blenlib/intern/task.c
source/blender/bmesh/intern/bmesh_interp.c
source/blender/bmesh/intern/bmesh_opdefines.c
source/blender/bmesh/intern/bmesh_polygon.c
source/blender/bmesh/intern/bmesh_private.h
source/blender/bmesh/intern/bmesh_query.c
source/blender/bmesh/operators/bmo_smooth_laplacian.c
source/blender/bmesh/tools/bmesh_bevel.c
source/blender/collada/AnimationExporter.cpp
source/blender/collada/ArmatureImporter.cpp
source/blender/collada/DocumentImporter.cpp
source/blender/collada/ErrorHandler.cpp
source/blender/collada/collada_utils.cpp
source/blender/collada/collada_utils.h
source/blender/compositor/intern/COM_NodeConverter.h
source/blender/editors/animation/drivers.c
source/blender/editors/animation/keyframes_general.c
source/blender/editors/armature/armature_relations.c
source/blender/editors/armature/editarmature_retarget.c
source/blender/editors/armature/pose_edit.c
source/blender/editors/gpencil/editaction_gpencil.c
source/blender/editors/gpencil/gpencil_intern.h
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/gpencil/gpencil_select.c
source/blender/editors/include/ED_keyframing.h
source/blender/editors/interface/interface_templates.c
source/blender/editors/interface/view2d.c
source/blender/editors/mask/mask_editaction.c
source/blender/editors/mesh/meshtools.c
source/blender/editors/object/object_constraint.c
source/blender/editors/object/object_random.c
source/blender/editors/physics/dynamicpaint_ops.c
source/blender/editors/screen/screen_edit.c
source/blender/editors/space_nla/nla_channels.c
source/blender/editors/transform/transform_conversions.c
source/blender/editors/uvedit/uvedit_smart_stitch.c
source/blender/freestyle/intern/image/GaussianFilter.h
source/blender/freestyle/intern/scene_graph/IndexedFaceSet.h
source/blender/freestyle/intern/view_map/ViewMap.h
source/blender/freestyle/intern/winged_edge/WEdge.h
source/blender/freestyle/intern/winged_edge/WXEdge.h
source/blender/imbuf/intern/dds/ColorBlock.cpp
source/blender/imbuf/intern/dds/DirectDrawSurface.cpp
source/blender/imbuf/intern/iris.c
source/blender/imbuf/intern/tiff.c
source/blender/makesdna/DNA_object_force_types.h
source/blender/makesdna/DNA_particle_types.h
source/blender/makesdna/DNA_scene_types.h
source/blender/makesrna/RNA_define.h
source/blender/makesrna/intern/rna_brush.c
source/blender/makesrna/intern/rna_dynamicpaint.c
source/blender/makesrna/intern/rna_particle.c
source/blender/physics/intern/implicit_blender.c
source/blender/physics/intern/implicit_eigen.cpp
source/blender/python/generic/py_capi_utils.c
source/blender/python/intern/gpu.c
source/blender/python/mathutils/mathutils_Vector.c
source/blender/render/intern/source/render_texture.c
source/blender/windowmanager/WM_api.h
source/blender/windowmanager/intern/wm_jobs.c
source/blender/windowmanager/wm_event_types.h
source/creator/creator.c

index 18d36c4..93c0f46 100644 (file)
@@ -112,9 +112,10 @@ public:
                return GHOST_kFailure;
        }
 
-       /** Stereo visual created. Only necessary for 'real' stereo support,
-        *  ie quad buffered stereo. This is not always possible, depends on
-        *  the graphics h/w
+       /**
+        * Stereo visual created. Only necessary for 'real' stereo support,
+        * ie quad buffered stereo. This is not always possible, depends on
+        * the graphics h/w
         */
        inline bool isStereoVisual() const {
                return m_stereoVisual;
index de12dfa..72463b4 100644 (file)
@@ -60,7 +60,7 @@ GHOST_DropTargetWin32::~GHOST_DropTargetWin32()
 
 
 /*
- *  IUnknown::QueryInterface
+ * IUnknown::QueryInterface
  */
 HRESULT __stdcall GHOST_DropTargetWin32::QueryInterface(REFIID riid, void **ppvObj)
 {
@@ -82,7 +82,7 @@ HRESULT __stdcall GHOST_DropTargetWin32::QueryInterface(REFIID riid, void **ppvO
 
 
 /*
- *     IUnknown::AddRef
+ * IUnknown::AddRef
  */
 
 ULONG __stdcall GHOST_DropTargetWin32::AddRef(void)
index 2fd8603..464d926 100644 (file)
@@ -184,7 +184,7 @@ public:
        /**
         * Inherited from GHOST_ISystem but left pure virtual
         *
-        *  virtual bool processEvents(bool waitForEvent) = 0;
+        * virtual bool processEvents(bool waitForEvent) = 0;
         */
 
 
@@ -213,9 +213,12 @@ public:
         * Cursor management functionality
         ***************************************************************************************/
 
-       /** Inherited from GHOST_ISystem but left pure virtual
-        *      GHOST_TSuccess getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const = 0;
-        *  GHOST_TSuccess setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y)
+       /**
+        * Inherited from GHOST_ISystem but left pure virtual
+        * <pre>
+        * GHOST_TSuccess getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const = 0;
+        * GHOST_TSuccess setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y)
+        * </pre>
         */
 
        /***************************************************************************************
index ae4aae3..c2ad3b0 100644 (file)
@@ -1332,9 +1332,9 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, UINT msg, WPARAM wParam,
                                        break;
                                case WM_DPICHANGED:
                                        /* The WM_DPICHANGED message is sent when the effective dots per inch (dpi) for a window has changed.
-                                       * The DPI is the scale factor for a window. There are multiple events that can cause the DPI to
-                                       * change such as when the window is moved to a monitor with a different DPI.
-                                       */
+                                        * The DPI is the scale factor for a window. There are multiple events that can cause the DPI to
+                                        * change such as when the window is moved to a monitor with a different DPI.
+                                        */
                                        {
                                                WORD newYAxisDPI = HIWORD(wParam);
                                                WORD newXAxisDPI = LOWORD(wParam);
index ed1542e..3a65ff2 100644 (file)
@@ -377,7 +377,7 @@ private:
        char m_keyboard_vector[32];
 
        /* to prevent multiple warp, we store the time of the last warp event
-        *  and stop accumulating all events generated before that */
+        * and stop accumulating all events generated before that */
        Time m_last_warp;
 
        /* detect autorepeat glitch */
index e6a4682..59d3123 100644 (file)
@@ -296,9 +296,9 @@ public:
        }
 
        /**
-       * Returns the recommended DPI for this window.
-       * \return The recommended DPI for this window.
-       */
+        * Returns the recommended DPI for this window.
+        * \return The recommended DPI for this window.
+        */
        virtual inline GHOST_TUns16 getDPIHint()
        {
                return 96;
index 5e7a3f4..293ac30 100644 (file)
@@ -66,16 +66,18 @@ typedef void (*ConstraintIDFunc)(struct bConstraint *con, struct ID **idpoin, bo
 
 /* ....... */
 
-/* Constraint Type-Info (shorthand in code = cti):
- *  This struct provides function pointers for runtime, so that functions can be
- *  written more generally (with fewer/no special exceptions for various constraints).
+/**
+ * Constraint Type-Info (shorthand in code = cti):
+ * This struct provides function pointers for runtime, so that functions can be
+ * written more generally (with fewer/no special exceptions for various constraints).
  *
- *  Callers of these functions must check that they actually point to something useful,
- *  as some constraints don't define some of these.
+ * Callers of these functions must check that they actually point to something useful,
+ * as some constraints don't define some of these.
  *
- *  Warning: it is not too advisable to reorder order of members of this struct,
- *                     as you'll have to edit quite a few ($NUM_CONSTRAINT_TYPES) of these
- *                     structs.
+ * Warning:
+ * it is not too advisable to reorder order of members of this struct,
+ * as you'll have to edit quite a few #NUM_CONSTRAINT_TYPES of these
+ * structs.
  */
 typedef struct bConstraintTypeInfo {
        /* admin/ident */
index e48c6ff..151d697 100644 (file)
@@ -1097,7 +1097,7 @@ BVHTree *bvhtree_from_mesh_get(
                                        int looptri_num = dm->getNumLoopTri(dm);
 
                                        /* this assert checks we have looptris,
-                                       * if not caller should use DM_ensure_looptri() */
+                                        * if not caller should use DM_ensure_looptri() */
                                        BLI_assert(!(looptri_num == 0 && dm->getNumPolys(dm) != 0));
 
                                        tree = bvhtree_from_mesh_looptri_create_tree(
index 26f998b..4597eb9 100644 (file)
@@ -553,11 +553,11 @@ void cloth_free_modifier(ClothModifierData *clmd )
                if (cloth->edgeset)
                        BLI_edgeset_free(cloth->edgeset);
 
-
-               /*
-               if (clmd->clothObject->facemarks)
-               MEM_freeN(clmd->clothObject->facemarks);
-               */
+#if 0
+               if (clmd->clothObject->facemarks) {
+                       MEM_freeN(clmd->clothObject->facemarks);
+               }
+#endif
                MEM_freeN ( cloth );
                clmd->clothObject = NULL;
        }
@@ -620,10 +620,11 @@ void cloth_free_modifier_extern(ClothModifierData *clmd )
                        BLI_edgeset_free(cloth->edgeset);
 
 
-               /*
-               if (clmd->clothObject->facemarks)
-               MEM_freeN(clmd->clothObject->facemarks);
-               */
+#if 0
+               if (clmd->clothObject->facemarks) {
+                       MEM_freeN(clmd->clothObject->facemarks);
+               }
+#endif
                MEM_freeN ( cloth );
                clmd->clothObject = NULL;
        }
index ab5fe1d..ed4ee1f 100644 (file)
@@ -1373,7 +1373,7 @@ static void dynamicPaint_initAdjacencyData(DynamicPaintSurface *surface, const b
                }
 
                /* also add number of vertices to temp_data
-                *  to locate points on "mesh edge" */
+                * to locate points on "mesh edge" */
                for (i = 0; i < numOfPolys; i++) {
                        for (int j = 0; j < mpoly[i].totloop; j++) {
                                temp_data[mloop[mpoly[i].loopstart + j].v]++;
@@ -1381,7 +1381,7 @@ static void dynamicPaint_initAdjacencyData(DynamicPaintSurface *surface, const b
                }
 
                /* now check if total number of edges+faces for
-                *  each vertex is even, if not -> vertex is on mesh edge */
+                * each vertex is even, if not -> vertex is on mesh edge */
                for (i = 0; i < sData->total_points; i++) {
                        if ((temp_data[i] % 2) || (temp_data[i] < 4)) {
                                ad->flags[i] |= ADJ_ON_MESH_EDGE;
@@ -1415,7 +1415,7 @@ static void dynamicPaint_initAdjacencyData(DynamicPaintSurface *surface, const b
        }
        else if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
                /* for image sequences, only allocate memory.
-                *  bake initialization takes care of rest */
+                * bake initialization takes care of rest */
        }
 
        MEM_freeN(temp_data);
@@ -1583,7 +1583,7 @@ static void dynamicPaint_setInitialColor(const Scene *scene, DynamicPaintSurface
                        return;
 
                /* for vertex surface loop through tfaces and find uv color
-                *  that provides highest alpha */
+                * that provides highest alpha */
                if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
                        struct ImagePool *pool = BKE_image_pool_new();
 
@@ -2908,7 +2908,7 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
                        int cursor = 0;
 
                        /* Create a temporary array of final indexes (before unassigned
-                        *  pixels have been dropped) */
+                        * pixels have been dropped) */
                        for (int i = 0; i < w * h; i++) {
                                if (tempPoints[i].tri_index != -1) {
                                        final_index[i] = cursor;
@@ -3458,9 +3458,9 @@ static void mesh_tris_spherecast_dp(void *userdata, int index, const BVHTreeRay
 }
 
 /* A modified callback to bvh tree nearest point. The tree must have been built using bvhtree_from_mesh_looptri.
- *  userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree.
+ * userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree.
  *
- *     To optimize brush detection speed this doesn't calculate hit normal.
+ * To optimize brush detection speed this doesn't calculate hit normal.
  */
 static void mesh_tris_nearest_point_dp(void *userdata, int index, const float co[3], BVHTreeNearest *nearest)
 {
@@ -4119,7 +4119,7 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(
                        interp_weights_tri_v3(weights, mvert[v1].co, mvert[v2].co, mvert[v3].co, hitCoord);
 
                        /* simple check based on brush surface velocity,
-                        *  todo: perhaps implement something that handles volume movement as well */
+                        * todo: perhaps implement something that handles volume movement as well. */
 
                        /* interpolate vertex speed vectors to get hit point velocity */
                        interp_v3_v3v3v3(brushPointVelocity,
@@ -4858,7 +4858,7 @@ static void surface_determineForceTargetPoints(
                const float closest_dot = dot_v3v3(bNeighs[n_index].dir, bNeighs[closest_id[0]].dir);
 
                /* only accept neighbor at "other side" of the first one in relation to force dir
-                *  so make sure angle between this and closest neigh is greater than first angle */
+                * so make sure angle between this and closest neigh is greater than first angle. */
                if (dir_dot > closest_d[1] && closest_dot < closest_d[0] && dir_dot > 0.0f) {
                        closest_d[1] = dir_dot;
                        closest_id[1] = n_index;
@@ -4875,7 +4875,7 @@ static void surface_determineForceTargetPoints(
                float temp;
 
                /* project force vector on the plane determined by these two neighbor points
-                *  and calculate relative force angle from it*/
+                * and calculate relative force angle from it. */
                cross_v3_v3v3(tangent, bNeighs[closest_id[0]].dir, bNeighs[closest_id[1]].dir);
                normalize_v3(tangent);
                force_intersect = dot_v3v3(force, tangent);
@@ -5025,7 +5025,7 @@ static void dynamic_paint_prepare_effect_cb(
        /* if global gravity is enabled, add it too */
        if (scene->physics_settings.flag & PHYS_GLOBAL_GRAVITY)
                /* also divide by 10 to about match default grav
-                *  with default force strength (1.0) */
+                * with default force strength (1.0). */
                madd_v3_v3fl(forc, scene->physics_settings.gravity,
                             surface->effector_weights->global_gravity * surface->effector_weights->weight[0] / 10.f);
 
@@ -5087,7 +5087,7 @@ static int dynamicPaint_prepareEffectStep(
        }
 
        /* Get number of required steps using average point distance
-        *  so that just a few ultra close pixels wont up substeps to max */
+        * so that just a few ultra close pixels wont up substeps to max. */
 
        /* adjust number of required substep by fastest active effect */
        if (surface->effect & MOD_DPAINT_EFFECT_DO_SPREAD)
@@ -5188,7 +5188,7 @@ static void dynamic_paint_effect_shrink_cb(
                totalAlpha += pPoint_prev->e_color[3];
 
                /* Check if neighboring point has lower alpha,
-                *  if so, decrease this point's alpha as well*/
+                * if so, decrease this point's alpha as well. */
                if (pPoint->color[3] <= 0.0f && pPoint->e_color[3] <= 0.0f && pPoint->wetness <= 0.0f)
                        continue;
 
@@ -5699,7 +5699,7 @@ static void dynamic_paint_surface_pre_step_cb(
                                        /* now calculate new alpha for dry layer that keeps final blended color unchanged */
                                        pPoint->color[3] = (f_color[3] - pPoint->e_color[3]) / (1.0f - pPoint->e_color[3]);
                                        /* for each rgb component, calculate a new dry layer color that keeps the final blend color
-                                        *  with these new alpha values. (wet layer color doesnt change)*/
+                                        * with these new alpha values. (wet layer color doesnt change)*/
                                        if (pPoint->color[3]) {
                                                for (i = 0; i < 3; i++) {
                                                        pPoint->color[i] = (f_color[i] * f_color[3] - pPoint->e_color[i] * pPoint->e_color[3]) /
index 95e4d2c..6ee6d87 100644 (file)
@@ -2021,8 +2021,8 @@ float evaluate_driver(PathResolvedRNA *anim_rna, ChannelDriver *driver, const fl
                default:
                {
                        /* special 'hack' - just use stored value
-                        *      This is currently used as the mechanism which allows animated settings to be able
-                        *  to be changed via the UI.
+                        * This is currently used as the mechanism which allows animated settings to be able
+                        * to be changed via the UI.
                         */
                        break;
                }
index b69bce0..5911d15 100644 (file)
@@ -273,7 +273,7 @@ static void fcm_fn_generator_new_data(void *mdata)
 }
 
 /* Unary 'normalized sine' function
- *  y = sin(PI + x) / (PI * x),
+ * y = sin(PI + x) / (PI * x),
  * except for x = 0 when y = 1.
  */
 static double sinc(double x)
index 0cf2993..9f63596 100644 (file)
@@ -3647,7 +3647,7 @@ bool BKE_object_modifier_update_subframe(
                if (ob->track) no_update |= BKE_object_modifier_update_subframe(bmain, eval_ctx, scene, ob->track, 0, recursion, frame, type);
 
                /* skip subframe if object is parented
-                *  to vertex of a dynamic paint canvas */
+                * to vertex of a dynamic paint canvas */
                if (no_update && (ob->partype == PARVERT1 || ob->partype == PARVERT3))
                        return false;
 
index 50706a0..b43c537 100644 (file)
@@ -2309,12 +2309,12 @@ static void psys_thread_create_path(ParticleTask *task, struct ChildParticle *cp
 
                /*
                 * NOTE: Should in theory be the same as:
-                cpa_num = psys_particle_dm_face_lookup(
-                       ctx->sim.psmd->dm_final,
-                       ctx->sim.psmd->dm_deformed,
-                       pa->num, pa->fuv,
-                       NULL);
-               */
+                cpa_num = psys_particle_dm_face_lookup(
+                       ctx->sim.psmd->dm_final,
+                       ctx->sim.psmd->dm_deformed,
+                       pa->num, pa->fuv,
+                       NULL);
+                */
                cpa_num = (ELEM(pa->num_dmcache, DMCACHE_ISCHILD, DMCACHE_NOTFOUND))
                        ? pa->num
                        : pa->num_dmcache;
index e3fc494..1a0e395 100644 (file)
@@ -1727,10 +1727,10 @@ static float check_zone(WipeZone *wipezone, int x, int y, Sequence *seq, float f
                        break;
                case DO_CLOCK_WIPE:
                        /*
-                        *  temp1: angle of effect center in rads
-                        *  temp2: angle of line through (halfx, halfy) and (x, y) in rads
-                        *  temp3: angle of low side of blur
-                        *  temp4: angle of high side of blur
+                        * temp1: angle of effect center in rads
+                        * temp2: angle of line through (halfx, halfy) and (x, y) in rads
+                        * temp3: angle of low side of blur
+                        * temp4: angle of high side of blur
                         */
                        output = 1.0f - facf0;
                        widthf = wipe->edgeWidth * 2.0f * (float)M_PI;
index 7e40693..0768fba 100644 (file)
@@ -2410,21 +2410,21 @@ void BKE_sequencer_color_balance_apply(StripColorBalance *cb, ImBuf *ibuf, float
 }
 
 /*
- *  input preprocessing for SEQ_TYPE_IMAGE, SEQ_TYPE_MOVIE, SEQ_TYPE_MOVIECLIP and SEQ_TYPE_SCENE
+ * input preprocessing for SEQ_TYPE_IMAGE, SEQ_TYPE_MOVIE, SEQ_TYPE_MOVIECLIP and SEQ_TYPE_SCENE
  *
- *  Do all the things you can't really do afterwards using sequence effects
- *  (read: before rescaling to render resolution has been done)
+ * Do all the things you can't really do afterwards using sequence effects
+ * (read: before rescaling to render resolution has been done)
  *
- *  Order is important!
+ * Order is important!
  *
- *  - Deinterlace
- *  - Crop and transform in image source coordinate space
- *  - Flip X + Flip Y (could be done afterwards, backward compatibility)
- *  - Promote image to float data (affects pipeline operations afterwards)
- *  - Color balance (is most efficient in the byte -> float
- *    (future: half -> float should also work fine!)
- *    case, if done on load, since we can use lookup tables)
- *  - Premultiply
+ * - Deinterlace
+ * - Crop and transform in image source coordinate space
+ * - Flip X + Flip Y (could be done afterwards, backward compatibility)
+ * - Promote image to float data (affects pipeline operations afterwards)
+ * - Color balance (is most efficient in the byte -> float
+ *   (future: half -> float should also work fine!)
+ *   case, if done on load, since we can use lookup tables)
+ * - Premultiply
  */
 
 bool BKE_sequencer_input_have_to_preprocess(const SeqRenderData *context, Sequence *seq, float UNUSED(cfra))
index c1a085a..12bc40e 100644 (file)
@@ -1513,7 +1513,7 @@ static void sample_derivedmesh(
                                velocity_map[index * 3 + 1] += hit_normal[1] * sfs->vel_normal * 0.25f;
                                velocity_map[index * 3 + 2] += hit_normal[2] * sfs->vel_normal * 0.25f;
                                /* TODO: for fire emitted from mesh surface we can use
-                                *  Vf = Vs + (Ps/Pf - 1)*S to model gaseous expansion from solid to fuel */
+                                * Vf = Vs + (Ps/Pf - 1)*S to model gaseous expansion from solid to fuel */
                        }
                        /* apply object velocity */
                        if (has_velocity && sfs->vel_multi) {
@@ -2713,7 +2713,7 @@ static DerivedMesh *createDomainGeometry(SmokeDomainSettings *sds, Object *ob)
                ml[0].v = 1; ml[1].v = 0; ml[2].v = 4; ml[3].v = 5;
 
                /* calculate required shift to match domain's global position
-                *  it was originally simulated at (if object moves without smoke step) */
+                * it was originally simulated at (if object moves without smoke step) */
                invert_m4_m4(ob->imat, ob->obmat);
                mul_m4_v3(ob->obmat, ob_loc);
                mul_m4_v3(sds->obmat, ob_cache_loc);
@@ -3069,7 +3069,7 @@ static void smoke_calc_transparency(SmokeDomainSettings *sds, Scene *scene)
 }
 
 /* get smoke velocity and density at given coordinates
- *  returns fluid density or -1.0f if outside domain*/
+ * returns fluid density or -1.0f if outside domain. */
 float smoke_get_velocity_at(struct Object *ob, float position[3], float velocity[3])
 {
        SmokeModifierData *smd = (SmokeModifierData *)modifiers_findByType(ob, eModifierType_Smoke);
index 47e567a..93039bd 100644 (file)
  */
 
 
-/*
-******
-variables on the UI for now
-
-       float mediafrict;  friction to env
-       float nodemass;   softbody mass of *vertex*
-       float grav;        softbody amount of gravitaion to apply
-
-       float goalspring;  softbody goal springs
-       float goalfrict;   softbody goal springs friction
-       float mingoal;     quick limits for goal
-       float maxgoal;
-
-       float inspring;   softbody inner springs
-       float infrict;     softbody inner springs friction
-
-*****
-*/
+/**
+ * variables on the UI for now
+ * <pre>
+ * float mediafrict;  friction to env
+ * float nodemass;       softbody mass of *vertex*
+ * float grav;        softbody amount of gravitaion to apply
+ *
+ * float goalspring;  softbody goal springs
+ * float goalfrict;   softbody goal springs friction
+ * float mingoal;     quick limits for goal
+ * float maxgoal;
+ *
+ * float inspring;       softbody inner springs
+ * float infrict;     softbody inner springs friction
+ * </pre>
+ */
 
 
 #include <math.h>
@@ -250,16 +248,16 @@ static float _final_mass(Object *ob, BodyPoint *bp)
 
 /*+++ collider caching and dicing +++*/
 
-/********************
-for each target object/face the axis aligned bounding box (AABB) is stored
-faces parallel to global axes
-so only simple "value" in [min, max] ckecks are used
-float operations still
-*/
+/*
+ * for each target object/face the axis aligned bounding box (AABB) is stored
+ * faces parallel to global axes
+ * so only simple "value" in [min, max] ckecks are used
+ * float operations still
+ */
 
 /* just an ID here to reduce the prob for killing objects
-** ob->sumohandle points to we should not kill :)
-*/
+ * ob->sumohandle points to we should not kill :)
+ */
 static const int CCD_SAVETY = 190561;
 
 typedef struct ccdf_minmax {
@@ -757,8 +755,8 @@ static void add_bp_springlist(BodyPoint *bp, int springID)
 }
 
 /* do this once when sb is build
-it is O(N^2) so scanning for springs every iteration is too expensive
-*/
+ * it is O(N^2) so scanning for springs every iteration is too expensive
+ */
 static void build_bps_springlist(Object *ob)
 {
        SoftBody *sb= ob->soft; /* is supposed to be there */
@@ -950,29 +948,29 @@ static void free_softbody_intern(SoftBody *sb)
 /* ************ dynamics ********** */
 
 /* the most general (micro physics correct) way to do collision
-** (only needs the current particle position)
-**
-** it actually checks if the particle intrudes a short range force field generated
-** by the faces of the target object and returns a force to drive the particel out
-** the strenght of the field grows exponetially if the particle is on the 'wrong' side of the face
-** 'wrong' side : projection to the face normal is negative (all referred to a vertex in the face)
-**
-** flaw of this: 'fast' particles as well as 'fast' colliding faces
-** give a 'tunnel' effect such that the particle passes through the force field
-** without ever 'seeing' it
-** this is fully compliant to heisenberg: h >= fuzzy(location) * fuzzy(time)
-** besides our h is way larger than in QM because forces propagate way slower here
-** we have to deal with fuzzy(time) in the range of 1/25 seconds (typical frame rate)
-** yup collision targets are not known here any better
-** and 1/25 second is looong compared to real collision events
-** Q: why not use 'simple' collision here like bouncing back a particle
-**   --> reverting is velocity on the face normal
-** A: because our particles are not alone here
-**    and need to tell their neighbors exactly what happens via spring forces
-** unless sbObjectStep( .. ) is called on sub frame timing level
-** BTW that also questions the use of a 'implicit' solvers on softbodies
-** since that would only valid for 'slow' moving collision targets and dito particles
-*/
+ * (only needs the current particle position)
+ *
+ * it actually checks if the particle intrudes a short range force field generated
+ * by the faces of the target object and returns a force to drive the particel out
+ * the strenght of the field grows exponetially if the particle is on the 'wrong' side of the face
+ * 'wrong' side : projection to the face normal is negative (all referred to a vertex in the face)
+ *
+ * flaw of this: 'fast' particles as well as 'fast' colliding faces
+ * give a 'tunnel' effect such that the particle passes through the force field
+ * without ever 'seeing' it
+ * this is fully compliant to heisenberg: h >= fuzzy(location) * fuzzy(time)
+ * besides our h is way larger than in QM because forces propagate way slower here
+ * we have to deal with fuzzy(time) in the range of 1/25 seconds (typical frame rate)
+ * yup collision targets are not known here any better
+ * and 1/25 second is looong compared to real collision events
+ * Q: why not use 'simple' collision here like bouncing back a particle
+ *   --> reverting is velocity on the face normal
+ * A: because our particles are not alone here
+ *    and need to tell their neighbors exactly what happens via spring forces
+ * unless sbObjectStep( .. ) is called on sub frame timing level
+ * BTW that also questions the use of a 'implicit' solvers on softbodies
+ * since that would only valid for 'slow' moving collision targets and dito particles
+ */
 
 /* +++ dependency information functions*/
 
@@ -1747,11 +1745,11 @@ static int sb_detect_vertex_collisionCached(
 
                                                if (mprevvert) {
                                                        /* grab the average speed of the collider vertices
-                                                       before we spoil nvX
-                                                       humm could be done once a SB steps but then we' need to store that too
-                                                       since the AABB reduced propabitlty to get here drasticallly
-                                                       it might be a nice tradeof CPU <--> memory
-                                                       */
+                                                        * before we spoil nvX
+                                                        * humm could be done once a SB steps but then we' need to store that too
+                                                        * since the AABB reduced propabitlty to get here drasticallly
+                                                        * it might be a nice tradeof CPU <--> memory
+                                                        */
                                                        sub_v3_v3v3(vv1, nv1, mprevvert[vt->tri[0]].co);
                                                        sub_v3_v3v3(vv2, nv2, mprevvert[vt->tri[1]].co);
                                                        sub_v3_v3v3(vv3, nv3, mprevvert[vt->tri[2]].co);
@@ -1852,7 +1850,8 @@ static int sb_deflect_face(Object *ob, float *actpos, float *facenormal, float *
        return(deflected);
 }
 
-/* hiding this for now .. but the jacobian may pop up on other tasks .. so i'd like to keep it
+/* hiding this for now .. but the jacobian may pop up on other tasks .. so i'd like to keep it */
+#if 0
 static void dfdx_spring(int ia, int ic, int op, float dir[3], float L, float len, float factor)
 {
        float m, delta_ij;
@@ -1888,7 +1887,8 @@ static void dfdv_goal(int ia, int ic, float factor)
        int i;
        for (i=0;i<3;i++) EIG_linear_solver_matrix_add(ia+i, ic+i, factor);
 }
-*/
+#endif  /* if 0 */
+
 static void sb_spring_force(Object *ob, int bpi, BodySpring *bs, float iks, float UNUSED(forcetime))
 {
        SoftBody *sb= ob->soft; /* is supposed to be there */
@@ -2292,7 +2292,7 @@ static void softbody_calc_forces(Scene *scene, Object *ob, float forcetime, floa
 
                /* rule we never alter free variables :bp->vec bp->pos in here !
                 * this will ruin adaptive stepsize AKA heun! (BM)
-               */
+                */
                SoftBody *sb= ob->soft; /* is supposed to be there */
                BodyPoint  *bp;
                /* BodyPoint *bproot; */ /* UNUSED */
@@ -2462,16 +2462,16 @@ static void softbody_calc_forces(Scene *scene, Object *ob, float forcetime, floa
                                        if (sb_deflect_face(ob, bp->pos, facenormal, defforce, &cf, timenow, vel, &intrusion)) {
                                                if (intrusion < 0.0f) {
                                                        if (G.debug_value & 0x01) { // 17 we did check for bit 0x10 before
-                                                               /*fixing bug [17428] this forces adaptive step size to tiny steps
-                                                               in some situations .. keeping G.debug_value==17 option for old files 'needing' the bug
-                                                               */
-                                                               /*bjornmose:  uugh.. what an evil hack
-                                                               violation of the 'don't touch bp->pos in here' rule
-                                                               but works nice, like this-->
-                                                               we predict the solution being out of the collider
-                                                               in heun step No1 and leave the heun step No2 adapt to it
-                                                               so we kind of introduced a implicit solver for this case
-                                                               */
+                                                               /* fixing bug [17428] this forces adaptive step size to tiny steps
+                                                                * in some situations .. keeping G.debug_value==17 option for old files 'needing' the bug
+                                                                */
+                                                               /* bjornmose:  uugh.. what an evil hack
+                                                                * violation of the 'don't touch bp->pos in here' rule
+                                                                * but works nice, like this-->
+                                                                * we predict the solution being out of the collider
+                                                                * in heun step No1 and leave the heun step No2 adapt to it
+                                                                * so we kind of introduced a implicit solver for this case
+                                                                */
                                                                madd_v3_v3fl(bp->pos, facenormal, -intrusion);
                                                        }
                                                        else {
@@ -2543,10 +2543,10 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
 
        /* old one with homogeneous masses  */
        /* claim a minimum mass for vertex */
-       /*
-       if (sb->nodemass > 0.009999f) timeovermass = forcetime/sb->nodemass;
-       else timeovermass = forcetime/0.009999f;
-       */
+#if 0
+       if (sb->nodemass > 0.009999f) timeovermass = forcetime / sb->nodemass;
+       else timeovermass = forcetime / 0.009999f;
+#endif
 
        for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
 /* now we have individual masses   */
@@ -2742,11 +2742,11 @@ static void softbody_swap_state(Object *ob, float *ppos, float *pvel)
 
 
 /* care for bodypoints taken out of the 'ordinary' solver step
-** because they are screwed to goal by bolts
-** they just need to move along with the goal in time
-** we need to adjust them on sub frame timing in solver
-** so now when frame is done .. put 'em to the position at the end of frame
-*/
+ * because they are screwed to goal by bolts
+ * they just need to move along with the goal in time
+ * we need to adjust them on sub frame timing in solver
+ * so now when frame is done .. put 'em to the position at the end of frame
+ */
 static void softbody_apply_goalsnap(Object *ob)
 {
        SoftBody *sb= ob->soft; /* is supposed to be there */
@@ -2811,9 +2811,9 @@ static void interpolate_exciter(Object *ob, int timescale, int time)
 
 /* ************ convertors ********** */
 
-/*  for each object type we need;
      - xxxx_to_softbody(Object *ob)      : a full (new) copy, creates SB geometry
-*/
+/* for each object type we need;
* - xxxx_to_softbody(Object *ob)      : a full (new) copy, creates SB geometry
+ */
 
 /* Resetting a Mesh SB object's springs */
 /* Spring length are caculted from'raw' mesh vertices that are NOT altered by modifier stack. */
index 82704e9..e8c92d9 100644 (file)
@@ -49,8 +49,7 @@ typedef unsigned int BLI_bitmap;
 #define BLI_BITMAP_SIZE(_tot) \
        ((size_t)(_BITMAP_NUM_BLOCKS(_tot)) * sizeof(BLI_bitmap))
 
-/* allocate memory for a bitmap with '_tot' bits; free
- *  with MEM_freeN() */
+/* allocate memory for a bitmap with '_tot' bits; free with MEM_freeN() */
 #define BLI_BITMAP_NEW(_tot, _alloc_string) \
        ((BLI_bitmap *)MEM_callocN(BLI_BITMAP_SIZE(_tot), \
                                 _alloc_string))
index 6ef7789..eb3a795 100644 (file)
@@ -572,7 +572,7 @@ DLRBT_Node *BLI_dlrbTree_add(DLRBT_Tree *tree, DLRBT_Comparator_FP cmp_cb,
                node->tree_col = DLRBT_RED;
 
                /* perform BST balancing steps:
-                *  start from case 1, an trek through the tail-recursive insertion checks
+                * start from case 1, an trek through the tail-recursive insertion checks
                 */
                insert_check_1(tree, node);
        }
index 356740b..e8ccef4 100644 (file)
@@ -2618,8 +2618,9 @@ float line_plane_factor_v3(const float plane_co[3], const float plane_no[3],
        return (dot != 0.0f) ? -dot_v3v3(plane_no, h) / dot : 0.0f;
 }
 
-/** Ensure the distance between these points is no greater than 'dist'.
- *  If it is, scale then both into the center.
+/**
+ * Ensure the distance between these points is no greater than 'dist'.
+ * If it is, scale then both into the center.
  */
 void limit_dist_v3(float v1[3], float v2[3], const float dist)
 {
@@ -3180,8 +3181,8 @@ void transform_point_by_tri_v3(
 {
        /* this works by moving the source triangle so its normal is pointing on the Z
         * axis where its barycentric weights can be calculated in 2D and its Z offset can
-        *  be re-applied. The weights are applied directly to the targets 3D points and the
-        *  z-depth is used to scale the targets normal as an offset.
+        * be re-applied. The weights are applied directly to the targets 3D points and the
+        * z-depth is used to scale the targets normal as an offset.
         * This saves transforming the target into its Z-Up orientation and back (which could also work) */
        float no_tar[3], no_src[3];
        float mat_src[3][3];
index 8c36167..b93a7f5 100644 (file)
@@ -44,7 +44,7 @@
  ***************************************************************************/
 
 /* BICUBIC Interpolation functions
- *  More info: http://wiki.blender.org/index.php/User:Damiles#Bicubic_pixel_interpolation
+ * More info: http://wiki.blender.org/index.php/User:Damiles#Bicubic_pixel_interpolation
  * function assumes out to be zero'ed, only does RGBA */
 
 static float P(float k)
index de24fc4..296086e 100644 (file)
@@ -326,15 +326,13 @@ bool BLI_uniquename_cb(
 #  define GIVE_STRADDR(data, offset) ( ((char *)data) + offset)
 #endif
 
-/* Generic function to set a unique name. It is only designed to be used in situations
+/**
+ * Generic function to set a unique name. It is only designed to be used in situations
  * where the name is part of the struct.
  *
  * For places where this is used, see constraint.c for example...
  *
- *  name_offs: should be calculated using offsetof(structname, membername) macro from stddef.h
- *  len: maximum length of string (to prevent overflows, etc.)
- *  defname: the name that should be used by default if none is specified already
- *  delim: the character which acts as a delimiter between parts of the name
+ * \param name_offs: should be calculated using offsetof(structname, membername) macro from stddef.h
  */
 static bool uniquename_find_dupe(ListBase *list, void *vlink, const char *name, int name_offs)
 {
index 5d3c6b3..2bb5d53 100644 (file)
@@ -116,7 +116,7 @@ typedef struct Task {
  *   At this moment task queue owns the memory.
  *
  * - When task is done and task_free() is called the memory will be put to the
- *  pool which corresponds to a thread which handled the task.
+ *   pool which corresponds to a thread which handled the task.
  */
 typedef struct TaskMemPool {
        /* Number of pre-allocated tasks in the pool. */
index e3b779d..e9c92e0 100644 (file)
@@ -583,18 +583,19 @@ void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f)
                int sides;
                int y;
 
-               /*
-                *  mdisps is a grid of displacements, ordered thus:
-                *
-                *                     v4/next
-                *                       |
-                *   |      v1/cent-----mid2 ---> x
-                *   |         |         |
-                *   |         |         |
-                *  v2/prev---mid1-----v3/cur
-                *             |
-                *             V
-                *             y
+               /**
+                * mdisps is a grid of displacements, ordered thus:
+                * <pre>
+                *                    v4/next
+                *                      |
+                *  |      v1/cent-----mid2 ---> x
+                *  |         |         |
+                *  |         |         |
+                * v2/prev---mid1-----v3/cur
+                *            |
+                *            V
+                *            y
+                * </pre>
                 */
 
                sides = (int)sqrt(mdp->totdisp);
@@ -613,18 +614,19 @@ void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f)
                int sides;
                int y;
 
-               /*
-                *  mdisps is a grid of displacements, ordered thus:
-                *
-                *                     v4/next
-                *                       |
-                *   |      v1/cent-----mid2 ---> x
-                *   |         |         |
-                *   |         |         |
-                *  v2/prev---mid1-----v3/cur
-                *             |
-                *             V
-                *             y
+               /**
+                * mdisps is a grid of displacements, ordered thus:
+                * <pre>
+                *                    v4/next
+                *                      |
+                *  |      v1/cent-----mid2 ---> x
+                *  |         |         |
+                *  |         |         |
+                * v2/prev---mid1-----v3/cur
+                *            |
+                *            V
+                *            y
+                * </pre>
                 */
 
                if (l->radial_next == l)
index b5e6fe1..450d492 100644 (file)
@@ -1424,7 +1424,7 @@ static BMOpDefine bmo_similar_faces_def = {
 /*
  * Similar Edges Search.
  *
- *  Find similar edges (length, direction, edge, seam, ...).
+ * Find similar edges (length, direction, edge, seam, ...).
  */
 static BMOpDefine bmo_similar_edges_def = {
        "similar_edges",
index 7cbc646..3137725 100644 (file)
@@ -869,7 +869,7 @@ void BM_face_normal_flip(BMesh *bm, BMFace *f)
 }
 
 /**
- *  BM POINT IN FACE
+ * BM POINT IN FACE
  *
  * Projects co onto face f, and returns true if it is inside
  * the face bounds.
@@ -1284,7 +1284,7 @@ void BM_face_splits_check_optimal(BMFace *f, BMLoop *(*loops)[2], int len)
  * Small utility functions for fast access
  *
  * faster alternative to:
- *  BM_iter_as_array(bm, BM_VERTS_OF_FACE, f, (void **)v, 3);
+ * BM_iter_as_array(bm, BM_VERTS_OF_FACE, f, (void **)v, 3);
  */
 void BM_face_as_array_vert_tri(BMFace *f, BMVert *r_verts[3])
 {
@@ -1299,7 +1299,7 @@ void BM_face_as_array_vert_tri(BMFace *f, BMVert *r_verts[3])
 
 /**
  * faster alternative to:
- *  BM_iter_as_array(bm, BM_VERTS_OF_FACE, f, (void **)v, 4);
+ * BM_iter_as_array(bm, BM_VERTS_OF_FACE, f, (void **)v, 4);
  */
 void BM_face_as_array_vert_quad(BMFace *f, BMVert *r_verts[4])
 {
@@ -1318,7 +1318,7 @@ void BM_face_as_array_vert_quad(BMFace *f, BMVert *r_verts[4])
  * Small utility functions for fast access
  *
  * faster alternative to:
- *  BM_iter_as_array(bm, BM_LOOPS_OF_FACE, f, (void **)l, 3);
+ * BM_iter_as_array(bm, BM_LOOPS_OF_FACE, f, (void **)l, 3);
  */
 void BM_face_as_array_loop_tri(BMFace *f, BMLoop *r_loops[3])
 {
@@ -1333,7 +1333,7 @@ void BM_face_as_array_loop_tri(BMFace *f, BMLoop *r_loops[3])
 
 /**
  * faster alternative to:
- *  BM_iter_as_array(bm, BM_LOOPS_OF_FACE, f, (void **)l, 4);
+ * BM_iter_as_array(bm, BM_LOOPS_OF_FACE, f, (void **)l, 4);
  */
 void BM_face_as_array_loop_quad(BMFace *f, BMLoop *r_loops[4])
 {
@@ -1352,7 +1352,7 @@ void BM_face_as_array_loop_quad(BMFace *f, BMLoop *r_loops[4])
  * \brief BM_mesh_calc_tessellation get the looptris and its number from a certain bmesh
  * \param looptris
  *
- * \note \a looptris  Must be pre-allocated to at least the size of given by: poly_to_tri_count
+ * \note \a looptris Must be pre-allocated to at least the size of given by: poly_to_tri_count
  */
 void BM_mesh_calc_tessellation(BMesh *bm, BMLoop *(*looptris)[3], int *r_looptris_tot)
 {
index daee22f..61e47a6 100644 (file)
@@ -31,9 +31,9 @@
 /** \file blender/bmesh/intern/bmesh_private.h
  *  \ingroup bmesh
  *
- *  Private function prototypes for bmesh public API.
- *  This file is a grab-bag of functions from various
- *  parts of the bmesh internals.
+ * Private function prototypes for bmesh public API.
+ * This file is a grab-bag of functions from various
+ * parts of the bmesh internals.
  */
 
 /* returns positive nonzero on error */
index 33ad783..540888a 100644 (file)
@@ -1206,7 +1206,7 @@ bool BM_face_share_face_check(BMFace *f1, BMFace *f2)
 }
 
 /**
- *  Counts the number of edges two faces share (if any)
+ * Counts the number of edges two faces share (if any)
  */
 int BM_face_share_edge_count(BMFace *f_a, BMFace *f_b)
 {
@@ -1225,7 +1225,7 @@ int BM_face_share_edge_count(BMFace *f_a, BMFace *f_b)
 }
 
 /**
- *  Returns true if the faces share an edge
+ * Returns true if the faces share an edge
  */
 bool BM_face_share_edge_check(BMFace *f1, BMFace *f2)
 {
@@ -1243,7 +1243,7 @@ bool BM_face_share_edge_check(BMFace *f1, BMFace *f2)
 }
 
 /**
- *  Counts the number of verts two faces share (if any).
+ * Counts the number of verts two faces share (if any).
  */
 int BM_face_share_vert_count(BMFace *f_a, BMFace *f_b)
 {
@@ -1262,7 +1262,7 @@ int BM_face_share_vert_count(BMFace *f_a, BMFace *f_b)
 }
 
 /**
- *  Returns true if the faces share a vert.
+ * Returns true if the faces share a vert.
  */
 bool BM_face_share_vert_check(BMFace *f_a, BMFace *f_b)
 {
@@ -1656,8 +1656,8 @@ void BM_loop_calc_face_tangent(const BMLoop *l, float r_tangent[3])
 /**
  * \brief BMESH EDGE/FACE ANGLE
  *
- *  Calculates the angle between two faces.
- *  Assumes the face normals are correct.
+ * Calculates the angle between two faces.
+ * Assumes the face normals are correct.
  *
  * \return angle in radians
  */
@@ -1680,8 +1680,8 @@ float BM_edge_calc_face_angle(const BMEdge *e)
 /**
  * \brief BMESH EDGE/FACE ANGLE
  *
- *  Calculates the angle between two faces.
- *  Assumes the face normals are correct.
+ * Calculates the angle between two faces.
+ * Assumes the face normals are correct.
  *
  * \return angle in radians
  */
index 317045b..9f394aa 100644 (file)
@@ -153,9 +153,12 @@ static LaplacianSystem *init_laplacian_system(int a_numEdges, int a_numFaces, in
        return sys;
 }
 
-/* Compute weight between vertice v_i and all your neighbors
+/**
+ * Compute weight between vertice v_i and all your neighbors
  * weight between v_i and v_neighbor
+ * <pre>
  * Wij = cot(alpha) + cot(beta) / (4.0 * total area of all faces  * sum all weight)
+ *
  *        v_i *
  *          / | \
  *         /  |  \
@@ -163,6 +166,7 @@ static LaplacianSystem *init_laplacian_system(int a_numEdges, int a_numFaces, in
  *         \  |  /
  *          \ | /
  *            * v_neighbor
+ * </pre>
  */
 
 static void init_laplacian_matrix(LaplacianSystem *sys)
index adfcb8d..754db54 100644 (file)
@@ -2113,7 +2113,7 @@ static void adjust_the_cycle_or_chain(BoundVert *vstart, bool iscycle)
 
                        /* residue np + 2*i (if cycle) else np - 1 + 2*i:
                         * right offset for parm i matches its spec; weighted */
-                       row = iscycle ? np + 2 * i : np - 1 + 2 *  i;
+                       row = iscycle ? np + 2 * i : np - 1 + 2 * i;
                        EIG_linear_solver_matrix_add(solver, row, i, weight);
                        EIG_linear_solver_right_hand_side_add(solver, 0, row, weight * eright->offset_r);
 #ifdef DEBUG_ADJUST
index 48656d1..6e45618 100644 (file)
@@ -61,9 +61,9 @@ bool AnimationExporter::is_flat_line(std::vector<float> &values, int channel_cou
        return true;
 }
 /*
- *  This function creates a complete LINEAR Collada <Animation> Entry with all needed
- *  <source>, <sampler>, and <channel> entries.
- *  This is is used for creating sampled Transformation Animations for either:
+ * This function creates a complete LINEAR Collada <Animation> Entry with all needed
+ * <source>, <sampler>, and <channel> entries.
+ * This is is used for creating sampled Transformation Animations for either:
  *
  *             1-axis animation:
  *                 times contains the time points in seconds from within the timeline
index 28e962d..e8b665b 100644 (file)
@@ -108,7 +108,7 @@ int ArmatureImporter::create_bone(SkinInfo *skin, COLLADAFW::Node *node, EditBon
 
        /*
         * We use the inv_bind_shape matrix to apply the armature bind pose as its rest pose.
-       */
+        */
 
        std::map<COLLADAFW::UniqueId, SkinInfo>::iterator skin_it;
        bool bone_is_skinned = false;
@@ -516,32 +516,32 @@ Object *ArmatureImporter::create_armature_bones(Main *bmain, SkinInfo& skin)
         * if so, use that skin's armature
         */
 
-       /*
-         Pseudocode:
-
-         find_node_in_tree(node, root_joint)
-
-         skin::find_root_joints(root_joints):
-               std::vector root_joints;
-               for each root in root_joints:
-                       for each joint in joints:
-                               if find_node_in_tree(joint, root):
-                                       if (std::find(root_joints.begin(), root_joints.end(), root) == root_joints.end())
-                                               root_joints.push_back(root);
-
-         for (each skin B with armature) {
-                 find all root joints for skin B
-
-                 for each joint X in skin A:
-                       for each root joint R in skin B:
-                               if (find_node_in_tree(X, R)) {
-                                       shared = 1;
-                                       goto endloop;
-                               }
-         }
-
-         endloop:
-       */
+       /**
+        * Pseudocode:
+        *
+        * find_node_in_tree(node, root_joint)
+        *
+        * skin::find_root_joints(root_joints):
+        *     std::vector root_joints;
+        *     for each root in root_joints:
+        *         for each joint in joints:
+        *             if find_node_in_tree(joint, root):
+        *                 if (std::find(root_joints.begin(), root_joints.end(), root) == root_joints.end())
+        *                     root_joints.push_back(root);
+        *
+        * for (each skin B with armature) {
+        *     find all root joints for skin B
+        *
+        *     for each joint X in skin A:
+        *         for each root joint R in skin B:
+        *             if (find_node_in_tree(X, R)) {
+        *                 shared = 1;
+        *                 goto endloop;
+        *             }
+        * }
+        *
+        * endloop:
+        */
 
        SkinInfo *a = &skin;
        Object *shared = NULL;
index f84cd06..67fd9d6 100644 (file)
@@ -703,8 +703,10 @@ finally:
        return root_objects;
 }
 
-/** When this method is called, the writer must write the entire visual scene.
- *  Return The writer should return true, if writing succeeded, false otherwise. */
+/**
+ * When this method is called, the writer must write the entire visual scene.
+ * Return The writer should return true, if writing succeeded, false otherwise.
+ */
 bool DocumentImporter::writeVisualScene(const COLLADAFW::VisualScene *visualScene)
 {
        if (mImportStage != General)
index 2667444..caa7390 100644 (file)
@@ -50,8 +50,8 @@ ErrorHandler::~ErrorHandler()
 bool ErrorHandler::handleError(const COLLADASaxFWL::IError *error)
 {
        /* This method must return true when Collada should continue.
-          See https://github.com/KhronosGroup/OpenCOLLADA/issues/442
-       */
+        * See https://github.com/KhronosGroup/OpenCOLLADA/issues/442
+        */
        bool isWarning = false;
 
        if (error->getErrorClass() == COLLADASaxFWL::IError::ERROR_SAXPARSER) {
index b9af197..07e2c83 100644 (file)
@@ -370,8 +370,8 @@ void bc_match_scale(std::vector<Object *> *objects_done,
 }
 
 /*
   Convenience function to get only the needed components of a matrix
-*/
* Convenience function to get only the needed components of a matrix
+ */
 void bc_decompose(float mat[4][4], float *loc, float eul[3], float quat[4], float *size)
 {
        if (size) {
@@ -392,17 +392,17 @@ void bc_decompose(float mat[4][4], float *loc, float eul[3], float quat[4], floa
 }
 
 /*
-* Create rotation_quaternion from a delta rotation and a reference quat
-*
-* Input:
-* mat_from: The rotation matrix before rotation
-* mat_to  : The rotation matrix after rotation
-* qref    : the quat corresponding to mat_from
-*
-* Output:
-* rot     : the calculated result (quaternion)
-*
-*/
+ * Create rotation_quaternion from a delta rotation and a reference quat
+ *
+ * Input:
+ * mat_from: The rotation matrix before rotation
+ * mat_to  : The rotation matrix after rotation
+ * qref    : the quat corresponding to mat_from
+ *
+ * Output:
+ * rot     : the calculated result (quaternion)
+ *
+ */
 void bc_rotate_from_reference_quat(float quat_to[4], float quat_from[4], float mat_to[4][4])
 {
        float qd[4];
@@ -481,11 +481,11 @@ int bc_set_layer(int bitfield, int layer, bool enable)
        return bitfield;
 }
 
-/*
| This method creates a new extension map when needed.
| Note: The ~BoneExtensionManager destructor takes care
| to delete the created maps when the manager is removed.
-*/
+/**
* This method creates a new extension map when needed.
* \note The ~BoneExtensionManager destructor takes care
* to delete the created maps when the manager is removed.
+ */
 BoneExtensionMap &BoneExtensionManager::getExtensionMap(bArmature *armature)
 {
        std::string key = armature->id.name;
@@ -683,8 +683,8 @@ int BoneExtended::get_use_connect()
 }
 
 /**
-* Stores a 4*4 matrix as a custom bone property array of size 16
-*/
+ * Stores a 4*4 matrix as a custom bone property array of size 16
+ */
 void bc_set_IDPropertyMatrix(EditBone *ebone, const char *key, float mat[4][4])
 {
        IDProperty *idgroup = (IDProperty *)ebone->prop;
@@ -710,10 +710,10 @@ void bc_set_IDPropertyMatrix(EditBone *ebone, const char *key, float mat[4][4])
 
 #if 0
 /**
-* Stores a Float value as a custom bone property
-*
-* Note: This function is currently not needed. Keep for future usage
-*/
+ * Stores a Float value as a custom bone property
+ *
+ * Note: This function is currently not needed. Keep for future usage
+ */
 static void bc_set_IDProperty(EditBone *ebone, const char *key, float value)
 {
        if (ebone->prop == NULL)
@@ -731,19 +731,19 @@ static void bc_set_IDProperty(EditBone *ebone, const char *key, float value)
 }
 #endif
 
-/*
-* Get a custom property when it exists.
-* This function is also used to check if a property exists.
-*/
+/**
+ * Get a custom property when it exists.
+ * This function is also used to check if a property exists.
+ */
 IDProperty *bc_get_IDProperty(Bone *bone, std::string key)
 {
        return (bone->prop == NULL) ? NULL : IDP_GetPropertyFromGroup(bone->prop, key.c_str());
 }
 
 /**
-* Read a custom bone property and convert to float
-* Return def if the property does not exist.
-*/
+ * Read a custom bone property and convert to float
+ * Return def if the property does not exist.
+ */
 float bc_get_property(Bone *bone, std::string key, float def)
 {
        float result = def;
@@ -767,13 +767,13 @@ float bc_get_property(Bone *bone, std::string key, float def)
 }
 
 /**
-* Read a custom bone property and convert to matrix
-* Return true if conversion was succesfull
-*
-* Return false if:
-* - the property does not exist
-* - is not an array of size 16
-*/
+ * Read a custom bone property and convert to matrix
+ * Return true if conversion was succesfull
+ *
+ * Return false if:
+ * - the property does not exist
+ * - is not an array of size 16
+ */
 bool bc_get_property_matrix(Bone *bone, std::string key, float mat[4][4])
 {
        IDProperty *property = bc_get_IDProperty(bone, key);
@@ -788,8 +788,8 @@ bool bc_get_property_matrix(Bone *bone, std::string key, float mat[4][4])
 }
 
 /**
-* get a vector that is stored in 3 custom properties (used in Blender <= 2.78)
-*/
+ * get a vector that is stored in 3 custom properties (used in Blender <= 2.78)
+ */
 void bc_get_property_vector(Bone *bone, std::string key, float val[3], const float def[3])
 {
        val[0] = bc_get_property(bone, key + "_x", def[0]);
@@ -798,8 +798,8 @@ void bc_get_property_vector(Bone *bone, std::string key, float val[3], const flo
 }
 
 /**
-* Check if vector exist stored in 3 custom properties (used in Blender <= 2.78)
-*/
+ * Check if vector exist stored in 3 custom properties (used in Blender <= 2.78)
+ */
 static bool has_custom_props(Bone *bone, bool enabled, std::string key)
 {
        if (!enabled)
@@ -812,11 +812,11 @@ static bool has_custom_props(Bone *bone, bool enabled, std::string key)
 }
 
 /**
-* Check if custom information about bind matrix exists and modify the from_mat
-* accordingly.
-*
-* Note: This is old style for Blender <= 2.78 only kept for compatibility
-*/
+ * Check if custom information about bind matrix exists and modify the from_mat
+ * accordingly.
+ *
+ * Note: This is old style for Blender <= 2.78 only kept for compatibility
+ */
 void bc_create_restpose_mat(const ExportSettings *export_settings, Bone *bone, float to_mat[4][4], float from_mat[4][4], bool use_local_space)
 {
        float loc[3];
@@ -870,8 +870,8 @@ void bc_create_restpose_mat(const ExportSettings *export_settings, Bone *bone, f
 }
 
 /*
   Make 4*4 matrices better readable
-*/
* Make 4*4 matrices better readable
+ */
 void bc_sanitize_mat(float mat[4][4], int precision)
 {
        for (int i = 0; i < 4; i++)
@@ -911,7 +911,7 @@ std::string bc_get_active_uvlayer_name(Object *ob)
        return bc_get_active_uvlayer_name(me);
 }
 
-/*
+/**
  * Returns name of Active UV Layer or empty String if no active UV Layer defined
  */
 std::string bc_get_active_uvlayer_name(Mesh *me)
index 438bb4a..d1591a3 100644 (file)
@@ -191,16 +191,16 @@ public:
 };
 
 /* a map to store bone extension maps
-| std:string     : an armature name
-| BoneExtended * : a map that contains extra data for bones
-*/
+ * std:string     : an armature name
+ * BoneExtended * : a map that contains extra data for bones
+ */
 typedef std::map<std::string, BoneExtended *> BoneExtensionMap;
 
 /*
-| A class to organise bone extendion data for multiple Armatures.
-| this is needed for the case where a Collada file contains 2 or more
-| separate armatures.
-*/
+ * A class to organise bone extendion data for multiple Armatures.
+ * this is needed for the case where a Collada file contains 2 or more
+ * separate armatures.
+ */
 class BoneExtensionManager {
 private:
        std::map<std::string, BoneExtensionMap *> extended_bone_maps;
index 4fb6b70..320646b 100644 (file)
@@ -36,44 +36,50 @@ class NodeOperationBuilder;
 
 class ViewerOperation;
 
-/** Interface type for converting a \a Node into \a NodeOperation.
- *  This is passed to \a Node::convertToOperation methods and allows them
- *  to register any number of operations, create links between them,
- *  and map original node sockets to their inputs or outputs.
+/**
+ * Interface type for converting a \a Node into \a NodeOperation.
+ * This is passed to \a Node::convertToOperation methods and allows them
+ * to register any number of operations, create links between them,
+ * and map original node sockets to their inputs or outputs.
  */
 class NodeConverter {
 public:
        NodeConverter(NodeOperationBuilder *builder);
 
-       /** Insert a new operation into the operations graph.
-        *  The operation must be created by the node.
+       /**
+        * Insert a new operation into the operations graph.
+        * The operation must be created by the node.
         */
        void addOperation(NodeOperation *operation);
 
-       /** Map input socket of the node to an operation socket.
-        *  Links between nodes will then generate equivalent links between
-        *  the mapped operation sockets.
+       /**
+        * Map input socket of the node to an operation socket.
+        * Links between nodes will then generate equivalent links between
+        * the mapped operation sockets.
         *
-        *  \note A \a Node input can be mapped to multiple \a NodeOperation inputs.
+        * \note A \a Node input can be mapped to multiple \a NodeOperation inputs.
         */
        void mapInputSocket(NodeInput *node_socket, NodeOperationInput *operation_socket);
-       /** Map output socket of the node to an operation socket.
-        *  Links between nodes will then generate equivalent links between
-        *  the mapped operation sockets.
+       /**
+        * Map output socket of the node to an operation socket.
+        * Links between nodes will then generate equivalent links between
+        * the mapped operation sockets.
         *
         * \note A \a Node output can only be mapped to one \a NodeOperation output.
         * Any existing operation output mapping will be replaced.
         */
        void mapOutputSocket(NodeOutput *node_socket, NodeOperationOutput *operation_socket);
 
-       /** Create a proxy operation for a node input.
-        *  This operation will be removed later and replaced
-        *  by direct links between the connected operations.
+       /**
+        * Create a proxy operation for a node input.
+        * This operation will be removed later and replaced
+        * by direct links between the connected operations.
         */
        NodeOperationOutput *addInputProxy(NodeInput *input, bool use_conversion);
-       /** Create a proxy operation for a node output.
-        *  This operation will be removed later and replaced
-        *  by direct links between the connected operations.
+       /**
+        * Create a proxy operation for a node output.
+        * This operation will be removed later and replaced
+        * by direct links between the connected operations.
         */
        NodeOperationInput *addOutputProxy(NodeOutput *output, bool use_conversion);
 
@@ -99,8 +105,9 @@ public:
        /** Add a preview operation for a node input. */
        void addNodeInputPreview(NodeInput *input);
 
-       /** When a node has no valid data
-        *  @note missing image / group pointer, or missing renderlayer from EXR
+       /**
+        * When a node has no valid data
+        * \note missing image / group pointer, or missing renderlayer from EXR
         */
        NodeOperation *setInvalidOutput(NodeOutput *output);
 
index 3e4e3a5..66d636e 100644 (file)
@@ -285,8 +285,8 @@ static int add_driver_with_target(
 }
 
 /* Main Driver Management API calls:
- *  Add a new driver for the specified property on the given ID block,
- *  and make it be driven by the specified target.
+ * Add a new driver for the specified property on the given ID block,
+ * and make it be driven by the specified target.
  *
  * This is intended to be used in conjunction with a modal "eyedropper"
  * for picking the variable that is going to be used to drive this one.
@@ -368,7 +368,7 @@ int ANIM_add_driver_with_target(
 /* --------------------------------- */
 
 /* Main Driver Management API calls:
- *  Add a new driver for the specified property on the given ID block
+ * Add a new driver for the specified property on the given ID block
  */
 int ANIM_add_driver(ReportList *reports, ID *id, const char rna_path[], int array_index, short flag, int type)
 {
@@ -464,7 +464,7 @@ int ANIM_add_driver(ReportList *reports, ID *id, const char rna_path[], int arra
 }
 
 /* Main Driver Management API calls:
- *  Remove the driver for the specified property on the given ID block (if available)
+ * Remove the driver for the specified property on the given ID block (if available)
  */
 bool ANIM_remove_driver(ReportList *UNUSED(reports), ID *id, const char rna_path[], int array_index, short UNUSED(flag))
 {
index a6ed664..347e3f3 100644 (file)
@@ -973,18 +973,18 @@ short paste_animedit_keys(bAnimContext *ac, ListBase *anim_data,
        }
        else {
                /* from selected channels
-                *  This "passes" system aims to try to find "matching" channels to paste keyframes
-                *  into with increasingly loose matching heuristics. The process finishes when at least
-                *  one F-Curve has been pasted into.
+                * This "passes" system aims to try to find "matching" channels to paste keyframes
+                * into with increasingly loose matching heuristics. The process finishes when at least
+                * one F-Curve has been pasted into.
                 */
                for (pass = 0; pass < 3; pass++) {
                        unsigned int totmatch = 0;
 
                        for (ale = anim_data->first; ale; ale = ale->next) {
                                /* find buffer item to paste from
-                                *      - if names don't matter (i.e. only 1 channel in buffer), don't check id/group
-                                *      - if names do matter, only check if id-type is ok for now (group check is not that important)
-                                *      - most importantly, rna-paths should match (array indices are unimportant for now)
+                                * - if names don't matter (i.e. only 1 channel in buffer), don't check id/group
+                                * - if names do matter, only check if id-type is ok for now (group check is not that important)
+                                * - most importantly, rna-paths should match (array indices are unimportant for now)
                                 */
                                AnimData *adt = ANIM_nla_mapping_get(ac, ale);
                                FCurve *fcu = (FCurve *)ale->data;  /* destination F-Curve */
index c211f91..7a5e056 100644 (file)
@@ -776,8 +776,8 @@ static int armature_parent_set_exec(bContext *C, wmOperator *op)
                 * - the context iterator contains both selected bones and their mirrored copies,
                 *   so we assume that unselected bones are mirrored copies of some selected bone
                 * - since the active one (and/or its mirror) will also be selected, we also need
-                *  to check that we are not trying to operate on them, since such an operation
-                *      would cause errors
+                *   to check that we are not trying to operate on them, since such an operation
+                *   would cause errors
                 */
 
                /* parent selected bones to the active one */
index b74b515..89e510e 100644 (file)
@@ -665,7 +665,7 @@ static int RIG_parentControl(RigControl *ctrl, EditBone *link)
                }
 
                /* if there's already a link
-                *  overwrite only if new link is higher in the chain */
+                * overwrite only if new link is higher in the chain */
                if (ctrl->link && flag == ctrl->flag) {
                        EditBone *bone = NULL;
 
index 389a842..d91d380 100644 (file)
@@ -801,8 +801,8 @@ static int pose_armature_layers_showall_exec(bContext *C, wmOperator *op)
                return OPERATOR_CANCELLED;
 
        /* use RNA to set the layers
-        *  although it would be faster to just set directly using bitflags, we still
-        *      need to setup a RNA pointer so that we get the "update" callbacks for free...
+        * although it would be faster to just set directly using bitflags, we still
+        * need to setup a RNA pointer so that we get the "update" callbacks for free...
         */
        RNA_id_pointer_create(&arm->id, &ptr);
 
index 5e62a87..9d9ec51 100644 (file)
@@ -55,9 +55,9 @@
 
 /* ***************************************** */
 /* NOTE ABOUT THIS FILE:
- *  This file contains code for editing Grease Pencil data in the Action Editor
- *  as a 'keyframes', so that a user can adjust the timing of Grease Pencil drawings.
- *  Therefore, this file mostly contains functions for selecting Grease-Pencil frames.
+ * This file contains code for editing Grease Pencil data in the Action Editor
+ * as a 'keyframes', so that a user can adjust the timing of Grease Pencil drawings.
+ * Therefore, this file mostly contains functions for selecting Grease-Pencil frames.
  */
 /* ***************************************** */
 /* Generics - Loopers */
index d7e60d2..f48736a 100644 (file)
@@ -319,15 +319,15 @@ typedef enum ACTCONT_TYPES {
 /* Stroke Iteration Utilities */
 
 /**
-* Iterate over all editable strokes in the current context,
-* stopping on each usable layer + stroke pair (i.e. gpl and gps)
-* to perform some operations on the stroke.
-*
-* \param gpl  The identifier to use for the layer of the stroke being processed.
-*                    Choose a suitable value to avoid name clashes.
-* \param gps The identifier to use for current stroke being processed.
-*                    Choose a suitable value to avoid name clashes.
-*/
+ * Iterate over all editable strokes in the current context,
+ * stopping on each usable layer + stroke pair (i.e. gpl and gps)
+ * to perform some operations on the stroke.
+ *
+ * \param gpl  The identifier to use for the layer of the stroke being processed.
+ *                    Choose a suitable value to avoid name clashes.
+ * \param gps The identifier to use for current stroke being processed.
+ *                    Choose a suitable value to avoid name clashes.
+ */
 #define GP_EDITABLE_STROKES_BEGIN(C, gpl, gps)                                          \
 {                                                                                       \
        CTX_DATA_BEGIN(C, bGPDlayer*, gpl, editable_gpencil_layers)                         \
index fd1ff85..0eb74f1 100644 (file)
@@ -2138,10 +2138,10 @@ static void gpencil_draw_apply_event(wmOperator *op, const wmEvent *event)
                p->pressure = wmtab->Pressure;
 
                /* Hack for pressure sensitive eraser on D+RMB when using a tablet:
-                *  The pen has to float over the tablet surface, resulting in
-                *  zero pressure (T47101). Ignore pressure values if floating
-                *  (i.e. "effectively zero" pressure), and only when the "active"
-                *  end is the stylus (i.e. the default when not eraser)
+                * The pen has to float over the tablet surface, resulting in
+                * zero pressure (T47101). Ignore pressure values if floating
+                * (i.e. "effectively zero" pressure), and only when the "active"
+                * end is the stylus (i.e. the default when not eraser)
                 */
                if (p->paintmode == GP_PAINTMODE_ERASER) {
                        if ((wmtab->Active != EVT_TABLET_ERASER) && (p->pressure < 0.001f)) {
@@ -2166,7 +2166,7 @@ static void gpencil_draw_apply_event(wmOperator *op, const wmEvent *event)
                p->straight[1] = 0;
 
                /* special exception here for too high pressure values on first touch in
-                *  windows for some tablets, then we just skip first touch...
+                * windows for some tablets, then we just skip first touch...
                 */
                if (tablet && (p->pressure >= 0.99f))
                        return;
index dd556e9..a21c561 100644 (file)
@@ -735,7 +735,7 @@ static bool gp_stroke_do_circle_sel(
                                if (gp_stroke_inside_circle(mval, mvalo, radius, x0, y0, x1, y1)) {
                                        /* change selection of stroke, and then of both points
                                         * (as the last point otherwise wouldn't get selected
-                                        *  as we only do n-1 loops through)
+                                        * as we only do n-1 loops through).
                                         */
                                        if (select) {
                                                pt1->flag |= GP_SPOINT_SELECT;
index 06b8197..eb77ee8 100644 (file)
@@ -327,11 +327,11 @@ bool ANIM_driver_vars_paste(struct ReportList *reports, struct FCurve *fcu, bool
 /* ************ Auto-Keyframing ********************** */
 /* Notes:
  * - All the defines for this (User-Pref settings and Per-Scene settings)
- *  are defined in DNA_userdef_types.h
+ *   are defined in DNA_userdef_types.h
  * - Scene settings take precedence over those for userprefs, with old files
- *  inheriting userpref settings for the scene settings
+ *   inheriting userpref settings for the scene settings
  * - "On/Off + Mode" are stored per Scene, but "settings" are currently stored
- *  as userprefs
+ *   as userprefs
  */
 
 /* Auto-Keying macros for use by various tools */
index 9d05819..941153f 100644 (file)
@@ -1283,11 +1283,11 @@ static uiLayout *draw_constraint(uiLayout *layout, Object *ob, bConstraint *con)
                short prev_proxylock, show_upbut, show_downbut;
 
                /* Up/Down buttons:
-                *      Proxy-constraints are not allowed to occur after local (non-proxy) constraints
-                *      as that poses problems when restoring them, so disable the "up" button where
-                *      it may cause this situation.
+                * Proxy-constraints are not allowed to occur after local (non-proxy) constraints
+                * as that poses problems when restoring them, so disable the "up" button where
+                * it may cause this situation.
                 *
-                *  Up/Down buttons should only be shown (or not grayed - todo) if they serve some purpose.
+                * Up/Down buttons should only be shown (or not grayed - todo) if they serve some purpose.
                 */
                if (BKE_constraints_proxylocked_owner(ob, pchan)) {
                        if (con->prev) {
index 299001d..7db2d7f 100644 (file)
@@ -215,8 +215,8 @@ void UI_view2d_region_reinit(View2D *v2d, short type, int winx, int winy)
        /* see eView2D_CommonViewTypes in UI_view2d.h for available view presets */
        switch (type) {
                /* 'standard view' - optimum setup for 'standard' view behavior,
-                *  that should be used new views as basis for their
-                *  own unique View2D settings, which should be used instead of this in most cases...
+                * that should be used new views as basis for their
+                * own unique View2D settings, which should be used instead of this in most cases...
                 */
                case V2D_COMMONVIEW_STANDARD:
                {
@@ -226,9 +226,9 @@ void UI_view2d_region_reinit(View2D *v2d, short type, int winx, int winy)
                        v2d->maxzoom = 1000.0f;
 
                        /* tot rect and cur should be same size, and aligned using 'standard' OpenGL coordinates for now
-                        *      - region can resize 'tot' later to fit other data
-                        *      - keeptot is only within bounds, as strict locking is not that critical
-                        *      - view is aligned for (0,0) -> (winx-1, winy-1) setup
+                        * - region can resize 'tot' later to fit other data
+                        * - keeptot is only within bounds, as strict locking is not that critical
+                        * - view is aligned for (0,0) -> (winx-1, winy-1) setup
                         */
                        v2d->align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_NEG_Y);
                        v2d->keeptot = V2D_KEEPTOT_BOUNDS;
@@ -260,7 +260,7 @@ void UI_view2d_region_reinit(View2D *v2d, short type, int winx, int winy)
                        break;
                }
                /* 'stack view' - practically the same as list/channel view, except is located in the pos y half instead.
-                *  zoom, aspect ratio, and alignment restrictions are set here */
+                * zoom, aspect ratio, and alignment restrictions are set here */
                case V2D_COMMONVIEW_STACK:
                {
                        /* zoom + aspect ratio are locked */
@@ -628,7 +628,7 @@ static void ui_view2d_curRect_validate_resize(View2D *v2d, bool resize, bool mas
                        }
                        else if (cur->xmax > tot->xmax) {
                                /* - only offset by difference of cur-xmax and tot-xmax if that would not move
-                                *  cur-xmin to lie past tot-xmin
+                                *   cur-xmin to lie past tot-xmin
                                 * - otherwise, simply shift to tot-xmin???
                                 */
                                temp = cur->xmax - tot->xmax;
@@ -672,7 +672,7 @@ static void ui_view2d_curRect_validate_resize(View2D *v2d, bool resize, bool mas
                        }
                        else if (cur->xmax > tot->xmax) {
                                /* - only offset by difference of cur-xmax and tot-xmax if that would not move
-                                *  cur-xmin to lie past tot-xmin
+                                *   cur-xmin to lie past tot-xmin
                                 * - otherwise, simply shift to tot-xmin???
                                 */
                                temp = cur->xmax - tot->xmax;
index 771deca..21f406c 100644 (file)
@@ -51,9 +51,9 @@
 
 /* ***************************************** */
 /* NOTE ABOUT THIS FILE:
- *  This file contains code for editing Mask data in the Action Editor
- *  as a 'keyframes', so that a user can adjust the timing of Mask shapekeys.
- *  Therefore, this file mostly contains functions for selecting Mask frames (shapekeys).
+ * This file contains code for editing Mask data in the Action Editor
+ * as a 'keyframes', so that a user can adjust the timing of Mask shapekeys.
+ * Therefore, this file mostly contains functions for selecting Mask frames (shapekeys).
  */
 /* ***************************************** */
 /* Generics - Loopers */
index 8980e18..3e9025b 100644 (file)
@@ -349,9 +349,9 @@ int join_mesh_exec(bContext *C, wmOperator *op)
        }
 
        /* - if destination mesh had shapekeys, move them somewhere safe, and set up placeholders
-        *  with arrays that are large enough to hold shapekey data for all meshes
-        * -    if destination mesh didn't have shapekeys, but we encountered some in the meshes we're
-        *      joining, set up a new keyblock and assign to the mesh
+        *   with arrays that are large enough to hold shapekey data for all meshes
+        * - if destination mesh didn't have shapekeys, but we encountered some in the meshes we're
+        *   joining, set up a new keyblock and assign to the mesh
         */
        if (key) {
                /* make a duplicate copy that will only be used here... (must remember to free it!) */
index 214c995..33596e8 100644 (file)
@@ -787,10 +787,10 @@ static void child_get_inverse_matrix(Scene *scene, Object *ob, bConstraint *con,
                if (ob && ob->pose && (pchan = BKE_pose_channel_active(ob))) {
                        bConstraint *con_last;
                        /* calculate/set inverse matrix:
-                        *  We just calculate all transform-stack eval up to but not including this constraint.
-                        *  This is because inverse should just inverse correct for just the constraint's influence
-                        *  when it gets applied; that is, at the time of application, we don't know anything about
-                        *  what follows.
+                        * We just calculate all transform-stack eval up to but not including this constraint.
+                        * This is because inverse should just inverse correct for just the constraint's influence
+                        * when it gets applied; that is, at the time of application, we don't know anything about
+                        * what follows.
                         */
                        float imat[4][4], tmat[4][4];
                        float pmat[4][4];
index a293f7a..05726e5 100644 (file)
@@ -45,7 +45,7 @@
 
 
 /**
- *  Generic randomize vertices function
+ * Generic randomize vertices function
  */
 
 static bool object_rand_transverts(
index 480d17b..dc94cab 100644 (file)
@@ -316,7 +316,7 @@ static void dpaint_bake_endjob(void *customdata)
        WM_set_locked_interface(G_MAIN->wm.first, false);
 
        /* Bake was successful:
-        *  Report for ended bake and how long it took */
+        * Report for ended bake and how long it took */
        if (job->success) {
                /* Show bake info */
                WM_reportf(RPT_INFO, "DynamicPaint: Bake complete! (%.2f)", PIL_check_seconds_timer() - job->start);
index e4d748a..2e8c520 100644 (file)
@@ -572,7 +572,7 @@ int area_getorientation(ScrArea *sa, ScrArea *sb)
 }
 
 /* Helper function to join 2 areas, it has a return value, 0=failed 1=success
- *  used by the split, join operators
+ * used by the split, join operators
  */
 int screen_area_join(bContext *C, bScreen *scr, ScrArea *sa1, ScrArea *sa2)
 {
index 9bb2572..c1e4a5d 100644 (file)
@@ -274,7 +274,8 @@ static int mouse_nla_channels(bContext *C, bAnimContext *ac, float x, int channe
                                if (nlaedit_is_tweakmode_on(ac) == 0) {
                                        /* 'push-down' action - only usable when not in TweakMode */
                                        /* TODO: make this use the operator instead of calling the function directly
-                                        *  however, calling the operator requires that we supply the args, and that works with proper buttons only */
+                                        * however, calling the operator requires that we supply the args,
+                                        * and that works with proper buttons only */
                                        BKE_nla_action_pushdown(adt);
                                }
                                else {
index 2836ed0..53f1aae 100644 (file)
@@ -5784,7 +5784,7 @@ static void clear_trans_object_base_flags(TransInfo *t)
 }
 
 /* auto-keyframing feature - for objects
- *  tmode: should be a transform mode
+ * tmode: should be a transform mode
  */
 // NOTE: context may not always be available, so must check before using it as it's a luxury for a few cases
 void autokeyframe_ob_cb_func(bContext *C, Scene *scene, View3D *v3d, Object *ob, int tmode)
@@ -5900,8 +5900,8 @@ void autokeyframe_ob_cb_func(bContext *C, Scene *scene, View3D *v3d, Object *ob,
 }
 
 /* auto-keyframing feature - for poses/pose-channels
- *  tmode: should be a transform mode
- *     targetless_ik: has targetless ik been done on any channels?
+ * tmode: should be a transform mode
+ * targetless_ik: has targetless ik been done on any channels?
  */
 // NOTE: context may not always be available, so must check before using it as it's a luxury for a few cases
 void autokeyframe_pose_cb_func(bContext *C, Scene *scene, View3D *v3d, Object *ob, int tmode, short targetless_ik)
index 0b76835..9699d74 100644 (file)
@@ -955,9 +955,9 @@ static int stitch_process_data(StitchState *state, Scene *scene, int final)
        /* store indices to editVerts and Faces. May be unneeded but ensuring anyway */
        BM_mesh_elem_index_ensure(bm, BM_VERT | BM_FACE);
 
-       /*****************************************
-        *  First determine stitchability of uvs *
-        *****************************************/
+       /****************************************
+        * First determine stitchability of uvs *
+        ****************************************/
 
        for (i = 0; i < state->selection_size; i++) {
                if (state->mode == STITCH_VERT) {
index fdbfd20..f460d56 100644 (file)
@@ -120,18 +120,16 @@ protected:
 };
 
 /*
-
-  #############################################
-  #############################################
-  #############################################
-  ######                                 ######
-  ######   I M P L E M E N T A T I O N   ######
-  ######                                 ######
-  #############################################
-  #############################################
-  #############################################
-
-*/
+ * #############################################
+ * #############################################
+ * #############################################
+ * ######                                 ######
+ * ######   I M P L E M E N T A T I O N   ######
+ * ######                                 ######
+ * #############################################
+ * #############################################
+ * #############################################
+ */
 
 template<class Map>
 float GaussianFilter::getSmoothedPixel(Map *map, int x, int y)
index a8fe3d8..4103d32 100644 (file)
@@ -113,7 +113,7 @@ public:
         *      0 : the arrays are not copied. The pointers passed as arguments are used. IndexedFaceSet takes these
         *          arrays desallocation in charge.
         *      1 : the arrays are copied. The caller is in charge of the arrays, passed as arguments desallocation.
-       */
+        */
        IndexedFaceSet(float *iVertices, unsigned iVSize, float *iNormals, unsigned iNSize, FrsMaterial **iMaterials,
                       unsigned iMSize, float *iTexCoords, unsigned iTSize, unsigned iNumFaces, unsigned *iNumVertexPerFace,
                       TRIANGLES_STYLE *iFaceStyle, FaceEdgeMark *iFaceEdgeMarks, unsigned *iVIndices, unsigned iVISize,
index 16c9699..74fb875 100644 (file)
@@ -1625,16 +1625,16 @@ public:
 
 
 /*
-  #############################################
-  #############################################
-  #############################################
-  ######                                 ######
-  ######   I M P L E M E N T A T I O N   ######
-  ######                                 ######
-  #############################################
-  #############################################
-  #############################################
-*/
* #############################################
* #############################################
* #############################################
* ######                                 ######
* ######   I M P L E M E N T A T I O N   ######
* ######                                 ######
* #############################################
* #############################################
* #############################################
+ */
 /* for inline functions */
 
 void ViewShape::SplitEdge(FEdge *fe, const vector<TVertex*>& iViewVertices, vector<FEdge*>& ioNewEdges,
index 14109fb..30f55ff 100644 (file)
@@ -1370,18 +1370,16 @@ private:
 
 
 /*
-
-#############################################
-#############################################
-#############################################
-######                                 ######
-######   I M P L E M E N T A T I O N   ######
-######                                 ######
-#############################################
-#############################################
-#############################################
-
-*/
+ * #############################################
+ * #############################################
+ * #############################################
+ * ######                                 ######
+ * ######   I M P L E M E N T A T I O N   ######
+ * ######                                 ######
+ * #############################################
+ * #############################################
+ * #############################################
+ */
 /* for inline functions */
 void WOEdge::RetrieveCWOrderedEdges(vector<WEdge *>& oEdges)
 {
index 774cc67..cabb1f8 100644 (file)
@@ -802,18 +802,16 @@ public:
 };
 
 /*
-
-#############################################
-#############################################
-#############################################
-######                                 ######
-######   I M P L E M E N T A T I O N   ######
-######                                 ######
-#############################################
-#############################################
-#############################################
-
-*/
+ * #############################################
+ * #############################################
+ * #############################################
+ * ######                                 ######
+ * ######   I M P L E M E N T A T I O N   ######
+ * ######                                 ######
+ * #############################################
+ * #############################################
+ * #############################################
+ */
 /* for inline functions */
 
 bool WXVertex::isFeature()
index d0db912..e2f52f5 100644 (file)
@@ -170,7 +170,7 @@ bool ColorBlock::isSingleColor(Color32 mask/*= Color32(0xFF, 0xFF, 0xFF, 0x00)*/
        return true;
 }
 
-/*
+#if 0
 /// Returns true if the block has a single color, ignoring transparent pixels.
 bool ColorBlock::isSingleColorNoAlpha() const
 {
@@ -194,10 +194,11 @@ bool ColorBlock::isSingleColorNoAlpha() const
 
        return true;
 }
-*/
+#endif
 
+#if 0
 /// Count number of unique colors in this color block.
-/*uint ColorBlock::countUniqueColors() const
+uint ColorBlock::countUniqueColors() const
 {
        uint count = 0;
 
@@ -217,9 +218,11 @@ bool ColorBlock::isSingleColorNoAlpha() const
        }
 
        return count;
-}*/
+}
+#endif
 
-/*/// Get average color of the block.
+#if 0
+/// Get average color of the block.
 Color32 ColorBlock::averageColor() const
 {
        uint r, g, b, a;
@@ -233,7 +236,8 @@ Color32 ColorBlock::averageColor() const
        }
 
        return Color32(uint8(r / 16), uint8(g / 16), uint8(b / 16), uint8(a / 16));
-}*/
+}
+#endif
 
 /// Return true if the block is not fully opaque.
 bool ColorBlock::hasAlpha() const
@@ -367,7 +371,8 @@ void ColorBlock::boundsRangeAlpha(Color32 *start, Color32 *end) const
 }
 #endif
 
-/*/// Sort colors by abosolute value in their 16 bit representation.
+#if 0
+/// Sort colors by abosolute value in their 16 bit representation.
 void ColorBlock::sortColorsByAbsoluteValue()
 {
        // Dummy selection sort.
@@ -385,10 +390,11 @@ void ColorBlock::sortColorsByAbsoluteValue()
                }
                swap( m_color[a], m_color[max] );
        }
-}*/
-
+}
+#endif
 
-/*/// Find extreme colors in the given axis.
+#if 0
+/// Find extreme colors in the given axis.
 void ColorBlock::computeRange(Vector3::Arg axis, Color32 *start, Color32 *end) const
 {
 
@@ -415,10 +421,11 @@ void ColorBlock::computeRange(Vector3::Arg axis, Color32 *start, Color32 *end) c
 
        *start = m_color[mini];
        *end = m_color[maxi];
-}*/
-
+}
+#endif
 
-/*/// Sort colors in the given axis.
+#if 0
+/// Sort colors in the given axis.
 void ColorBlock::sortColors(const Vector3 & axis)
 {
        float luma_array[16];
@@ -439,10 +446,11 @@ void ColorBlock::sortColors(const Vector3 & axis)
                swap( luma_array[a], luma_array[min] );
                swap( m_color[a], m_color[min] );
        }
-}*/
-
+}
+#endif
 
-/*/// Get the volume of the color block.
+#if 0
+/// Get the volume of the color block.
 float ColorBlock::volume() const
 {
        Box bounds;
@@ -455,4 +463,4 @@ float ColorBlock::volume() const
 
        return bounds.volume();
 }
-*/
+#endif
index df9182c..8e49dba 100644 (file)
@@ -792,7 +792,7 @@ void DDSHeader::setUserVersion(int version)
        this->reserved[8] = version;
 }
 
-/*
+#if 0
 void DDSHeader::swapBytes()
 {
        this->fourcc = POSH_LittleU32(this->fourcc);
@@ -828,7 +828,7 @@ void DDSHeader::swapBytes()
        this->header10.arraySize = POSH_LittleU32(this->header10.arraySize);
        this->header10.reserved = POSH_LittleU32(this->header10.reserved);
 }
-*/
+#endif
 
 bool DDSHeader::hasDX10Header() const
 {
@@ -909,11 +909,11 @@ bool DirectDrawSurface::isValid() const
        }
 
        /* in some files DDSCAPS_TEXTURE is missing: silently ignore */
-       /*
-       if ( !(header.caps.caps1 & DDSCAPS_TEXTURE) ) {
+#if 0
+       if (!(header.caps.caps1 & DDSCAPS_TEXTURE)) {
                return false;
        }
-       */
+#endif
 
        return true;
 }
index ba48feb..50690cf 100644 (file)
@@ -765,17 +765,16 @@ fail:
        return DIRTY_FLAG_ENCODING;
 }
 
-/*
- *     output_iris -
- *             copy an array of ints to an iris image file.  Each int
- *     represents one pixel.  xsize and ysize specify the dimensions of
- *     the pixel array.  zsize specifies what kind of image file to
- *     write out.  if zsize is 1, the luminance of the pixels are
- *     calculated, and a single channel black and white image is saved.
- *     If zsize is 3, an RGB image file is saved.  If zsize is 4, an
- *     RGBA image file is saved.
+/**
+ * Copy an array of ints to an iris image file.
+ * Each int represents one pixel.  xsize and ysize specify the dimensions of
+ * the pixel array.  zsize specifies what kind of image file to
+ * write out.  if zsize is 1, the luminance of the pixels are
+ * calculated, and a single channel black and white image is saved.
+ * If zsize is 3, an RGB image file is saved.  If zsize is 4, an
+ * RGBA image file is saved.
  *
- *  Added: zbuf write
+ * Added: zbuf write
  */
 
 static int output_iris(uint *lptr, int xsize, int ysize, int zsize, const char *name, int *zptr)
index 0d650da..f72a924 100644 (file)
@@ -178,10 +178,10 @@ static tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n)
  * \param handle: Handle of the TIFF file (pointer to ImbTIFFMemFile).
  * \param ofs:    Offset value (interpreted according to whence below).
  * \param whence: This can be one of three values:
- *  SEEK_SET - The offset is set to ofs bytes.
- *  SEEK_CUR - The offset is set to its current location plus ofs bytes.
- *  SEEK_END - (This is unsupported and will return -1, indicating an
- *              error).
+ * SEEK_SET - The offset is set to ofs bytes.
+ * SEEK_CUR - The offset is set to its current location plus ofs bytes.
+ * SEEK_END - (This is unsupported and will return -1, indicating an
+ *             error).
  *
  * \return: Resulting offset location within the file, measured in bytes from
  *          the beginning of the file.  (-1) indicates an error.
index 6b963bb..c90a626 100644 (file)
@@ -130,8 +130,8 @@ typedef struct EffectorWeights {
 /* Point cache file data types:
  * - used as (1<<flag) so poke jahka if you reach the limit of 15
  * - to add new data types update:
- *             * BKE_ptcache_data_size()
- *             * ptcache_file_init_pointers()
+ *   - BKE_ptcache_data_size()
+ *   - ptcache_file_init_pointers()
  */
 #define BPHYS_DATA_INDEX               0
 #define BPHYS_DATA_LOCATION            1
index f1c22a8..a96354f 100644 (file)
@@ -106,15 +106,15 @@ typedef struct ParticleData {
 
        int totkey;                             /* amount of hair or keyed keys*/
 
-       float time, lifetime;   /* dietime is not nescessarily time+lifetime as */
-       float dietime;                  /* particles can die unnaturally (collision)    */
+       float time, lifetime;   /* dietime is not nescessarily time+lifetime as */
+       float dietime;                  /* particles can die unnaturally (collision). */
 
        /* WARNING! Those two indices, when not affected to vertices, are for !!! TESSELLATED FACES !!!, not POLYGONS! */
        int num;                                /* index to vert/edge/face */
        int num_dmcache;                /* index to derived mesh data (face) to avoid slow lookups */
 
        float fuv[4], foffset;  /* coordinates on face/edge number "num" and depth along*/
-                                                       /* face normal for volume emission                                              */
+                                                       /* face normal for volume emission. */
 
        float size;                             /* size and multiplier so that we can update size when ever */
 
index 2a62ada..505b89f 100644 (file)
@@ -118,7 +118,7 @@ typedef enum eFFMpegPreset {
        /* Used by WEBM/VP9 and h.264 to control encoding speed vs. file size.
         * WEBM/VP9 use these values directly, whereas h.264 map those to
         * respectively the MEDIUM, SLOWER, and SUPERFAST presets.
-       */
+        */
        FFM_PRESET_GOOD = 10, /* the default and recommended for most applications */
        FFM_PRESET_BEST, /* recommended if you have lots of time and want the best compression efficiency */
        FFM_PRESET_REALTIME, /* recommended for live / fast encoding */
@@ -374,8 +374,8 @@ typedef enum eStereo3dInterlaceType {
  * this is used for NodeImageFile and IMAGE_OT_save_as operator too.
  *
  * note: its a bit strange that even though this is an image format struct
- *  the imtype can still be used to select video formats.
- *  RNA ensures these enum's are only selectable for render output.
+ * the imtype can still be used to select video formats.
+ * RNA ensures these enum's are only selectable for render output.
  */
 typedef struct ImageFormatData {
        char imtype;   /* R_IMF_IMTYPE_PNG, R_... */
@@ -1321,9 +1321,9 @@ typedef struct UnifiedPaintSettings {
        float brush_rotation;
        float brush_rotation_sec;
 
-       /*********************************************************************************
-        *  all data below are used to communicate with cursor drawing and tex sampling  *
-        *********************************************************************************/
+       /*******************************************************************************
+        * all data below are used to communicate with cursor drawing and tex sampling *
+        *******************************************************************************/
        int anchored_size;
 
        float overlap_factor; /* normalization factor due to accumulated value of curve along spacing.
index ee8c197..9726602 100644 (file)
@@ -25,7 +25,9 @@
 
 /** \file RNA_define.h
  *  \ingroup RNA
- *  Functions used during preprocess and runtime, for defining the RNA. */
+ *
+ * Functions used during preprocess and runtime, for defining the RNA.
+ */
 
 #include <float.h>
 #include <limits.h>
index bb204bf..1afa462 100644 (file)
@@ -1461,16 +1461,16 @@ static void rna_def_brush(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Image Painting Capabilities", "Brush's capabilities in image paint mode");
 }
 
-
-/* A brush stroke is a list of changes to the brush that
+/**
+ * A brush stroke is a list of changes to the brush that
  * can occur during a stroke
  *
- *  o 3D location of the brush
- *  o 2D mouse location
- *  o Tablet pressure
- *  o Direction flip
- *  o Tool switch
- *  o Time
+ * - 3D location of the brush
+ * - 2D mouse location
+ * - Tablet pressure
+ * - Direction flip
+ * - Tool switch
+ * - Time
  */
 static void rna_def_operator_stroke_element(BlenderRNA *brna)
 {
index d16ef3d..c82c95e 100644 (file)
@@ -127,7 +127,7 @@ static void rna_DynamicPaintSurface_changePreview(Main *bmain, Scene *scene, Poi
        DynamicPaintSurface *surface = act_surface->canvas->surfaces.first;
 
        /* since only one color surface can show preview at time
-        *  disable preview on other surfaces*/
+        * disable preview on other surfaces. */
        for (; surface; surface = surface->next) {
                if (surface != act_surface)
                        surface->flags &= ~MOD_DPAINT_PREVIEW;
index a2286f0..05fd0ee 100644 (file)
@@ -1528,7 +1528,7 @@ static void rna_def_particle(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Keyed States", "");
 /* */
 /*     float fuv[4], foffset;   *//* coordinates on face/edge number "num" and depth along*/
-/*                                                      *//* face normal for volume emission                                           */
+/*                                                      *//* face normal for volume emission */
 
        prop = RNA_def_property(srna, "birth_time", PROP_FLOAT, PROP_TIME);
        RNA_def_property_float_sdna(prop, NULL, "time");
index 5fd9c6b..e4d93b7 100644 (file)
 static float I[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
 static float ZERO[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
 
-/*
+#if 0
 #define C99
 #ifdef C99
 #defineDO_INLINE inline
 #else
 #defineDO_INLINE static
 #endif
-*/
+#endif  /* if 0 */
+
 struct Cloth;
 
 //////////////////////////////////////////
@@ -383,14 +384,18 @@ DO_INLINE void inverse_fmatrix(float to[3][3], float from[3][3])
                        int i2=(i+2)%3;
                        int j1=(j+1)%3;
                        int j2=(j+2)%3;
-                       // reverse indexs i&j to take transpose
+                       /** Reverse indexs i&j to take transpose. */
                        to[j][i] = (from[i1][j1]*from[i2][j2]-from[i1][j2]*from[i2][j1])/d;
-                       /*
-                       if (i==j)
-                       to[i][j] = 1.0f / from[i][j];
-                       else
-                       to[i][j] = 0;
-                       */
+                       /**
+                        * <pre>
+                        * if (i == j) {
+                        *     to[i][j] = 1.0f / from[i][j];
+                        * }
+                        * else {
+                        *     to[i][j] = 0;
+                        * }
+                        * </pre>
+                        */
                }
        }
 
@@ -916,7 +921,8 @@ DO_INLINE void BuildPPinv(fmatrix3x3 *lA, fmatrix3x3 *P, fmatrix3x3 *Pinv)
 
        }
 }
-/*
+
+#if 0
 // version 1.3
 static int cg_filtered_pre(lfVector *dv, fmatrix3x3 *lA, lfVector *lB, lfVector *z, fmatrix3x3 *S, fmatrix3x3 *P, fmatrix3x3 *Pinv)
 {
@@ -988,7 +994,8 @@ static int cg_filtered_pre(lfVector *dv, fmatrix3x3 *lA, lfVector *lB, lfVector
 
        return iterations<conjgrad_looplimit;
 }
-*/
+#endif
+
 // version 1.4
 static int cg_filtered_pre(lfVector *dv, fmatrix3x3 *lA, lfVector *lB, lfVector *z, fmatrix3x3 *S, fmatrix3x3 *P, fmatrix3x3 *Pinv, fmatrix3x3 *bigI)
 {
@@ -1031,7 +1038,7 @@ static int cg_filtered_pre(lfVector *dv, fmatrix3x3 *lA, lfVector *lB, lfVector
        // deltaNew = r^TP
        deltaNew = dot_lfvector(r, p, numverts);
 
-       /*
+#if 0
        filter(dv, S);
        add_lfvector_lfvector(dv, dv, z, numverts);
 
@@ -1045,7 +1052,7 @@ static int cg_filtered_pre(lfVector *dv, fmatrix3x3 *lA, lfVector *lB, lfVector
        deltaNew = dot_lfvector(r, p, numverts);
 
        delta0 = deltaNew * sqrt(conjgrad_epsilon);
-       */
+#endif
 
 #ifdef DEBUG_TIME
        double start = PIL_check_seconds_timer();
@@ -1541,8 +1548,8 @@ BLI_INLINE bool spring_length(Implicit_Data *data, int i, int j, float r_extent[
        *r_length = len_v3(r_extent);
 
        if (*r_length > ALMOST_ZERO) {
-               /*
-               if (length>L) {
+#if 0
+               if (length > L) {
                        if ((clmd->sim_parms->flags & CSIMSETT_FLAG_TEARING_ENABLED) &&
                            ( ((length-L)*100.0f/L) > clmd->sim_parms->maxspringlen ))
                        {
@@ -1551,7 +1558,7 @@ BLI_INLINE bool spring_length(Implicit_Data *data, int i, int j, float r_extent[
                                return false;
                        }
                }
-               */
+#endif
                mul_v3_v3fl(r_dir, r_extent, 1.0f/(*r_length));
        }
        else {
index eaac638..fd91df9 100644 (file)
@@ -900,8 +900,8 @@ BLI_INLINE bool spring_length(Implicit_Data *data, int i, int j, float r_extent[
        *r_length = len_v3(r_extent);
 
        if (*r_length > ALMOST_ZERO) {
-               /*
-               if (length>L) {
+#if 0
+               if (length > L) {
                        if ((clmd->sim_parms->flags & CSIMSETT_FLAG_TEARING_ENABLED) &&
                            ( ((length-L)*100.0f/L) > clmd->sim_parms->maxspringlen ))
                        {
@@ -910,7 +910,7 @@ BLI_INLINE bool spring_length(Implicit_Data *data, int i, int j, float r_extent[
                                return false;
                        }
                }
-               */
+#endif
                mul_v3_v3fl(r_dir, r_extent, 1.0f/(*r_length));
        }
        else {
index d8d6b5c..327f325 100644 (file)
@@ -691,7 +691,7 @@ PyObject *PyC_UnicodeFromByte(const char *str)
  * Description: This function creates a new Python dictionary object.
  * note: dict is owned by sys.modules["__main__"] module, reference is borrowed
  * note: important we use the dict from __main__, this is what python expects
- *  for 'pickle' to work as well as strings like this...
+ * for 'pickle' to work as well as strings like this...
  * >> foo = 10
  * >> print(__import__("__main__").foo)
  *
index 7cf669e..43796dc 100644 (file)
@@ -62,7 +62,7 @@ static struct PyModuleDef gpumodule = {
        "gpu",     /* name of module */
        M_gpu_doc, /* module documentation */
        -1,        /* size of per-interpreter state of the module,
-                   *  or -1 if the module keeps state in global variables. */
+                   * or -1 if the module keeps state in global variables. */
        NULL, NULL, NULL, NULL, NULL
 };
 
index 6a40f22..c203ac2 100644 (file)
@@ -847,7 +847,7 @@ static PyObject *Vector_orthogonal(VectorObject *self)
 /**
  * Vector.reflect(mirror): return a reflected vector on the mirror normal.
  * <pre>
- *  vec - ((2 * dot(vec, mirror)) * mirror)
+ * vec - ((2 * dot(vec, mirror)) * mirror)
  * </pre>
  */
 PyDoc_STRVAR(Vector_reflect_doc,
@@ -1650,7 +1650,7 @@ static PyObject *Vector_isub(PyObject *v1, PyObject *v2)
 
 
 /**
- *  column vector multiplication (Matrix * Vector)
+ * Column vector multiplication (Matrix * Vector).
  * <pre>
  * [1][4][7]   [a]
  * [2][5][8] * [b]
@@ -2299,7 +2299,7 @@ static PyObject *Vector_swizzle_get(VectorObject *self, void *closure)
 }
 
 /**
- *  Set the items of this vector using a swizzle.
+ * Set the items of this vector using a swizzle.
  * - If value is a vector or list this operates like an array copy, except that
  *   the destination is effectively re-ordered as defined by the swizzle. At
  *   most min(len(source), len(dest)) values will be copied.
index 7426e95..fb3c8b5 100644 (file)
@@ -358,8 +358,8 @@ static int wood(Tex *tex, const float texvec[3], TexResult *texres)
 static float marble_int(Tex *tex, float x, float y, float z)
 {
        float n, mi;
-       short wf = tex->noisebasis2;    /* wave form:   TEX_SIN=0,  TEX_SAW=1,  TEX_TRI=2                                               */
-       short mt = tex->stype;                  /* marble type: TEX_SOFT=0,     TEX_SHARP=1,TEX_SHAPER=2                                        */
+       short wf = tex->noisebasis2;    /* wave form:   TEX_SIN=0, TEX_SAW=1, TEX_TRI=2 */
+       short mt = tex->stype;                  /* marble type: TEX_SOFT=0, TEX_SHARP=1, TEX_SHAPER=2 */
 
        float (*waveform[3])(float);    /* create array of pointers to waveform functions */
        waveform[0] = tex_sin;                  /* assign address of tex_sin() function to pointer array */
index dd2f9b4..33e918b 100644 (file)
 /** \file blender/windowmanager/WM_api.h
  *  \ingroup wm
  *
- *  \page wmpage windowmanager
- *  \section wmabout About windowmanager
- *  \ref wm handles events received from \ref GHOST and manages
- *  the screens, areas and input for Blender
- *  \section wmnote NOTE
- *  \todo document
+ * \page wmpage windowmanager
+ * \section wmabout About windowmanager
+ * \ref wm handles events received from \ref GHOST and manages
+ * the screens, areas and input for Blender
+ * \section wmnote NOTE
+ * \todo document
  */
 
 /* dna-savable wmStructs here */
index dd9e7ed..d7df671 100644 (file)
  *   - add timer notifier to handle progress
  *
  * Stop job
- *   - signal job to end
- *  on end, job will tag itself as sleeping
+ * - signal job to end
+ * on end, job will tag itself as sleeping
  *
  * Remove job
  * - signal job to end
- *  on end, job will remove itself
+ * on end, job will remove itself
  *
  * When job is done:
  * - it puts timer to sleep (or removes?)
index 55f29cc..cee7d6a 100644 (file)
@@ -26,9 +26,8 @@
 
 
 /*
- *  These define have its origin at sgi, where all device defines were written down in device.h.
- *  Blender copied the conventions quite some, and expanded it with internal new defines (ton)
- *
+ * These define have its origin at sgi, where all device defines were written down in device.h.
+ * Blender copied the conventions quite some, and expanded it with internal new defines (ton)
  */
 
 
index 33da54f..e375b65 100644 (file)
@@ -539,7 +539,7 @@ int main(
        WM_main(C);
 
        return 0;
-} /* end of int main(argc, argv)       */
+} /* end of int main(argc, argv) */
 
 #ifdef WITH_PYTHON_MODULE
 void main_python_exit(void)