Cleanup: comment blocks
authorCampbell Barton <ideasman42@gmail.com>
Sun, 2 Sep 2018 08:28:27 +0000 (18:28 +1000)
committerCampbell Barton <ideasman42@gmail.com>
Sun, 2 Sep 2018 08:28:27 +0000 (18:28 +1000)
125 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/BKE_gpencil_modifier.h
source/blender/blenkernel/BKE_shader_fx.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/gpencil.c
source/blender/blenkernel/intern/gpencil_modifier.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/shader_fx.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_mesh.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/depsgraph/intern/builder/deg_builder_relations.cc
source/blender/depsgraph/intern/eval/deg_eval_copy_on_write.cc
source/blender/draw/engines/gpencil/gpencil_draw_cache_impl.c
source/blender/draw/engines/gpencil/gpencil_draw_utils.c
source/blender/draw/engines/gpencil/gpencil_engine.c
source/blender/draw/engines/gpencil/gpencil_render.c
source/blender/draw/engines/gpencil/gpencil_shader_fx.c
source/blender/draw/intern/draw_manager.c
source/blender/draw/modes/edit_metaball_mode.c
source/blender/draw/modes/object_mode.c
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/gizmo_library/gizmo_types/button2d_gizmo.c
source/blender/editors/gpencil/annotate_paint.c
source/blender/editors/gpencil/drawgpencil.c
source/blender/editors/gpencil/editaction_gpencil.c
source/blender/editors/gpencil/gpencil_armature.c
source/blender/editors/gpencil/gpencil_brush.c
source/blender/editors/gpencil/gpencil_data.c
source/blender/editors/gpencil/gpencil_edit.c
source/blender/editors/gpencil/gpencil_fill.c
source/blender/editors/gpencil/gpencil_intern.h
source/blender/editors/gpencil/gpencil_old.c
source/blender/editors/gpencil/gpencil_ops.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/gpencil/gpencil_select.c
source/blender/editors/gpencil/gpencil_utils.c
source/blender/editors/include/ED_keyframing.h
source/blender/editors/interface/interface_draw.c
source/blender/editors/interface/interface_templates.c
source/blender/editors/interface/view2d.c
source/blender/editors/mask/mask_editaction.c
source/blender/editors/mesh/editmesh_rip.c
source/blender/editors/mesh/editmesh_rip_edge.c
source/blender/editors/mesh/meshtools.c
source/blender/editors/object/object_constraint.c
source/blender/editors/object/object_modifier.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/space_view3d/view3d_draw.c
source/blender/editors/transform/transform.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/gpu/GPU_legacy_stubs.h
source/blender/gpu/GPU_shader.h
source/blender/gpu/shaders/gpu_shader_image_alpha_color_frag.glsl
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_gpencil_types.h
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_gpencil.c
source/blender/makesrna/intern/rna_particle.c
source/blender/modifiers/intern/MOD_weighted_normal.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/intern/wm_operators.c
source/blender/windowmanager/wm_event_types.h
source/creator/creator.c

index 670b86d456fdf6c77d059011a699682b6709e6e3..327ecd4b2455a036a34c7ad75f93441f68082675 100644 (file)
@@ -117,9 +117,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 de12dfad8159b6028a2c8f823244f7210d54ee67..72463b456c6ef39b87495be4aa1c399d28e3af0b 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 2fd8603516dd7801196b6202eec38ce09ece1bd0..464d9269f28274c0128eb9eff8895136c4d3c910 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 99fa5026c0333a972a80206c019be32ce6a66cd7..bcf7d4e587a5ecce2263de3c2a21d48c19789ab5 100644 (file)
@@ -1446,9 +1446,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 4564bebe4fc28b1693f61b04a251fa8395a719bd..ec6da53631d6311db4d9d47cba20ab2df791eba2 100644 (file)
@@ -397,7 +397,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 e6a4682ee7cbe95cc57d2a379a2d26991ba164c5..59d3123b9deb754c251ccb2316f92a828dfae08a 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 6f83dbcce5975652862a2d92b521bb5d6e5430ee..cfc7d8e6065fad1570b4a1248b9c610eee5c1974 100644 (file)
@@ -68,16 +68,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 be27560bbf2f49f18099a8b7ebf1abf2e3022ab8..a5647f5ad0d9939bccb54f33981f6d36a95640f5 100644 (file)
@@ -66,16 +66,16 @@ typedef enum {
        eGpencilModifierTypeFlag_SupportsEditmode = (1 << 1),
 
        /* For modifiers that support editmode this determines if the
-       * modifier should be enabled by default in editmode. This should
-       * only be used by modifiers that are relatively speedy and
-       * also generally used in editmode, otherwise let the user enable
-       * it by hand.
-       */
+        * modifier should be enabled by default in editmode. This should
+        * only be used by modifiers that are relatively speedy and
+        * also generally used in editmode, otherwise let the user enable
+        * it by hand.
+        */
        eGpencilModifierTypeFlag_EnableInEditmode = (1 << 2),
 
        /* For modifiers that require original data and so cannot
-       * be placed after any non-deformative modifier.
-       */
+        * be placed after any non-deformative modifier.
+        */
        eGpencilModifierTypeFlag_RequiresOriginalData = (1 << 3),
 
        /* max one per type */
index d2c8cfb457cf6f4eb1b64271c4f96c2ed2fd08f2..3306d8256e8808072750b6f62fee5f3e241b37fa 100644 (file)
@@ -63,8 +63,8 @@ typedef enum {
        eShaderFxTypeFlag_SupportsEditmode = (1 << 0),
 
        /* For effects that support editmode this determines if the
-       * effect should be enabled by default in editmode.
-       */
+        * effect should be enabled by default in editmode.
+        */
        eShaderFxTypeFlag_EnableInEditmode = (1 << 2),
 
        /* max one per type */
@@ -95,8 +95,8 @@ typedef struct ShaderFxTypeInfo {
        ShaderFxTypeFlag flags;
 
        /* Copy instance data for this effect type. Should copy all user
-       * level settings to the target effect.
-       */
+        * level settings to the target effect.
+        */
        void(*copyData)(const struct ShaderFxData *fx, struct ShaderFxData *target);
 
        /* Initialize new instance data for this effect type, this function
index 19ac81b4bb7787a74fac7841b2255308f1774788..bb3d468fd7bad5ec8d9935071077a615efd7d80d 100644 (file)
@@ -1243,7 +1243,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(
@@ -1445,7 +1445,7 @@ BVHTree *BKE_bvhtree_from_mesh_get(
                                if (data_cp.cached == false) {
                                        int looptri_num = BKE_mesh_runtime_looptri_len(mesh);
                                        /* 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 && mesh->totpoly != 0));
 
                                        data_cp.tree = bvhtree_from_mesh_looptri_create_tree(
index ce723d4a7f29215086c32c8b16bfe86b0af49c9f..53894431fc3cf8aa0278c6833f04cf1159c8023b 100644 (file)
@@ -570,11 +570,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;
        }
@@ -640,10 +640,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 4b61d35cac81b33e85a6dc54630727b82e10ee83..eadf6c5ea227dd3b7c25b77cb11499781973efb9 100644 (file)
@@ -1347,7 +1347,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]++;
@@ -1355,7 +1355,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;
@@ -1389,7 +1389,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);
@@ -1557,7 +1557,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();
 
@@ -2884,7 +2884,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;
@@ -3349,9 +3349,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)
 {
@@ -4005,7 +4005,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,
@@ -4717,7 +4717,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;
@@ -4734,7 +4734,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);
@@ -4884,7 +4884,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);
 
@@ -4946,7 +4946,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)
@@ -5047,7 +5047,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;
 
@@ -5558,7 +5558,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 1e4c868a3dbf3a823dce0e93f21956f887106468..bf516a6b7394a7e2d0181a0ceb9d90252ea0fd6e 100644 (file)
@@ -2022,8 +2022,8 @@ float evaluate_driver(PathResolvedRNA *anim_rna, ChannelDriver *driver, ChannelD
                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 b69bce088d2b8a2ace0a626dc3b5ea571fd00801..5911d1552785a00b1bc0da88484f940c3ee5e56e 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 6d771148723c1380072719e3da6a2325bcee1e96..20c069fcbdbedee268841401807fb58a7e34c68a 100644 (file)
@@ -1265,8 +1265,8 @@ bool BKE_gpencil_smooth_stroke(bGPDstroke *gps, int i, float inf)
        }
 
        /* Only affect endpoints by a fraction of the normal strength,
-       * to prevent the stroke from shrinking too much
-       */
+        * to prevent the stroke from shrinking too much
+        */
        if ((i == 0) || (i == gps->totpoints - 1)) {
                inf *= 0.1f;
        }
@@ -1332,8 +1332,8 @@ bool BKE_gpencil_smooth_stroke_strength(bGPDstroke *gps, int point_index, float
        ptc = &gps->points[after];
 
        /* the optimal value is the corresponding to the interpolation of the strength
-        at the distance of point b
-       */
+        * at the distance of point b
+        */
        const float fac = line_point_factor_v3(&ptb->x, &pta->x, &ptc->x);
        const float optimal = (1.0f - fac) * pta->strength + fac * ptc->strength;
 
@@ -1366,8 +1366,8 @@ bool BKE_gpencil_smooth_stroke_thickness(bGPDstroke *gps, int point_index, float
        ptc = &gps->points[after];
 
        /* the optimal value is the corresponding to the interpolation of the pressure
-        at the distance of point b
-       */
+        * at the distance of point b
+        */
        float fac = line_point_factor_v3(&ptb->x, &pta->x, &ptc->x);
        float optimal = interpf(ptc->pressure, pta->pressure, fac);
 
@@ -1400,8 +1400,8 @@ bool BKE_gpencil_smooth_stroke_uv(bGPDstroke *gps, int point_index, float influe
        ptc = &gps->points[after];
 
        /* the optimal value is the corresponding to the interpolation of the pressure
-        at the distance of point b
-       */
+        * at the distance of point b
+        */
        float fac = line_point_factor_v3(&ptb->x, &pta->x, &ptc->x);
        float optimal = interpf(ptc->uv_rot, pta->uv_rot, fac);
 
index bff71f648719053ddfe7842d81b250722e8d233d..cf5c58d5727104cc0bfb1f8f185f59c44dbb4296 100644 (file)
@@ -584,7 +584,7 @@ void BKE_gpencil_modifier_copyData_generic(const GpencilModifierData *md_src, Gp
        const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md_src->type);
 
        /* md_dst may have alredy be fully initialized with some extra allocated data,
-       * we need to free it now to avoid memleak. */
+        * we need to free it now to avoid memleak. */
        if (mti->freeData) {
                mti->freeData(md_dst);
        }
index 37560cf84ae2ae512b6893a9e5e628edbc48abe9..03d0d9704dd4db4eabc8928cbba0ddd1e8c0fe8e 100644 (file)
@@ -2313,8 +2313,8 @@ void BKE_object_where_is_calc(Depsgraph *depsgraph, Scene *scene, Object *ob)
  *
  * It assumes the object parent is already in the depsgraph.
  * Otherwise, after changing ob->parent you need to call:
- *  DEG_relations_tag_update(bmain);
- *  BKE_scene_graph_update_tagged(depsgraph, bmain);
+ * - #DEG_relations_tag_update(bmain);
+ * - #BKE_scene_graph_update_tagged(depsgraph, bmain);
  */
 void BKE_object_workob_calc_parent(Depsgraph *depsgraph, Scene *scene, Object *ob, Object *workob)
 {
@@ -3934,7 +3934,7 @@ bool BKE_object_modifier_update_subframe(
                if (ob->track) no_update |= BKE_object_modifier_update_subframe(depsgraph, 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;
 
@@ -3963,7 +3963,7 @@ bool BKE_object_modifier_update_subframe(
        BKE_animsys_evaluate_animdata(depsgraph, scene, &ob->id, ob->adt, frame, ADT_RECALC_ANIM);
        if (update_mesh) {
                /* ignore cache clear during subframe updates
-                *  to not mess up cache validity */
+                * to not mess up cache validity */
                object_cacheIgnoreClear(ob, 1);
                BKE_object_handle_update(depsgraph, scene, ob);
                object_cacheIgnoreClear(ob, 0);
index da5efe3eeb8475f4af8f6978a32316bb5bbde394..ef681c72676ee928fda39cf908c74c719f5d065f 100644 (file)
@@ -2193,12 +2193,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 65d023fb6f2b9ed7339ad8fcb81a8cbe173517c7..5deaa5e4ce9b52d580a5285a7b1e3b3880941b3a 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 b5b4ec5cd41d5d658fccafc1e223e81ba1a14ccc..936f13fe3821b7b9f4fea8dd2c26ad9fb9f4ee23 100644 (file)
@@ -2420,21 +2420,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 c028c2184fd28d7b5b62926bad2dd3c52a011c0d..0bbac9b7a2ae30e3ca4578db76a0c6ce68161674 100644 (file)
@@ -166,7 +166,7 @@ void BKE_shaderfx_copyData_generic(const ShaderFxData *fx_src, ShaderFxData *fx_
        const ShaderFxTypeInfo *fxi = BKE_shaderfxType_getInfo(fx_src->type);
 
        /* fx_dst may have alredy be fully initialized with some extra allocated data,
-       * we need to free it now to avoid memleak. */
+        * we need to free it now to avoid memleak. */
        if (fxi->freeData) {
                fxi->freeData(fx_dst);
        }
index c9b10e36ed1369672db99f390de397199ad23481..e9832d723e4f0e48909ce73e89c4edcecfc19f65 100644 (file)
@@ -1514,7 +1514,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) {
@@ -2711,7 +2711,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);
@@ -3067,7 +3067,7 @@ static void smoke_calc_transparency(SmokeDomainSettings *sds, ViewLayer *view_la
 }
 
 /* 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 3ab55b3705afd7a7e70888a5cbe63cef36aa2c62..1f5cefd47d7f795a787aaa370dabe7a7c31f0040 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>
@@ -256,16 +254,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 {
@@ -732,8 +730,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 */
@@ -925,29 +923,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*/
 
@@ -1704,11 +1702,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);
@@ -1809,7 +1807,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;
@@ -1845,7 +1844,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 */
@@ -2248,7 +2248,7 @@ static void softbody_calc_forces(struct Depsgraph *depsgraph, Scene *scene, Obje
 
                /* 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 */
@@ -2417,16 +2417,16 @@ static void softbody_calc_forces(struct Depsgraph *depsgraph, Scene *scene, Obje
                                        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 {
@@ -2498,10 +2498,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   */
@@ -2697,11 +2697,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 */
@@ -2766,9 +2766,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 03390a0dbcd455db554e0b125f40ecbed73fa516..8e873c76dc965b5275d4be063398daf438959a52 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 6ef77890e95eb5221b4f74ae6938713a2c1cb299..eb3a79502ae9b06afc7b2bd92b77e5491496fcce 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 c04fd79f7aa58f4adde242be13477d5ffa77b769..122464735231f6536e1924fabd2dc8bb2da153d0 100644 (file)
@@ -2906,8 +2906,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)
 {
@@ -3468,8 +3469,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 8c36167371525a8a67b7ebf94e8dc6a81a216eff..b93a7f55821e76f6e0d45a700456975108ad85d7 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 de24fc4d1f56099fd8217a5471a60f809f26f9b1..296086ed652cffb7368def8939067846a34473f6 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 5d3c6b35ac1b8cdedf22bc43b449c9745ac30f91..2bb5d5397a93b3a57d62eaab20d1aab6918a796d 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 e3b779ddbcd36401eaa05e4a60180ec424fcfcb4..e9c92e0d5e401e88f0a310beb7d1264627808d0f 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 0dcbc05b201ceec7f9d92c392ed683d6b4e9cf27..8833564e486a7a626315cf5a1c51d8e00ee62a8f 100644 (file)
@@ -1096,24 +1096,24 @@ void BM_lnorspace_invalidate(BMesh *bm, const bool do_invalidate_all)
        BMLoop *l;
        BMIter viter, liter;
        /* Note: we could use temp tag of BMItem for that, but probably better not use it in such a low-level func?
-       * --mont29 */
+        * --mont29 */
        BLI_bitmap *done_verts = BLI_BITMAP_NEW(bm->totvert, __func__);
 
        BM_mesh_elem_index_ensure(bm, BM_VERT);
 
        /* When we affect a given vertex, we may affect following smooth fans:
-       *     - all smooth fans of said vertex;
-       *     - all smooth fans of all immediate loop-neighbors vertices;
-       * This can be simplified as 'all loops of selected vertices and their immediate neighbors'
-       * need to be tagged for update.
-       */
+        *     - all smooth fans of said vertex;
+        *     - all smooth fans of all immediate loop-neighbors vertices;
+        * This can be simplified as 'all loops of selected vertices and their immediate neighbors'
+        * need to be tagged for update.
+        */
        BM_ITER_MESH(v, &viter, bm, BM_VERTS_OF_MESH) {
                if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
                        BM_ITER_ELEM(l, &liter, v, BM_LOOPS_OF_VERT) {
                                BM_ELEM_API_FLAG_ENABLE(l, BM_LNORSPACE_UPDATE);
 
                                /* Note that we only handle unselected neighbor vertices here, main loop will take care of
-                               * selected ones. */
+                                * selected ones. */
                                if ((!BM_elem_flag_test(l->prev->v, BM_ELEM_SELECT)) &&
                                    !BLI_BITMAP_TEST(done_verts, BM_elem_index_get(l->prev->v)))
                                {
@@ -1265,10 +1265,10 @@ void BM_normals_loops_edges_tag(BMesh *bm, const bool do_edges)
 }
 
 /**
-* Auxillary function only used by rebuild to detect if any spaces were not marked as invalid.
-* Reports error if any of the lnor spaces change after rebuilding, meaning that all the possible
-* lnor spaces to be rebuilt were not correctly marked.
-*/
+ * Auxillary function only used by rebuild to detect if any spaces were not marked as invalid.
+ * Reports error if any of the lnor spaces change after rebuilding, meaning that all the possible
+ * lnor spaces to be rebuilt were not correctly marked.
+ */
 #ifndef NDEBUG
 void BM_lnorspace_err(BMesh *bm)
 {
index c054089480f82ffe5a2608978a412dc3c04a74a0..427ef239abc8ab564af960b552b98d35160ff560 100644 (file)
@@ -1529,7 +1529,7 @@ static BMO_FlagSet bmo_enum_similar_edges_types[] = {
 /*
  * 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 421b2adc3a78fadccf3de23e4736c1a6d90ce172..8c96c938cefc84613b6d4e7469b0c9d56e49ec93 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 daee22ffe76ab06399ff7b98b09037c24b676742..61e47a6cbd449e4bcbee8c1e25cc253cb6d15e17 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 33ad7836893dc6a39b28372a7b8b67aaff5dd8aa..540888ac0b961ee669df21e5b5b43aab75c28158 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 317045b303cd83b574cb2dcbf5f66d225b5534c6..9f394aacc1c24686871484f00a26fc031de26e19 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 90e4033d572272dc3301b46561f5d36580877fb8..ed32a9bbc2c1376aa139e88f1405eed12ba6093e 100644 (file)
@@ -1596,8 +1596,8 @@ static void bevel_extend_edge_data(BevVert *bv)
                                start = bcur;                   /* set start to first boundvert with seam_len > 0 */
 
                        /* Now for all the mesh_verts starting at current index and ending at idxlen
-                        We go through outermost ring and through all its segments and add seams
-                        for those edges */
+                        * We go through outermost ring and through all its segments and add seams
+                        * for those edges */
                        int idxlen = bcur->index + bcur->seam_len;
                        for (int i = bcur->index; i < idxlen; i++) {
                                BMVert *v1 = mesh_vert(vm, i % vm->count, 0, 0)->v, *v2;
@@ -2345,7 +2345,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 31d0dde567b14840cee6396d8d1361e0c1922ed4..0f9d439a4545a8b6cb8805b8a12e6399588b0700 100644 (file)
@@ -65,9 +65,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 d3370172f6072798975937583402caa908728247..a2c367e50760d434d1b4caffbffb6d8bee450853 100644 (file)
@@ -111,7 +111,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;
@@ -519,32 +519,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 ced6e967acf616e6c53d3849bcf1078cc17ff5b3..eea51d1560f9687f5af811c689502b977b01e7d9 100644 (file)
@@ -695,8 +695,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 26674445d98f6f2d000feed563ebfe44951ef158..caa739006322d6a85a61567b2993f1c48ff4d472 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 868248003786dedf608dfe9a4748c043e06962fc..3ebe23e120b5f1f01a99fd9bd304ac6fcf2d8e4f 100644 (file)
@@ -377,8 +377,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) {
@@ -399,17 +399,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];
@@ -488,11 +488,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;
@@ -690,8 +690,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;
@@ -717,10 +717,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)
@@ -738,19 +738,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;
@@ -774,13 +774,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);
@@ -795,8 +795,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]);
@@ -805,8 +805,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)
@@ -819,11 +819,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];
@@ -877,8 +877,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++)
@@ -908,7 +908,7 @@ void bc_copy_farray_m4(float *r, float a[4][4])
 
 }
 
-/*
+/**
  * Returns name of Active UV Layer or empty String if no active UV Layer defined
  */
 std::string bc_get_active_uvlayer_name(Mesh *me)
@@ -923,17 +923,17 @@ std::string bc_get_active_uvlayer_name(Mesh *me)
        return "";
 }
 
-/*
-* Returns name of Active UV Layer or empty String if no active UV Layer defined.
-* Assuming the Object is of type MESH
-*/
+/**
+ * Returns name of Active UV Layer or empty String if no active UV Layer defined.
+ * Assuming the Object is of type MESH
+ */
 std::string bc_get_active_uvlayer_name(Object *ob)
 {
        Mesh *me = (Mesh *)ob->data;
        return bc_get_active_uvlayer_name(me);
 }
 
-/*
+/**
  * Returns UV Layer name or empty string if layer index is out of range
  */
 std::string bc_get_uvlayer_name(Mesh *me, int layer)
index 89a5379d3c79d72aca51e48aa1cf09bb2d2b7790..001a2f5fe1bf944a98ef9c5a032c827a3672604f 100644 (file)
@@ -184,16 +184,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 4fb6b70ad1b897801e7f59b54ca9eea021a0ad6c..320646be50d0ff66116b79de5b8bdcc171f6bffc 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 b4c5f37b97e15c51be1a427fac359a0418751150..51ea286d21883760b82604f5d255e4722a28d6de 100644 (file)
@@ -1997,10 +1997,10 @@ void DepsgraphRelationBuilder::build_object_data_geometry_datablock(ID *obdata)
                        bGPdata *gpd = (bGPdata *)obdata;
 
                        /* Geometry cache needs to be recalculated on frame change
-                       * (e.g. to fix crashes after scrubbing the timeline when
-                        onion skinning is enabled, since the ghosts need to be
-                        re-added to the cache once scrubbing ends)
-                       */
+                        * (e.g. to fix crashes after scrubbing the timeline when
+                        * onion skinning is enabled, since the ghosts need to be
+                        * re-added to the cache once scrubbing ends)
+                        */
                        TimeSourceKey time_key;
                        ComponentKey geometry_key(obdata, DEG_NODE_TYPE_GEOMETRY);
                        add_relation(time_key,
index 9ed50fafc3d095299321c8533c9818eee8953ea9..5b2436279f09448e480481c5f4b4d37ad9b2eeb8 100644 (file)
@@ -777,7 +777,7 @@ static void deg_restore_object_runtime(
                        /* Evaluated mesh simply copied edit_btmesh pointer from
                         * original mesh during update, need to make sure no dead
                         * pointers are left behind.
-                       */
+                        */
                        mesh_eval->edit_btmesh = mesh_orig->edit_btmesh;
                }
        }
index edb8f4433c9a97d182b68955cd68789ef2944c0e..8e6f2791e72abf676883037fb13a3bc616022aea 100644 (file)
@@ -358,9 +358,9 @@ GPUBatch *DRW_gpencil_get_buffer_fill_geom(bGPdata *gpd)
        float (*points2d)[2] = MEM_mallocN(sizeof(*points2d) * totpoints, __func__);
 
        /* Convert points to array and triangulate
-       * Here a cache is not used because while drawing the information changes all the time, so the cache
-       * would be recalculated constantly, so it is better to do direct calculation for each function call
-       */
+        * Here a cache is not used because while drawing the information changes all the time, so the cache
+        * would be recalculated constantly, so it is better to do direct calculation for each function call
+        */
        for (int i = 0; i < totpoints; i++) {
                const tGPspoint *pt = &points[i];
                points2d[i][0] = pt->x;
@@ -460,10 +460,10 @@ GPUBatch *DRW_gpencil_get_edit_geom(bGPDstroke *gps, float alpha, short dflag)
        }
 
        /* Get size of verts:
-       * - The selected state needs to be larger than the unselected state so that
-       *   they stand out more.
-       * - We use the theme setting for size of the unselected verts
-       */
+        * - The selected state needs to be larger than the unselected state so that
+        *   they stand out more.
+        * - We use the theme setting for size of the unselected verts
+        */
        float bsize = UI_GetThemeValuef(TH_GP_VERTEX_SIZE);
        float vsize;
        if ((int)bsize > 8) {
index f1d3ad37e671e75491e906c29d7be765d91ae427..3963f9d45b9da33acb22c07504655e4129ea5352 100644 (file)
@@ -928,8 +928,8 @@ void DRW_gpencil_populate_buffer_strokes(GPENCIL_e_data *e_data, void *vedata, T
        if (ED_gpencil_session_active() && (gpd->runtime.sbuffer_size > 0)) {
                if ((gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0) {
                        /* It should also be noted that sbuffer contains temporary point types
-                       * i.e. tGPspoints NOT bGPDspoints
-                       */
+                        * i.e. tGPspoints NOT bGPDspoints
+                        */
                        short lthick = brush->size * obscale;
                        /* if only one point, don't need to draw buffer because the user has no time to see it */
                        if (gpd->runtime.sbuffer_size > 1) {
@@ -1294,8 +1294,8 @@ void DRW_gpencil_populate_datablock(
                if (!ID_IS_LINKED(&gpd->id)) {
                        ID *orig_id = gpd->id.orig_id;
                        /* GPXX: Now only a datablock with one use is allowed to be compatible
-                       * with instances
-                       */
+                        * with instances
+                        */
                        if ((!cache_ob->is_dup_onion) && (gpd->flag & GP_DATA_SHOW_ONIONSKINS) &&
                            (do_onion) && (gpl->onion_flag & GP_LAYER_ONIONSKIN) &&
                            ((!playing) || (gpd->onion_flag & GP_ONION_GHOST_ALWAYS)) &&
index 2e237ac7fe8796c71124d73f2b9ba3bf74c289ad..5dd1cb50405b818de21239f5db345f297bf24c6b 100644 (file)
@@ -353,9 +353,9 @@ void GPENCIL_cache_init(void *vedata)
 
                if (obact_gpd) {
                        /* for some reason, when press play there is a delay in the animation flag check
-                       * and this produces errors. To be sure, we set cache as dirty because the frame
-                       * is changing.
-                       */
+                        * and this produces errors. To be sure, we set cache as dirty because the frame
+                        * is changing.
+                        */
                        if (stl->storage->is_playing == true) {
                                obact_gpd->flag |= GP_DATA_CACHE_IS_DIRTY;
                        }
index 3aa94c346df679bf312f042d0d7ffd9281e00568..41f0c601a13b5f03da0eb294e70021c63344510d 100644 (file)
@@ -40,9 +40,9 @@
 #include "gpencil_engine.h"
 
 /* Get pixel size for render
-* This function uses the same calculation used for viewport, because if use
-* camera pixelsize, the result is not correct.
-*/
+ * This function uses the same calculation used for viewport, because if use
+ * camera pixelsize, the result is not correct.
+ */
 static float get_render_pixelsize(float persmat[4][4], int winx, int winy)
 {
        float v1[3], v2[3];
@@ -74,9 +74,9 @@ void GPENCIL_render_init(GPENCIL_Data *ved, RenderEngine *engine, struct Depsgra
        const int size[2] = { (int)viewport_size[0], (int)viewport_size[1] };
 
        /* In render mode the default framebuffer is not generated
-       * because there is no viewport. So we need to manually create one
-       * NOTE : use 32 bit format for precision in render mode.
-       */
+        * because there is no viewport. So we need to manually create one
+        * NOTE : use 32 bit format for precision in render mode.
+        */
        /* create multiframe framebuffer for AA */
        if (U.gpencil_multisamples > 0) {
                int rect_w = (int)viewport_size[0];
@@ -156,7 +156,7 @@ static void GPENCIL_render_update_viewvecs(float invproj[4][4], float winmat[4][
        for (int i = 0; i < 4; i++) {
                mul_project_m4_v3(invproj, view_vecs[i]);
                /* normalized trick see:
-               * http://www.derschmale.com/2014/01/26/reconstructing-positions-from-the-depth-buffer */
+                * http://www.derschmale.com/2014/01/26/reconstructing-positions-from-the-depth-buffer */
                if (is_persp) {
                        /* Divide XY by Z. */
                        mul_v2_fl(view_vecs[i], 1.0f / view_vecs[i][2]);
@@ -164,14 +164,14 @@ static void GPENCIL_render_update_viewvecs(float invproj[4][4], float winmat[4][
        }
 
        /**
-       * If ortho : view_vecs[0] is the near-bottom-left corner of the frustum and
-       *            view_vecs[1] is the vector going from the near-bottom-left corner to
-       *            the far-top-right corner.
-       * If Persp : view_vecs[0].xy and view_vecs[1].xy are respectively the bottom-left corner
-       *            when Z = 1, and top-left corner if Z = 1.
-       *            view_vecs[0].z the near clip distance and view_vecs[1].z is the (signed)
-       *            distance from the near plane to the far clip plane.
-       **/
+        * If ortho : view_vecs[0] is the near-bottom-left corner of the frustum and
+        *            view_vecs[1] is the vector going from the near-bottom-left corner to
+        *            the far-top-right corner.
+        * If Persp : view_vecs[0].xy and view_vecs[1].xy are respectively the bottom-left corner
+        *            when Z = 1, and top-left corner if Z = 1.
+        *            view_vecs[0].z the near clip distance and view_vecs[1].z is the (signed)
+        *            distance from the near plane to the far clip plane.
+        */
        copy_v4_v4(r_viewvecs[0], view_vecs[0]);
 
        /* we need to store the differences */
index c3bf241baf50afb1100addfee0ab3ac322f16924..7d6a8691b877af5e54f8fc9f0324e0cb8377c9fb 100644 (file)
@@ -76,11 +76,12 @@ static bool effect_is_active(bGPdata *gpd, ShaderFxData *fx, bool is_render)
        return false;
 }
 
-/* get normal of draw using one stroke of visible layer
-* /param gpd        GP datablock
-* /param r_point    Point on plane
-* /param r_normal   Normal vector
-*/
+/**
+ * Get normal of draw using one stroke of visible layer
+ * \param gpd        GP datablock
+ * \param r_point    Point on plane
+ * \param r_normal   Normal vector
+ */
 static bool get_normal_vector(bGPdata *gpd, float r_point[3], float r_normal[3])
 {
        for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
@@ -123,9 +124,9 @@ static void GPENCIL_dof_nearfar(Object *camera, float coc, float nearfar[2])
        float focal_len = cam->lens;
 
        /* this is factor that converts to the scene scale. focal length and sensor are expressed in mm
-       * unit.scale_length is how many meters per blender unit we have. We want to convert to blender units though
-       * because the shader reads coordinates in world space, which is in blender units.
-       * Note however that focus_distance is already in blender units and shall not be scaled here (see T48157). */
+        * unit.scale_length is how many meters per blender unit we have. We want to convert to blender units though
+        * because the shader reads coordinates in world space, which is in blender units.
+        * Note however that focus_distance is already in blender units and shall not be scaled here (see T48157). */
        float scale = (scene->unit.system) ? scene->unit.scale_length : 1.0f;
        float scale_camera = 0.001f / scale;
        /* we want radius here for the aperture number  */
@@ -308,8 +309,8 @@ static void DRW_gpencil_fx_light(
        copy_v3_v3(fxd->loc, &fxd->object->loc[0]);
 
        /* Calc distance to strokes plane
-       * The w component of location is used to transfer the distance to drawing plane
-       */
+        * The w component of location is used to transfer the distance to drawing plane
+        */
        float r_point[3], r_normal[3];
        float r_plane[4];
        bGPdata *gpd = cache->gpd;
index f5f98aef3e7d97ab5bf14911b217426bea5da717..cd64c080e7867a372116de393d13b4b0f0a88770 100644 (file)
@@ -1670,7 +1670,7 @@ void DRW_render_gpencil(struct RenderEngine *engine, struct Depsgraph *depsgraph
        /* This function is only valid for Cycles
         * Eevee done all work in the Eevee render directly.
         * Maybe it can be done equal for both engines?
-       */
+        */
        if (STREQ(engine->type->name, "Eevee")) {
                return;
        }
@@ -2371,8 +2371,8 @@ bool DRW_state_is_scene_render(void)
 }
 
 /**
-* Whether we are rendering simple opengl render
-*/
+ * Whether we are rendering simple opengl render
+ */
 bool DRW_state_is_opengl_render(void)
 {
        return DST.options.is_image_render && !DST.options.is_scene_render;
index 20539295fd2997ef01f5be606686716aac4cbe69..9e27ed7bd17cb7809956613692208a90dfee98ca 100644 (file)
@@ -154,7 +154,7 @@ static void EDIT_METABALL_cache_populate(void *vedata, Object *ob)
                                float scamat[3][3];
                                copy_m3_m4(scamat, ob->obmat);
                                /* Get the normalized inverse matrix to extract only
-                               * the scale of Scamat */
+                                * the scale of Scamat */
                                float iscamat[3][3];
                                invert_m3_m3(iscamat, scamat);
                                normalize_m3(iscamat);
index e00e6dbdd0ad53ce934ba7689ffd1bef5cc496d3..18e270e189c4f70b218ba7b07b4fe4bf1a7c7cdb 100644 (file)
@@ -1384,7 +1384,7 @@ static void DRW_shgroup_mball_handles(OBJECT_ShadingGroupList *sgl, Object *ob,
                float scamat[3][3];
                copy_m3_m4(scamat, ob->obmat);
                /* Get the normalized inverse matrix to extract only
-               * the scale of Scamat */
+                * the scale of Scamat */
                float iscamat[3][3];
                invert_m3_m3(iscamat, scamat);
                normalize_m3(iscamat);
index fe57909be75e73631e5ee25cad2740480310a2b8..43ee1133ea0e37447234c272ad9d7b71d8b91ac5 100644 (file)
@@ -287,8 +287,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.
@@ -370,7 +370,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)
 {
@@ -477,7 +477,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 b98feac23845bc5e253bff624267e5935b7cb2d6..cff57e39fa04c628b6f17fd36f7cc05ddd38cfcf 100644 (file)
@@ -974,18 +974,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 e0155a8c435a91ba24179cd9d74d80a5dc02ccc7..1ab5d3dda1ffa48f759caa002878d8559de74e49 100644 (file)
@@ -785,8 +785,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 b74b515b37fa0b1495771117ca41b61db3a54011..89e510e6f3e95d538adc63332cf66063283f194d 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 62f0f107360c41b8426c10fbdec0ad51a3118d7f..8acac47706f90e6e959f410eb3c8609451cb86db 100644 (file)
@@ -904,8 +904,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 dfc0dcd791c36aa76fd39895c83b6110fc1ff1fb..7459d1beeff868a01d943f9fe40b91e61f715af0 100644 (file)
@@ -196,7 +196,7 @@ static void button2d_draw_intern(
                        if (is_3d) {
                                const float fac = 2.0f;
                                GPU_matrix_translate_2f(-(fac / 2), -(fac / 2));
-                               GPU_matrix_scale_2f(fac / (ICON_DEFAULT_WIDTH *  UI_DPI_FAC), fac / (ICON_DEFAULT_HEIGHT * UI_DPI_FAC));
+                               GPU_matrix_scale_2f(fac / (ICON_DEFAULT_WIDTH * UI_DPI_FAC), fac / (ICON_DEFAULT_HEIGHT * UI_DPI_FAC));
                                size[0] = 1.0f;
                                size[1] = 1.0f;
                        }
index 4f25dc421e4b174d791dba143604026ef084b8e9..75b232e14454e77bd4f5bfc8f64d7ac371b9256a 100644 (file)
@@ -1750,10 +1750,10 @@ static void gpencil_draw_apply_event(wmOperator *op, const wmEvent *event, Depsg
                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)) {
@@ -1778,7 +1778,7 @@ static void gpencil_draw_apply_event(wmOperator *op, const wmEvent *event, Depsg
                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 180fb65e74341caadd1a01d14a108b6c0ed0ae7f..f7ea15a9eaf8bfde8ce6e5fd9d6eac39864915b9 100644 (file)
@@ -1781,7 +1781,7 @@ void ED_gpencil_draw_view3d_object(wmWindowManager *wm, Scene *scene, Depsgraph
        if (gpd == NULL) return;
 
        /* when rendering to the offscreen buffer we don't want to
-       * deal with the camera border, otherwise map the coords to the camera border. */
+        * deal with the camera border, otherwise map the coords to the camera border. */
        if ((rv3d->persp == RV3D_CAMOB) && !(G.f & G_RENDER_OGL)) {
                rctf rectf;
                ED_view3d_calc_camera_border(scene, depsgraph, ar, v3d, rv3d, &rectf, true); /* no shift */
@@ -1801,9 +1801,9 @@ void ED_gpencil_draw_view3d_object(wmWindowManager *wm, Scene *scene, Depsgraph
        /* set flags */
        if (only3d) {
                /* 3D strokes/3D space:
-               * - only 3D space points
-               * - don't status text either (as it's the wrong space)
-               */
+                * - only 3D space points
+                * - don't status text either (as it's the wrong space)
+                */
                dflag |= (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_NOSTATUS);
        }
 
@@ -1814,8 +1814,8 @@ void ED_gpencil_draw_view3d_object(wmWindowManager *wm, Scene *scene, Depsgraph
 
        if ((wm == NULL) || ED_screen_animation_playing(wm)) {
                /* don't show onionskins during animation playback/scrub (i.e. it obscures the poses)
-               * OpenGL Renders (i.e. final output), or depth buffer (i.e. not real strokes)
-               */
+                * OpenGL Renders (i.e. final output), or depth buffer (i.e. not real strokes)
+                */
                dflag |= GP_DRAWDATA_NO_ONIONS;
        }
 
index 2c3159692bfba655ef6482e41fd9ce8a9b752e38..f1b501eec1ccf9ca587751de9ef45f506139ecc8 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 3626528414ab1fcf7485652996ed6260ce2f4a71..57e15250ed24e05887f7bf24682fca7041311f5a 100644 (file)
@@ -461,15 +461,15 @@ static void gpencil_object_vgroup_calc_from_armature(
        const int defbase_tot = BLI_listbase_count(&ob->defbase);
        int defbase_add;
        /* Traverse the bone list, trying to create empty vertex
-               * groups corresponding to the bone.
-               */
+        * groups corresponding to the bone.
+        */
        defbase_add = gpencil_bone_looper(
                ob, arm->bonebase.first, NULL,
                vgroup_add_unique_bone_cb);
 
        if (defbase_add) {
                /* its possible there are DWeight's outside the range of the current
-                       * objects deform groups, in this case the new groups wont be empty */
+                * objects deform groups, in this case the new groups wont be empty */
                ED_vgroup_data_clamp_range(ob->data, defbase_tot);
        }
 
index 6eff4d3687f08d514ca151feb3c17929409361e1..6f9e02b4ce44b0d99591ab62fabcadb044635fec 100644 (file)
@@ -885,9 +885,9 @@ static bool gp_brush_weight_apply(
        float inf;
 
        /* Compute strength of effect
-       * - We divide the strength by 10, so that users can set "sane" values.
-       *   Otherwise, good default values are in the range of 0.093
-       */
+        * - We divide the strength by 10, so that users can set "sane" values.
+        *   Otherwise, good default values are in the range of 0.093
+        */
        inf = gp_brush_influence_calc(gso, radius, co) / 10.0f;
 
        /* need a vertex group */
index 818a694a899605246e82dc09d7a186c3fc259483..87ea779b7f7436ac4407ee4870f118f6f145beac 100644 (file)
@@ -1903,8 +1903,8 @@ static int gpencil_vertex_group_smooth_exec(bContext *C, wmOperator *op)
                                float wb = defvert_find_weight(dvertb, def_nr);
 
                                /* the optimal value is the corresponding to the interpolation of the weight
-                                at the distance of point b
-                               */
+                                * at the distance of point b
+                                */
                                const float opfac = line_point_factor_v3(&ptb->x, &pta->x, &ptc->x);
                                const float optimal = interpf(wa, wb, opfac);
                                /* Based on influence factor, blend between original and optimal */
@@ -2339,8 +2339,8 @@ static int gpencil_color_isolate_exec(bContext *C, wmOperator *op)
                        continue;
 
                /* If the flags aren't set, that means that the color is
-               * not alone, so we have some colors to isolate still
-               */
+                * not alone, so we have some colors to isolate still
+                */
                gp_style = ma->gp_style;
                if ((gp_style->flag & flags) == 0) {
                        isolate = true;
index 171c52470c0fbdd028554c4bd57162c2612e2ef3..d4594ee6f7e7a75e172b84fced0d587076d77b0f 100644 (file)
@@ -442,9 +442,9 @@ static bool gp_stroke_edit_poll(bContext *C)
 static bool gp_strokes_edit3d_poll(bContext *C)
 {
        /* 2 Requirements:
-        - 1) Editable GP data
-        - 2) 3D View only
-       */
+        * - 1) Editable GP data
+        * - 2) 3D View only
+        */
        return (gp_stroke_edit_poll(C) && ED_operator_view3d_active(C));
 }
 
index 6aeaa04f2bd924db0f50ec284742182447767e41..4cdc3a53c7ed2679c3d4074aab10778f2c14a238 100644 (file)
@@ -448,8 +448,7 @@ static bool is_leak_narrow(ImBuf *ibuf, const int maxpixel, int limit, int index
 
        /* Vertical leak (check horizontal pixels)
         *
-        *  XXXxB7XX
-        *
+        * XXXxB7XX
         */
        if (type == LEAK_VERT) {
                /* get pixel range of the row */
@@ -515,17 +514,17 @@ static void gpencil_boundaryfill_area(tGPDfill *tgpf)
        }
 
        /* the fill use a stack to save the pixel list instead of the common recursive
-       * 4-contact point method.
-       * The problem with recursive calls is that for big fill areas, we can get max limit
-       * of recursive calls and STACK_OVERFLOW error.
-       *
-       * The 4-contact point analyze the pixels to the left, right, bottom and top
-       *      -----------
-       *      |    X    |
-       *      |   XoX   |
-       *      |    X    |
-       *      -----------
-       */
+        * 4-contact point method.
+        * The problem with recursive calls is that for big fill areas, we can get max limit
+        * of recursive calls and STACK_OVERFLOW error.
+        *
+        * The 4-contact point analyze the pixels to the left, right, bottom and top
+        *      -----------
+        *      |    X    |
+        *      |   XoX   |
+        *      |    X    |
+        *      -----------
+        */
        while (!BLI_stack_is_empty(stack)) {
                int v;
                BLI_stack_pop(stack, &v);
@@ -737,8 +736,8 @@ static void gpencil_get_depth_array(tGPDfill *tgpf)
        }
 
        /* for surface sketching, need to set the right OpenGL context stuff so that
-       * the conversions will project the values correctly...
-       */
+        * the conversions will project the values correctly...
+        */
        if (ts->gpencil_v3d_align & GP_PROJECT_DEPTH_VIEW) {
                /* need to restore the original projection settings before packing up */
                view3d_region_operator_needs_opengl(tgpf->win, tgpf->ar);
index 975b09ed5c8a729cd591392a67a32f4b73c0a796..dce9730334105b2f5abaa689b5c515a52bcf62a3 100644 (file)
@@ -474,15 +474,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)                                          \
 {                                                                                       \
        Depsgraph *depsgraph_ = CTX_data_depsgraph(C);                                      \
index 5c01de5588596fc25b0dea454013d258162bcb1e..1474e948920cf700b4c5096b84903be79096f570 100644 (file)
@@ -178,18 +178,18 @@ static int gpencil_convert_old_files_exec(bContext *C, wmOperator *UNUSED(op))
                        }
                        else if (ob->type == OB_EMPTY) {
                                /* Empty with GP data - This should be able to be converted
-                               * to a GP object with little data loss
-                               */
+                                * to a GP object with little data loss
+                                */
                                ob->data = ob->gpd;
                                ob->gpd = NULL;
                                ob->type = OB_GPENCIL;
                        }
                        else {
                                /* FIXME: What to do in this case?
-                               *
-                               * We cannot create new objects for these, as we don't have a scene & scene layer
-                               * to put them into from here...
-                               */
+                                *
+                                * We cannot create new objects for these, as we don't have a scene & scene layer
+                                * to put them into from here...
+                                */
                                printf("WARNING: Old Grease Pencil data ('%s') still exists on Object '%s'\n",
                                        ob->gpd->id.name + 2, ob->id.name + 2);
                        }
index b14f18714a58d3b4222a3b08c55f122ebd94ff9c..fd6cf1f9681eec474be24eafca86d70a63be47dc 100644 (file)
@@ -217,10 +217,11 @@ static void ed_keymap_gpencil_selection(wmKeyMap *keymap)
        kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select_lasso", EVT_TWEAK_A, KM_ANY, KM_SHIFT | KM_CTRL, 0);
        RNA_boolean_set(kmi->ptr, "deselect", true);
 
-       /* In the Node Editor, lasso select needs ALT modifier too (as somehow CTRL+LMB drag gets taken for "cut" quite early)
-       * There probably isn't too much harm adding this for other editors too as part of standard GP editing keymap. This hotkey
-       * combo doesn't seem to see much use under standard scenarios?
-       */
+       /* In the Node Editor, lasso select needs ALT modifier too
+        * (as somehow CTRL+LMB drag gets taken for "cut" quite early)
+        * There probably isn't too much harm adding this for other editors too as part of standard GP editing keymap.
+        * This hotkey combo doesn't seem to see much use under standard scenarios?
+        */
        kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select_lasso", EVT_TWEAK_A, KM_ANY, KM_CTRL | KM_ALT, 0);
        RNA_boolean_set(kmi->ptr, "deselect", false);
        kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select_lasso", EVT_TWEAK_A, KM_ANY, KM_SHIFT | KM_CTRL | KM_ALT, 0);
@@ -275,11 +276,11 @@ static void ed_keymap_gpencil_sculpt(wmKeyMap *keymap)
        /* Sculpting ------------------------------------- */
 
        /* Brush-Based Editing:
-       *   EKEY + LMB                          = Single stroke, draw immediately
-       *        + Other Modifiers (Ctrl/Shift) = Invert, Smooth, etc.
-       *
-       * For the modal version, use D+E -> Sculpt
-       */
+        *   EKEY + LMB                          = Single stroke, draw immediately
+        *        + Other Modifiers (Ctrl/Shift) = Invert, Smooth, etc.
+        *
+        * For the modal version, use D+E -> Sculpt
+        */
        /* GPXX: disabled to make toolsystem works */
        //kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_brush_paint", LEFTMOUSE, KM_PRESS, 0, 0);
        //RNA_boolean_set(kmi->ptr, "wait_for_input", false);
@@ -312,11 +313,11 @@ static void ed_keymap_gpencil_weight(wmKeyMap *keymap)
 
 
        /* Brush-Based Editing:
-       *   EKEY + LMB                          = Single stroke, draw immediately
-       *        + Other Modifiers (Ctrl/Shift) = Invert, Smooth, etc.
-       *
-       * For the modal version, use D+E -> Sculpt
-       */
+        *   EKEY + LMB                          = Single stroke, draw immediately
+        *        + Other Modifiers (Ctrl/Shift) = Invert, Smooth, etc.
+        *
+        * For the modal version, use D+E -> Sculpt
+        */
        /* GPXX: disabled to make toolsystem works */
        //kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_brush_paint", LEFTMOUSE, KM_PRESS, 0, 0);
        //RNA_boolean_set(kmi->ptr, "wait_for_input", false);
@@ -494,8 +495,8 @@ static void ed_keymap_gpencil_painting_draw(wmKeyConfig *keyconf)
 
        /* Tablet Mappings for Drawing ------------------ */
        /* For now, only support direct drawing using the eraser, as most users using a tablet
-       * may still want to use that as their primary pointing device!
-       */
+        * may still want to use that as their primary pointing device!
+        */
 #if 0
        kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_draw", TABLET_STYLUS, KM_PRESS, 0, 0);
        RNA_enum_set(kmi->ptr, "mode", GP_PAINTMODE_DRAW);
index 807fa94fa8a45c45b18575428a058a08f54a1305..c1fc47d74fc466b8b3678802d34f8d4e62d73ae8 100644 (file)
@@ -314,20 +314,20 @@ static bool gp_stroke_filtermval(tGPsdata *p, const int mval[2], int pmval[2])
                }
                else {
                        /* If the mouse is moving within the radius of the last move,
-                       * don't update the mouse position. This allows sharp turns. */
+                        * don't update the mouse position. This allows sharp turns. */
                        copy_v2_v2_int(p->mval, p->mvalo);
                        return false;
                }
        }
        /* check if mouse moved at least certain distance on both axes (best case)
-        *      - aims to eliminate some jitter-noise from input when trying to draw straight lines freehand
+        * - aims to eliminate some jitter-noise from input when trying to draw straight lines freehand
         */
        else if ((dx > MIN_MANHATTEN_PX) && (dy > MIN_MANHATTEN_PX))
                return true;
 
        /* check if the distance since the last point is significant enough
-        *      - prevents points being added too densely
-        *      - distance here doesn't use sqrt to prevent slowness... we should still be safe from overflows though
+        * - prevents points being added too densely
+        * - distance here doesn't use sqrt to prevent slowness... we should still be safe from overflows though
         */
        else if ((dx * dx + dy * dy) > MIN_EUCLIDEAN_PX * MIN_EUCLIDEAN_PX)
                return true;
@@ -372,9 +372,9 @@ static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3]
        if (gpd->runtime.sbuffer_sflag & GP_STROKE_3DSPACE) {
 
                /* add small offset to keep stroke over the surface.
-               * This could be a UI parameter, but the value is too sensitive for
-               * the user to use it and don't improve the result.
-               */
+                * This could be a UI parameter, but the value is too sensitive for
+                * the user to use it and don't improve the result.
+                */
                if (depth) {
                        *depth *= 0.99998f;
                }
@@ -500,14 +500,14 @@ static void gp_brush_angle(bGPdata *gpd, Brush *brush, tGPspoint *pt, const int
 }
 
 /* Apply smooth to buffer while drawing
-* to smooth point C, use 2 before (A, B) and current point (D):
-*
-*   A----B-----C------D
-*
-* \param p         Temp data
-* \param inf    Influence factor
-* \param idx   Index of the last point (need minimum 3 points in the array)
-*/
+ * to smooth point C, use 2 before (A, B) and current point (D):
+ *
+ *   A----B-----C------D
+ *
+ * \param p        Temp data
+ * \param inf    Influence factor
+ * \param idx  Index of the last point (need minimum 3 points in the array)
+ */
 static void gp_smooth_buffer(tGPsdata *p, float inf, int idx)
 {
        bGPdata *gpd = p->gpd;
@@ -1656,10 +1656,9 @@ static void gp_init_drawing_brush(bContext *C, tGPsdata *p)
        p->radius = (short)p->eraser->size;
 
        /* GPXX: Need this update to synchronize brush with draw manager.
-       * Maybe this update can be removed when the new tool system
-       * will be in place, but while, we need this to keep drawing working.
-       *
-       */
+        * Maybe this update can be removed when the new tool system
+        * will be in place, but while, we need this to keep drawing working.
+        */
        DEG_id_tag_update(&scene->id, DEG_TAG_COPY_ON_WRITE);
 }
 
@@ -2495,10 +2494,10 @@ static void gpencil_draw_apply_event(bContext *C, wmOperator *op, const wmEvent
                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)) {
@@ -2539,7 +2538,7 @@ static void gpencil_draw_apply_event(bContext *C, wmOperator *op, const wmEvent
                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 401a4e2a5507099dcec7be6760ab43033f8fcc6c..a1c433535cfc6b4568391737fbd65a04f733ece9 100644 (file)
@@ -886,7 +886,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 06747798ec7a0c73d1d0b7656c7cb05c1d6a8fcf..1db4777ad98a16b21a2836e31ff732db712c20d1 100644 (file)
@@ -777,8 +777,8 @@ void gp_stroke_convertcoords_tpoint(
 
        if ((depth != NULL) && (ED_view3d_autodist_simple(ar, mval, r_out, 0, depth))) {
                /* projecting onto 3D-Geometry
-               *       - nothing more needs to be done here, since view_autodist_simple() has already done it
-               */
+                * - nothing more needs to be done here, since view_autodist_simple() has already done it
+                */
        }
        else {
                float mval_f[2] = {(float)point2D->x, (float)point2D->y};
@@ -849,8 +849,8 @@ void ED_gp_project_stroke_to_plane(Object *ob, RegionView3D *rv3d, bGPDstroke *g
        zero_v3(plane_normal);
        if (axis < 0) {
                /* if the axis is not locked, need a vector to the view direction
-               * in order to get the right size of the stroke.
-               */
+                * in order to get the right size of the stroke.
+                */
                ED_view3d_global_to_vector(rv3d, origin, plane_normal);
        }
        else {
@@ -1370,10 +1370,11 @@ void ED_gpencil_brush_draw_eraser(Brush *brush, int x, int y)
        immUniform1f("dash_width", 12.0f);
        immUniform1f("dash_factor", 0.5f);
 
-       imm_draw_circle_wire_2d(shdr_pos, x, y, radius,
-               /* XXX Dashed shader gives bad results with sets of small segments currently,
-               *     temp hack around the issue. :( */
-               max_ii(8, radius / 2));  /* was fixed 40 */
+       imm_draw_circle_wire_2d(
+               shdr_pos, x, y, radius,
+               /* XXX Dashed shader gives bad results with sets of small segments currently,
+                *     temp hack around the issue. :( */
+               max_ii(8, radius / 2));  /* was fixed 40 */
 
        immUnbindProgram();
 
index b0807c8e5ae66390976aaaa9e608a79c1f57e8f8..08a039841f8f9271b2984ee665669f029b1ec8b6 100644 (file)
@@ -329,11 +329,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 6a304a8150e764dd3284d36e8c26ab5eb9a24726..715980953a599570ee1f9b9fdbc5ed7c5295ed48 100644 (file)
@@ -2053,7 +2053,9 @@ void ui_draw_but_NODESOCKET(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol
 
 static void ui_shadowbox(unsigned pos, unsigned color, float minx, float miny, float maxx, float maxy, float shadsize, unsigned char alpha)
 {
-       /*          v1-_
+       /**
+        * <pre>
+        *          v1-_
         *          |   -_v2
         *          |     |
         *          |     |
@@ -2062,6 +2064,7 @@ static void ui_shadowbox(unsigned pos, unsigned color, float minx, float miny, f
         * \        |     /
         *  \       |   _v5
         *  v8______v6_-
+        * </pre>
         */
        const float v1[2] = {maxx,                   maxy - 0.3f * shadsize};
        const float v2[2] = {maxx + shadsize,        maxy - 0.75f * shadsize};
index 27805f2cf1eacddcb7f104b8608ff7c5bd89a3af..0b7dd753ae19d08808fa77babdcabf33db4c71d9 100644 (file)
@@ -2006,11 +2006,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 3a5277123678b119e126a7ec4a22cff2d8c328cd..4ad3a54febafa9e4a94341ac8c4fca47f1185321 100644 (file)
@@ -216,8 +216,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:
                {
@@ -227,9 +227,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;
@@ -261,7 +261,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 */
@@ -634,7 +634,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;
@@ -678,7 +678,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 771deca69b607ba1ad9075fdffc03aad958859c4..21f406c7657dd8b91f752de01c0c4643143e8fcf 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 23011f835c1babbc5f8288faca25e8559f6bbdea..794111fd6aef9adc60514cfe0fec66be2bed5eb2 100644 (file)
@@ -1037,7 +1037,7 @@ static int edbm_rip_invoke(bContext *C, wmOperator *op, const wmEvent *event)
                /* running in face mode hardly makes sense, so convert to region loop and rip */
                if (bm->totfacesel) {
                        /* highly nifty but hard to support since the operator can fail and we're left
-                       * with modified selection */
+                        * with modified selection */
                        // WM_operator_name_call(C, "MESH_OT_region_to_loop", WM_OP_INVOKE_DEFAULT, NULL);
                        continue;
                }
@@ -1050,14 +1050,14 @@ static int edbm_rip_invoke(bContext *C, wmOperator *op, const wmEvent *event)
                error_disconected_vertices = false;
 
                /* note on selection:
-               * When calling edge split we operate on tagged edges rather then selected
-               * this is important because the edges to operate on are extended by one,
-               * but the selection is left alone.
-               *
-               * After calling edge split - the duplicated edges have the same selection state as the
-               * original, so all we do is de-select the far side from the mouse and we have a
-               * useful selection for grabbing.
-               */
+                * When calling edge split we operate on tagged edges rather then selected
+                * this is important because the edges to operate on are extended by one,
+                * but the selection is left alone.
+                *
+                * After calling edge split - the duplicated edges have the same selection state as the
+                * original, so all we do is de-select the far side from the mouse and we have a
+                * useful selection for grabbing.
+                */
 
                /* BM_ELEM_SELECT --> BM_ELEM_TAG */
                BM_ITER_MESH(e, &iter, bm, BM_EDGES_OF_MESH) {
index 33dc252ab14ba974ddbc8d5535157e0c51ebd617..c4a1ee9134d044e759ee1bc9965bcc0f0451bc89 100644 (file)
@@ -99,7 +99,7 @@ static int edbm_rip_edge_invoke(bContext *C, wmOperator *UNUSED(op), const wmEve
                /* not essential, but gives more expected results with edge selection */
                if (bm->totedgesel) {
                        /* angle against center can give odd result,
-                       * try re-position the center to the closest edge */
+                        * try re-position the center to the closest edge */
                        BMIter eiter;
                        BMEdge *e;
                        float dist_sq_best = len_squared_v2v2(cent_sco, mval_fl);
index 537056cd1baff4f44bb5bd08373894bfc881dcd7..b4033af1523f3cc6ecf4e9b283622cca541e2185 100644 (file)
@@ -357,9 +357,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 8de245fc369a85cbfaa7cc6f815a6a810b17b1da..ef81d0c5a0f61e3f6a1a6d20318f09e338935f17 100644 (file)
@@ -799,10 +799,10 @@ static void child_get_inverse_matrix(const bContext *C, Scene *scene, Object *ob
                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 0b5a94d832ee8493237008734e1b473471fceeb1..84c2b0d33e58347842de4435179312aa76bc5cf0 100644 (file)
@@ -1,31 +1,31 @@
 /*
-* ***** BEGIN GPL LICENSE BLOCK *****
-*
-* This program is free software; you can redistribute it and/or
-* modify it under the terms of the GNU General Public License
-* as published by the Free Software Foundation; either version 2
-* of the License, or (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program; if not, write to the Free Software Foundation,
-* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-*
-* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
-* All rights reserved.
-*
-* Contributor(s): Blender Foundation, 2009
-*
-* ***** END GPL LICENSE BLOCK *****
-*/
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * Contributor(s): Blender Foundation, 2009
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 
 /** \file blender/editors/object/object_modifier.c
-*  \ingroup edobj
-*/
+ *  \ingroup edobj
+ */
 
 
 #include <math.h>
@@ -117,8 +117,8 @@ ModifierData *ED_object_modifier_add(ReportList *reports, Main *bmain, Scene *sc
 
        if (type == eModifierType_ParticleSystem) {
                /* don't need to worry about the new modifier's name, since that is set to the number
-               * of particle systems which shouldn't have too many duplicates
-               */
+                * of particle systems which shouldn't have too many duplicates
+                */
                new_md = object_add_particle_system(bmain, scene, ob, name);
        }
        else {
@@ -182,7 +182,7 @@ ModifierData *ED_object_modifier_add(ReportList *reports, Main *bmain, Scene *sc
 }
 
 /* Return true if the object has a modifier of type 'type' other than
-* the modifier pointed to be 'exclude', otherwise returns false. */
+ * the modifier pointed to be 'exclude', otherwise returns false. */
 static bool object_has_modifier(const Object *ob, const ModifierData *exclude,
        ModifierType type)
 {
@@ -197,13 +197,13 @@ static bool object_has_modifier(const Object *ob, const ModifierData *exclude,
 }
 
 /* If the object data of 'orig_ob' has other users, run 'callback' on
-* each of them.
-*
-* If include_orig is true, the callback will run on 'orig_ob' too.
-*
-* If the callback ever returns true, iteration will stop and the
-* function value will be true. Otherwise the function returns false.
-*/
+ * each of them.
+ *
+ * If include_orig is true, the callback will run on 'orig_ob' too.
+ *
+ * If the callback ever returns true, iteration will stop and the
+ * function value will be true. Otherwise the function returns false.
+ */
 bool ED_object_iter_other(
         Main *bmain, Object *orig_ob, const bool include_orig,
         bool (*callback)(Object *ob, void *callback_data),
@@ -278,8 +278,8 @@ static bool object_modifier_remove(Main *bmain, Object *ob, ModifierData *md,
        bool *r_sort_depsgraph)
 {
        /* It seems on rapid delete it is possible to
-       * get called twice on same modifier, so make
-       * sure it is in list. */
+        * get called twice on same modifier, so make
+        * sure it is in list. */
        if (BLI_findindex(&ob->modifiers, md) == -1) {
                return 0;
        }
@@ -533,15 +533,15 @@ static int modifier_apply_shape(
        }
 
        /*
-       * It should be ridiculously easy to extract the original verts that we want
-       * and form the shape data.  We can probably use the CD KEYINDEX layer (or
-       * whatever I ended up calling it, too tired to check now), though this would
-       * by necessity have to make some potentially ugly assumptions about the order
-       * of the mesh data :-/  you can probably assume in 99% of cases that the first
-       * element of a given index is the original, and any subsequent duplicates are
-       * copies/interpolates, but that's an assumption that would need to be tested
-       * and then predominantly stated in comments in a half dozen headers.
-       */
+        * It should be ridiculously easy to extract the original verts that we want
+        * and form the shape data.  We can probably use the CD KEYINDEX layer (or
+        * whatever I ended up calling it, too tired to check now), though this would
+        * by necessity have to make some potentially ugly assumptions about the order
+        * of the mesh data :-/  you can probably assume in 99% of cases that the first
+        * element of a given index is the original, and any subsequent duplicates are
+        * copies/interpolates, but that's an assumption that would need to be tested
+        * and then predominantly stated in comments in a half dozen headers.
+        */
 
        if (ob->type == OB_MESH) {
                Mesh *mesh_applied;
@@ -564,7 +564,7 @@ static int modifier_apply_shape(
                        key = me->key = BKE_key_add(bmain, (ID *)me);
                        key->type = KEY_RELATIVE;
                        /* if that was the first key block added, then it was the basis.
-                       * Initialize it with the mesh, and add another for the modifier */
+                        * Initialize it with the mesh, and add another for the modifier */
                        kb = BKE_keyblock_add(key, NULL);
                        BKE_keyblock_convert_from_mesh(me, key, kb);
                }
@@ -693,7 +693,7 @@ int ED_object_modifier_apply(
                BKE_report(reports, RPT_INFO, "Applied modifier was not first, result may not be as expected");
 
        /* Get evaluated modifier, so object links pointer to evaluated data,
-       * but still use original object it is applied to the original mesh. */
+        * but still use original object it is applied to the original mesh. */
        Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
        ModifierData *md_eval = (ob_eval) ? modifiers_findByName(ob_eval, md->name) : md;
 
@@ -1748,14 +1748,14 @@ static Object *modifier_skin_armature_create(Depsgraph *depsgraph, Main *bmain,
        edges_visited = BLI_BITMAP_NEW(me->totedge, "edge_visited");
 
        /* note: we use EditBones here, easier to set them up and use
-       * edit-armature functions to convert back to regular bones */
+        * edit-armature functions to convert back to regular bones */
        for (v = 0; v < me->totvert; v++) {
                if (mvert_skin[v].flag & MVERT_SKIN_ROOT) {
                        EditBone *bone = NULL;
 
                        /* Unless the skin root has just one adjacent edge, create
-                       * a fake root bone (have it going off in the Y direction
-                       * (arbitrary) */
+                        * a fake root bone (have it going off in the Y direction
+                        * (arbitrary) */
                        if (emap[v].count > 1) {
                                bone = ED_armature_ebone_add(arm, "Bone");
 
@@ -2088,7 +2088,7 @@ static int oceanbake_breakjob(void *UNUSED(customdata))
        //return *(ob->stop);
 
        /* this is not nice yet, need to make the jobs list template better
-       * for identifying/acting upon various different jobs */
+        * for identifying/acting upon various different jobs */
        /* but for now we'll reuse the render break... */
        return (G.is_break);
 }
@@ -2172,22 +2172,22 @@ static int ocean_bake_exec(bContext *C, wmOperator *op)
        /* precalculate time variable before baking */
        for (f = omd->bakestart; f <= omd->bakeend; f++) {
                /* from physics_fluid.c:
-               *
-               * XXX: This can't be used due to an anim sys optimization that ignores recalc object animation,
-               * leaving it for the depgraph (this ignores object animation such as modifier properties though... :/ )
-               * --> BKE_animsys_evaluate_all_animation(bmain, eval_time);
-               * This doesn't work with drivers:
-               * --> BKE_animsys_evaluate_animdata(&fsDomain->id, fsDomain->adt, eval_time, ADT_RECALC_ALL);
-               */
+                *
+                * XXX: This can't be used due to an anim sys optimization that ignores recalc object animation,
+                * leaving it for the depgraph (this ignores object animation such as modifier properties though... :/ )
+                * --> BKE_animsys_evaluate_all_animation(bmain, eval_time);
+                * This doesn't work with drivers:
+                * --> BKE_animsys_evaluate_animdata(&fsDomain->id, fsDomain->adt, eval_time, ADT_RECALC_ALL);
+                */
 
                /* Modifying the global scene isn't nice, but we can do it in
-               * this part of the process before a threaded job is created */
+                * this part of the process before a threaded job is created */
 
                //scene->r.cfra = f;
                //ED_update_for_newframe(bmain, scene);
 
                /* ok, this doesn't work with drivers, but is way faster.
-               * let's use this for now and hope nobody wants to drive the time value... */
+                * let's use this for now and hope nobody wants to drive the time value... */
                BKE_animsys_evaluate_animdata(CTX_data_depsgraph(C), scene, (ID *)ob, ob->adt, f, ADT_RECALC_ANIM);
 
                och->time[i] = omd->time;
index a293f7a950e5bf0c7be03ef58a8523e5605b1b9d..05726e5be2d62d7bb6a2ac3492837e8a2ccfe94e 100644 (file)
@@ -45,7 +45,7 @@
 
 
 /**
- *  Generic randomize vertices function
+ * Generic randomize vertices function
  */
 
 static bool object_rand_transverts(
index 7f74dd4666a1706876d243e2ad58454d8a32459e..a967450408c673c018a51bf7692eacc0ae99dc7f 100644 (file)
@@ -319,7 +319,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 e20668e417f3372fa2003433695afb9054a862dd..463c15f26966ff67426a8374f98b6f0583b55528 100644 (file)
@@ -325,7 +325,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 51177a77f0dc9be057156c2754d514d25e718d44..eea5510913648d83b7cf9deabdedf0eb766948f5 100644 (file)
@@ -273,7 +273,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 46b53a369e385f65f6d7ef55ad59179692f06eb0..fe1877f62fa42de0cff7a163d08595e6a3c12d8c 100644 (file)
@@ -961,8 +961,8 @@ static void UNUSED_FUNCTION(draw_rotation_guide)(RegionView3D *rv3d)
 /* ******************** info ***************** */
 
 /**
-* Render and camera border
-*/
+ * Render and camera border
+ */
 static void view3d_draw_border(const bContext *C, ARegion *ar)
 {
        Scene *scene = CTX_data_scene(C);
@@ -979,16 +979,16 @@ static void view3d_draw_border(const bContext *C, ARegion *ar)
 }
 
 /**
-* Grease Pencil
-*/
+ * Grease Pencil
+ */
 static void view3d_draw_grease_pencil(const bContext *UNUSED(C))
 {
        /* TODO viewport */
 }
 
 /**
-* Viewport Name
-*/
+ * Viewport Name
+ */
 static const char *view3d_get_name(View3D *v3d, RegionView3D *rv3d)
 {
        const char *name = NULL;
@@ -1182,8 +1182,8 @@ static void draw_selected_name(Scene *scene, Object *ob, rcti *rect)
 /* ******************** view loop ***************** */
 
 /**
-* Information drawn on top of the solid plates and composed data
-*/
+ * Information drawn on top of the solid plates and composed data
+ */
 void view3d_draw_region_info(const bContext *C, ARegion *ar, const int UNUSED(offset))
 {
        RegionView3D *rv3d = ar->regiondata;
index dee65d3a1c9d27ea6822ac997ab6388b9bb669af..8032e6b1dd4aa6501d470d7d4fb7a29ed329feb4 100644 (file)
@@ -2573,7 +2573,7 @@ bool initTransform(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
                                        bool do_skip = false;
 
                                        /* Currently only used for two of three most frequent transform ops, can include more ops.
-                                       * Note that scaling cannot be included here, non-uniform scaling will affect normals. */
+                                        * Note that scaling cannot be included here, non-uniform scaling will affect normals. */
                                        if (ELEM(t->mode, TFM_TRANSLATION, TFM_ROTATION)) {
                                                if (em->bm->totvertsel == em->bm->totvert) {
                                                        /* No need to invalidate if whole mesh is selected. */
index d3b7417c4ddd5a579a7c14e942588dea67530fe4..7e4f22b34aabea8cf8a60d8a0c5d805a7f7202e5 100644 (file)
@@ -5917,7 +5917,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, ViewLayer *view_layer, Object *ob, int tmode)
@@ -6038,8 +6038,8 @@ void autokeyframe_ob_cb_func(bContext *C, Scene *scene, ViewLayer *view_layer, O
 }
 
 /* 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, Object *ob, int tmode, short targetless_ik)
index 422c3489e0160dc4bd5eb4817c5420b9f24019ef..420cfb199f20ae6058bea9855d279cca0764abac 100644 (file)
@@ -1015,9 +1015,9 @@ static int stitch_process_data(
        /* 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 (ssc->mode == STITCH_VERT) {
@@ -1153,9 +1153,9 @@ static int stitch_process_data(
                return 1;
        }
 
-       /*****************************************
-        *  Setup preview for stitchable islands *
-        *****************************************/
+       /****************************************
+        * Setup preview for stitchable islands *
+        ****************************************/
        if (ssc->snap_islands) {
                for (i = 0; i < state->element_map->totalIslands; i++) {
                        if (island_stitch_data[i].addedForPreview) {
@@ -1417,7 +1417,7 @@ static int stitch_process_data(
                                        luv = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MLOOPUV);
 
                                        /* accumulate each islands' translation from stitchable elements. it is important to do here
-                                       * because in final pass MTFaces get modified and result is zero. */
+                                        * because in final pass MTFaces get modified and result is zero. */
                                        island_stitch_data[element->island].translation[0] += final_position[i].uv[0] - luv->uv[0];
                                        island_stitch_data[element->island].translation[1] += final_position[i].uv[1] - luv->uv[1];
                                        island_stitch_data[element->island].medianPoint[0] += luv->uv[0];
index fdbfd20d764d3526ee919bd0bd49d3ca46848169..f460d56e5a5af6321ba863bbfd74205a32712417 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 c1a5b2a6774e97a5b2bbe8eba50c00b7e2f0b880..aa090155537a34aecc749a1e1a4e1f0f9619f5fb 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 16c9699dcef4c8d2c2f790b198cb17586a9a65b6..74fb875ffc6d70f40f2b279aa160795d9d2c0975 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 14109fba84363630c0f6abbfdd709dc9538551c5..30f55ff7e73046e4e2809a9e55fb3ebf74251ccd 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 774cc67f3ab9f86634f43105ef97bddb8d254461..cabb1f81c1a0ad4c4ba6d3f6555e402aff6baf6e 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 a195eac9eecc150755286a94a1ec7f2e78a4744f..27f805c4d31606d93646b10fb0a81db2216691de 100644 (file)
 /** \file GPU_legacy_stubs.h
  *  \ingroup gpu
  *
- *  This is to mark the transition to OpenGL core profile
- *  The idea is to allow Blender 2.8 to be built with OpenGL 3.3 even if it means breaking things
+ * This is to mark the transition to OpenGL core profile
+ * The idea is to allow Blender 2.8 to be built with OpenGL 3.3 even if it means breaking things
  *
- *  This file should be removed in the future
+ * This file should be removed in the future
  */
 
 #ifndef __GPU_LEGACY_STUBS_H__
index 7cb841c421aaab4bf07b07cac77f6a9e12170918..03e45e63132695ebab3303a97e3eede83acf3fbe 100644 (file)
@@ -361,10 +361,10 @@ typedef enum GPUBuiltinShader {
        GPU_NUM_BUILTIN_SHADERS /* (not an actual shader) */
 } GPUBuiltinShader;
 
-/* Keep these in sync with:
- *  gpu_shader_image_interlace_frag.glsl
- *  gpu_shader_image_rect_interlace_frag.glsl
- **/
+/** Keep these in sync with:
+ * - `gpu_shader_image_interlace_frag.glsl`
+ * - `gpu_shader_image_rect_interlace_frag.glsl`
+ */
 typedef enum GPUInterlaceShader {
        GPU_SHADER_INTERLACE_ROW               = 0,
        GPU_SHADER_INTERLACE_COLUMN            = 1,
index fc0c86090691559216e69ece1e984690a1c8bce5..e2af83ec52935de40560ae3c3349aee99e05be35 100644 (file)
@@ -9,6 +9,6 @@ void main()
 {
        fragColor = texture(image, texCoord_interp).r * color.rgba;
        /* Premul by alpha (not texture alpha)
-       * Use blending function GPU_blend_set_func(GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA); */
+        * Use blending function GPU_blend_set_func(GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA); */
        fragColor.rgb *= color.a;
 }
index d0db912f4dcc94f7f324474d6b69165969501a7c..e2f52f547f02b981650fe53057d457be283b6475 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 df9182c2c1e1ce3ea9ee12fed958e9376585ad6c..8e49dba5e337e4806e150216146236c03f505add 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 ba48feb01e8f681f016e432ada8d491d4b74e03b..50690cfa0476026f8cef4e3ec07ef3b9d8f6d09b 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 0d650daa1c993da6b703d7b396c3231d1a7dd65b..f72a924806b977e43332ecee311a204609e0ddde 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 8462b615d2c83c58d1ac60bc8734cb4e593677bd..cdadb1764b81caa95bcd004aad245dea39fb3916 100644 (file)
@@ -315,9 +315,9 @@ typedef struct bGPdata_runtime {
        short bfill_style;          /* buffer style for filling areas (used to select shader type) */
 
        /* Stroke Buffer data (only used during paint-session)
-       *       - buffer must be initialized before use, but freed after
-       *         whole paint operation is over
-       */
+        * - buffer must be initialized before use, but freed after
+        *   whole paint operation is over
+        */
        short sbuffer_size;                     /* number of elements currently in cache */
        short sbuffer_sflag;            /* flags for stroke that cache represents */
        char pad_[6];
index 3538abcff1abb47b8b42b5c11bf5e46b34825f81..721154a62eb115f4e3b652f4de3f13a5c678307b 100644 (file)
@@ -137,8 +137,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 a7f212a06948170e1721c3a1c827911689b03249..22527ea0e31a550903bd16484a590755b34a53a9 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 1429e7ce2385a9941fa187e8c87916b7df5a1524..397c0e966cce011dd79ed03f625637be9ba1efd3 100644 (file)
@@ -113,7 +113,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 */
@@ -367,8 +367,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_... */
@@ -1109,9 +1109,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 97a8a4a5546e6208c8df76ba9ee84b13b85d8484..551805f6a80450ceb14a220684da51f0908c26f0 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 680ed346b5413216a49120000960d4b8e528b5fe..111c187a40789149a32329db1b5f53060f69a4b6 100644 (file)
@@ -1949,16 +1949,16 @@ static void rna_def_brush(BlenderRNA *brna)
 
 }
 
-
-/* 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 884435d70cf1690cba5872fa492bd26af7b70d18..209860e26c6376d0980c1e8a8f30f705b9b26c97 100644 (file)
@@ -128,7 +128,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 6bb93e9e313210da8f0d87e1002ddae4bb4f0714..85bc30665c185e4f46064cfb037fb47cc760cdb0 100644 (file)
@@ -798,7 +798,7 @@ static void rna_def_gpencil_mvert_group(BlenderRNA *brna)
        RNA_def_struct_ui_icon(srna, ICON_GROUP_VERTEX);
 
        /* we can't point to actual group, it is in the object and so
-       * there is no unique group to point to, hence the index */
+        * there is no unique group to point to, hence the index */
        prop = RNA_def_property(srna, "group", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_int_sdna(prop, NULL, "def_nr");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
index 02574b2c38c541c2a002eabc7a4dd3fcdb40990f..966409220322407d423dd52cbd07733df8966010 100644 (file)
@@ -1499,7 +1499,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 69c71d34dbcc37f1523d10b2cc30ac3c9b5d74b8..19b3c2ca745bc4e7cca99df0fe03fc25544b7bc0 100644 (file)
@@ -218,7 +218,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd, Weight
                items_data = MEM_calloc_arrayN((size_t)num_items, sizeof(*items_data), __func__);
 
                /* In this first loop, we assign each WeightedNormalDataAggregateItem
-                to its smooth fan of loops (aka lnor space). */
+                * to its smooth fan of loops (aka lnor space). */
                MPoly *mp;
                int mp_index;
                int item_index;
@@ -484,8 +484,8 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
        Object *ob = ctx->object;
 
        /* XXX TODO ARG GRRR XYQWNMPRXTYY
-       * Once we fully switch to Mesh evaluation of modifiers, we can expect to get that flag from the COW copy.
-       * But for now, it is lost in the DM intermediate step, so we need to directly check orig object's data. */
+        * Once we fully switch to Mesh evaluation of modifiers, we can expect to get that flag from the COW copy.
+        * But for now, it is lost in the DM intermediate step, so we need to directly check orig object's data. */
 #if 0
        if (!(mesh->flag & ME_AUTOSMOOTH)) {
 #else
index 0d897893ff533c13c66b182b726e06ed4cafbb82..b98518fedc0a35ac9efa2e9c974a3ea45321b8e4 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>
+                        */
                }
        }
 
@@ -923,7 +928,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)
 {
@@ -995,7 +1001,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)
 {
@@ -1038,7 +1045,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);
 
@@ -1052,7 +1059,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();
@@ -1548,8 +1555,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 ))
                        {
@@ -1558,7 +1565,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 eaac63893a689d110b860278517d997bc0026bd7..fd91df9c7693b888eddde7c85ec36ef5a0500106 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 d8d6b5c7ce7d339b72f9764706d46682c6bf6deb..327f325f02c0e0080a40a615d476918206a7a872 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 a3de9a3a7fd3576de54b838f83682638e5e88b99..eb28e4d4e1c885bb0285bd0bedc24b70e849ccf5 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 860760d2b10a85fabc530f5463f42173fe911b68..52d44ec5726a91c7fb24094da443b47ee3d64ae6 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]
@@ -2391,7 +2391,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 e24e14058edc78f58b551e19120bcc0e523e8919..3945c82d8de4f66741bbf37017bca831b7b26aaf 100644 (file)
@@ -289,8 +289,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 39364ee27be9ba6469c372eca6cc7f8579cdc365..66e3a77a66a6e65a8142565a37d7744500f781a4 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 dd9e7edf4135a3c0fb922378cf290abf79af1d67..d7df671bce5531aad54b92e9884d5018b52f92aa 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 00506e68bccbcbe4f6eb1f988e10443f1e15967f..8061211c0b005ac20cacb0b46baeb9b348a163e3 100644 (file)
@@ -1493,7 +1493,7 @@ static uiBlock *wm_block_create_splash(bContext *C, ARegion *ar, void *UNUSED(ar
        UI_block_func_set(block, wm_block_splash_refreshmenu, block, NULL);
 
        /* label for 'a' bugfix releases, or 'Release Candidate 1'...
-        *  avoids recreating splash for version updates */
+        * avoids recreating splash for version updates */
        if (STREQ(STRINGIFY(BLENDER_VERSION_CYCLE), "alpha")) {
                version_suffix = "Alpha 2";
        }
index 6a0e488283064ef7cb1e99833b62ea2e5612d6ff..904ac2b89b30e078ff28b70e264fb1313a6e3164 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 914211afd56ec41562259e8e7f697bddd996cbae..3cd3e2986f98e51fd7a28186bf8203b4b34cce4c 100644 (file)
@@ -525,7 +525,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)