ClangFormat: format '#if 0' code in source/
authorCampbell Barton <ideasman42@gmail.com>
Wed, 17 Apr 2019 06:24:14 +0000 (08:24 +0200)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 17 Apr 2019 06:24:14 +0000 (08:24 +0200)
204 files changed:
source/blender/blenkernel/BKE_data_transfer.h
source/blender/blenkernel/BKE_sound.h
source/blender/blenkernel/BKE_undo_system.h
source/blender/blenkernel/intern/armature_update.c
source/blender/blenkernel/intern/cdderivedmesh.c
source/blender/blenkernel/intern/constraint.c
source/blender/blenkernel/intern/dynamicpaint.c
source/blender/blenkernel/intern/fmodifier.c
source/blender/blenkernel/intern/ipo.c
source/blender/blenkernel/intern/library_query.c
source/blender/blenkernel/intern/mask_evaluate.c
source/blender/blenkernel/intern/mask_rasterize.c
source/blender/blenkernel/intern/mesh_evaluate.c
source/blender/blenkernel/intern/pbvh_bmesh.c
source/blender/blenkernel/intern/pointcache.c
source/blender/blenkernel/intern/sequencer.c
source/blender/blenkernel/intern/softbody.c
source/blender/blenkernel/intern/studiolight.c
source/blender/blenkernel/intern/text.c
source/blender/blenlib/BLI_fileops.h
source/blender/blenlib/intern/BLI_mempool.c
source/blender/blenlib/intern/fileops.c
source/blender/blenlib/intern/math_geom.c
source/blender/blenlib/intern/math_interp.c
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/versioning_270.c
source/blender/bmesh/intern/bmesh_log.c
source/blender/bmesh/intern/bmesh_mesh.c
source/blender/bmesh/intern/bmesh_mods.c
source/blender/bmesh/intern/bmesh_operators.c
source/blender/bmesh/intern/bmesh_polygon.c
source/blender/bmesh/intern/bmesh_query.c
source/blender/bmesh/intern/bmesh_walkers_impl.c
source/blender/bmesh/tools/bmesh_beautify.c
source/blender/collada/AnimationImporter.cpp
source/blender/collada/AnimationImporter.h
source/blender/collada/ArmatureExporter.cpp
source/blender/collada/ArmatureExporter.h
source/blender/collada/ArmatureImporter.cpp
source/blender/collada/ArmatureImporter.h
source/blender/collada/BCAnimationSampler.cpp
source/blender/collada/ControllerExporter.cpp
source/blender/collada/ControllerExporter.h
source/blender/collada/DocumentImporter.cpp
source/blender/collada/EffectExporter.cpp
source/blender/collada/collada_utils.cpp
source/blender/collada/collada_utils.h
source/blender/compositor/operations/COM_CompositorOperation.cpp
source/blender/compositor/operations/COM_RenderLayersProg.cpp
source/blender/draw/engines/eevee/eevee_effects.c
source/blender/draw/engines/eevee/eevee_materials.c
source/blender/draw/engines/eevee/eevee_motion_blur.c
source/blender/draw/engines/workbench/workbench_effect_dof.c
source/blender/draw/engines/workbench/workbench_studiolight.c
source/blender/draw/intern/draw_cache.c
source/blender/draw/intern/draw_cache_impl_mesh.c
source/blender/draw/intern/draw_manager_exec.c
source/blender/editors/animation/anim_channels_defines.c
source/blender/editors/animation/anim_deps.c
source/blender/editors/armature/armature_utils.c
source/blender/editors/armature/meshlaplacian.c
source/blender/editors/armature/pose_edit.c
source/blender/editors/armature/pose_lib.c
source/blender/editors/curve/editcurve.c
source/blender/editors/gizmo_library/gizmo_types/cage3d_gizmo.c
source/blender/editors/gpencil/annotate_paint.c
source/blender/editors/gpencil/drawgpencil.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/include/ED_view3d.h
source/blender/editors/include/UI_interface.h
source/blender/editors/interface/interface.c
source/blender/editors/interface/interface_context_menu.c
source/blender/editors/interface/interface_draw.c
source/blender/editors/interface/interface_layout.c
source/blender/editors/interface/interface_templates.c
source/blender/editors/lattice/editlattice_undo.c
source/blender/editors/mesh/editmesh_rip.c
source/blender/editors/mesh/editmesh_select.c
source/blender/editors/mesh/editmesh_utils.c
source/blender/editors/mesh/meshtools.c
source/blender/editors/object/object_data_transfer.c
source/blender/editors/object/object_relations.c
source/blender/editors/physics/particle_edit.c
source/blender/editors/render/render_preview.c
source/blender/editors/screen/area.c
source/blender/editors/screen/screen_ops.c
source/blender/editors/screen/workspace_edit.c
source/blender/editors/sculpt_paint/paint_image.c
source/blender/editors/sculpt_paint/paint_image_proj.c
source/blender/editors/sculpt_paint/paint_image_undo.c
source/blender/editors/sculpt_paint/paint_stroke.c
source/blender/editors/sculpt_paint/paint_vertex.c
source/blender/editors/sculpt_paint/sculpt.c
source/blender/editors/space_action/action_select.c
source/blender/editors/space_console/console_ops.c
source/blender/editors/space_file/filelist.c
source/blender/editors/space_graph/graph_draw.c
source/blender/editors/space_image/image_buttons.c
source/blender/editors/space_image/image_ops.c
source/blender/editors/space_image/space_image.c
source/blender/editors/space_info/info_report.c
source/blender/editors/space_node/drawnode.c
source/blender/editors/space_node/node_edit.c
source/blender/editors/space_outliner/outliner_draw.c
source/blender/editors/space_outliner/outliner_edit.c
source/blender/editors/space_outliner/outliner_tree.c
source/blender/editors/space_sequencer/sequencer_draw.c
source/blender/editors/space_sequencer/sequencer_edit.c
source/blender/editors/space_sequencer/sequencer_select.c
source/blender/editors/space_text/text_draw.c
source/blender/editors/space_text/text_header.c
source/blender/editors/space_view3d/view3d_edit.c
source/blender/editors/space_view3d/view3d_project.c
source/blender/editors/space_view3d/view3d_select.c
source/blender/editors/space_view3d/view3d_view.c
source/blender/editors/transform/transform.c
source/blender/editors/transform/transform_conversions.c
source/blender/editors/transform/transform_orientations.c
source/blender/editors/uvedit/uvedit_ops.c
source/blender/editors/uvedit/uvedit_parametrizer.c
source/blender/freestyle/intern/application/AppCanvas.cpp
source/blender/freestyle/intern/application/Controller.cpp
source/blender/freestyle/intern/application/Controller.h
source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
source/blender/freestyle/intern/blender_interface/BlenderFileLoader.h
source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp
source/blender/freestyle/intern/geometry/GeomCleaner.h
source/blender/freestyle/intern/geometry/Grid.cpp
source/blender/freestyle/intern/geometry/Polygon.h
source/blender/freestyle/intern/geometry/SweepLine.h
source/blender/freestyle/intern/geometry/VecMat.h
source/blender/freestyle/intern/image/ImagePyramid.cpp
source/blender/freestyle/intern/scene_graph/NodeCamera.cpp
source/blender/freestyle/intern/scene_graph/NodeCamera.h
source/blender/freestyle/intern/stroke/Curve.cpp
source/blender/freestyle/intern/stroke/Curve.h
source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h
source/blender/freestyle/intern/stroke/Operators.cpp
source/blender/freestyle/intern/stroke/Stroke.cpp
source/blender/freestyle/intern/stroke/StrokeRep.cpp
source/blender/freestyle/intern/view_map/FEdgeXDetector.cpp
source/blender/freestyle/intern/view_map/FEdgeXDetector.h
source/blender/freestyle/intern/view_map/Silhouette.cpp
source/blender/freestyle/intern/view_map/Silhouette.h
source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.cpp
source/blender/freestyle/intern/view_map/SteerableViewMap.cpp
source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.cpp
source/blender/freestyle/intern/view_map/ViewMap.cpp
source/blender/freestyle/intern/view_map/ViewMap.h
source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h
source/blender/freestyle/intern/view_map/ViewMapBuilder.cpp
source/blender/freestyle/intern/winged_edge/Curvature.cpp
source/blender/freestyle/intern/winged_edge/WEdge.cpp
source/blender/freestyle/intern/winged_edge/WEdge.h
source/blender/freestyle/intern/winged_edge/WXEdge.cpp
source/blender/freestyle/intern/winged_edge/WXEdge.h
source/blender/gpu/GPU_batch.h
source/blender/gpu/intern/gpu_codegen.c
source/blender/gpu/intern/gpu_framebuffer.c
source/blender/gpu/intern/gpu_select_pick.c
source/blender/ikplugin/intern/itasc_plugin.cpp
source/blender/imbuf/intern/allocimbuf.c
source/blender/imbuf/intern/dds/BlockDXT.h
source/blender/imbuf/intern/dds/ColorBlock.cpp
source/blender/imbuf/intern/dds/PixelFormat.h
source/blender/imbuf/intern/filter.c
source/blender/imbuf/intern/jpeg.c
source/blender/imbuf/intern/png.c
source/blender/makesdna/DNA_action_types.h
source/blender/makesdna/DNA_curve_types.h
source/blender/makesdna/DNA_dynamicpaint_types.h
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_boid.c
source/blender/makesrna/intern/rna_wm.c
source/blender/modifiers/intern/MOD_armature.c
source/blender/modifiers/intern/MOD_explode.c
source/blender/modifiers/intern/MOD_particlesystem.c
source/blender/modifiers/intern/MOD_screw.c
source/blender/modifiers/intern/MOD_skin.c
source/blender/modifiers/intern/MOD_solidify.c
source/blender/modifiers/intern/MOD_subsurf.c
source/blender/modifiers/intern/MOD_uvproject.c
source/blender/modifiers/intern/MOD_weightvgmix.c
source/blender/nodes/shader/nodes/node_shader_particle_info.c
source/blender/physics/intern/BPH_mass_spring.cpp
source/blender/physics/intern/ConstrainedConjugateGradient.h
source/blender/physics/intern/hair_volume.cpp
source/blender/python/bmesh/bmesh_py_types.c
source/blender/python/generic/idprop_py_api.c
source/blender/python/gpu/gpu_py_matrix.c
source/blender/python/intern/bpy_capi_utils.c
source/blender/python/intern/bpy_interface.c
source/blender/python/intern/bpy_operator.c
source/blender/python/intern/bpy_props.c
source/blender/python/intern/bpy_rna.c
source/blender/python/intern/bpy_rna_array.c
source/blender/python/intern/bpy_rna_callback.c
source/blender/render/intern/source/multires_bake.c
source/blender/render/intern/source/pipeline.c
source/blender/windowmanager/intern/wm_event_system.c
source/blender/windowmanager/intern/wm_gesture.c
source/blender/windowmanager/intern/wm_gesture_ops.c
source/blender/windowmanager/intern/wm_operators.c
tests/gtests/blenlib/BLI_array_store_test.cc

index a909328..79ef512 100644 (file)
@@ -119,7 +119,7 @@ enum {
   DT_LAYERS_NAME_DST = -2,
   DT_LAYERS_INDEX_DST = -3,
 #if 0 /* TODO */
-  DT_LAYERS_CREATE_DST                 = -4,  /* Never replace existing data in dst, always create new layers. */
+  DT_LAYERS_CREATE_DST = -4, /* Never replace existing data in dst, always create new layers. */
 #endif
 };
 
index 9d917f0..91e23d3 100644 (file)
@@ -61,7 +61,10 @@ struct bSound *BKE_sound_new_file_exists(struct Main *bmain, const char *filepat
 #if 0
 struct bSound *BKE_sound_new_buffer(struct Main *bmain, struct bSound *source);
 
-struct bSound *BKE_sound_new_limiter(struct Main *bmain, struct bSound *source, float start, float end);
+struct bSound *BKE_sound_new_limiter(struct Main *bmain,
+                                     struct bSound *source,
+                                     float start,
+                                     float end);
 #endif
 
 void BKE_sound_cache(struct bSound *sound);
index 6852c3e..fc6fc6f 100644 (file)
@@ -187,7 +187,9 @@ void BKE_undosys_type_free_all(void);
 
 /* ID Accessor */
 #if 0 /* functionality is only used internally for now. */
-void BKE_undosys_foreach_ID_ref(UndoStack *ustack, UndoTypeForEachIDRefFn foreach_ID_ref_fn, void *user_data);
+void BKE_undosys_foreach_ID_ref(UndoStack *ustack,
+                                UndoTypeForEachIDRefFn foreach_ID_ref_fn,
+                                void *user_data);
 #endif
 
 /* Use when the undo step stores many arbitrary pointers. */
index 6d51c7f..917d29a 100644 (file)
@@ -869,8 +869,7 @@ void BKE_pose_eval_proxy_copy_bone(struct Depsgraph *depsgraph, Object *object,
    * around for the time while proxies are evaluating.
    */
 #if 0
-  bPoseChannel *pchan_from = pose_pchan_get_indexed(
-          object->proxy_from, pchan_index);
+  bPoseChannel *pchan_from = pose_pchan_get_indexed(object->proxy_from, pchan_index);
 #else
   bPoseChannel *pchan_from = BKE_pose_channel_find_name(object->proxy_from->pose, pchan->name);
 #endif
index ada746d..debdeda 100644 (file)
@@ -1149,9 +1149,10 @@ void CDDM_calc_normals_mapping(DerivedMesh *dm)
 void CDDM_calc_normals(DerivedMesh *dm)
 {
   CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-  float (*poly_nors)[3];
+  float(*poly_nors)[3];
 
-  if (dm->numVertData == 0) return;
+  if (dm->numVertData == 0)
+    return;
 
   /* we don't want to overwrite any referenced layers */
   cddm->mvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT, dm->numVertData);
@@ -1162,8 +1163,14 @@ void CDDM_calc_normals(DerivedMesh *dm)
     poly_nors = CustomData_add_layer(&dm->polyData, CD_NORMAL, CD_CALLOC, NULL, dm->numPolyData);
   }
 
-  BKE_mesh_calc_normals_poly(cddm->mvert, dm->numVertData, CDDM_get_loops(dm), CDDM_get_polys(dm),
-                                 dm->numLoopData, dm->numPolyData, poly_nors, false);
+  BKE_mesh_calc_normals_poly(cddm->mvert,
+                             dm->numVertData,
+                             CDDM_get_loops(dm),
+                             CDDM_get_polys(dm),
+                             dm->numLoopData,
+                             dm->numPolyData,
+                             poly_nors,
+                             false);
 
   cddm->dm.dirty &= ~DM_DIRTY_NORMALS;
 }
index 114bf5e..01dc7c6 100644 (file)
@@ -665,18 +665,18 @@ static void constraint_target_to_mat4(Object *ob,
  */
 #if 0
 static bConstraintTypeInfo CTI_CONSTRNAME = {
-  CONSTRAINT_TYPE_CONSTRNAME, /* type */
-  sizeof(bConstrNameConstraint), /* size */
-  "ConstrName", /* name */
-  "bConstrNameConstraint", /* struct name */
-  constrname_free, /* free data */
-  constrname_id_looper, /* id looper */
-  constrname_copy, /* copy data */
-  constrname_new_data, /* new data */
-  constrname_get_tars, /* get constraint targets */
-  constrname_flush_tars, /* flush constraint targets */
-  constrname_get_tarmat, /* get target matrix */
-  constrname_evaluate, /* evaluate */
+    CONSTRAINT_TYPE_CONSTRNAME,    /* type */
+    sizeof(bConstrNameConstraint), /* size */
+    "ConstrName",                  /* name */
+    "bConstrNameConstraint",       /* struct name */
+    constrname_free,               /* free data */
+    constrname_id_looper,          /* id looper */
+    constrname_copy,               /* copy data */
+    constrname_new_data,           /* new data */
+    constrname_get_tars,           /* get constraint targets */
+    constrname_flush_tars,         /* flush constraint targets */
+    constrname_get_tarmat,         /* get target matrix */
+    constrname_evaluate,           /* evaluate */
 };
 #endif
 
index 7bbdfa6..2d4f160 100644 (file)
@@ -3064,10 +3064,18 @@ int dynamicPaint_createUVSurface(Scene *scene,
 
             if (tempPoints[index].tri_index != -1) {
               int nidx = tempPoints[index].neighbour_pixel;
-              fprintf(dump_file, "%d\t%d,%d\t%u\t%d,%d\t%d\t", fidx, tx, h-1-ty, tempPoints[index].tri_index, nidx<0?-1:(nidx%w), nidx<0?-1:h-1-(nidx/w), ed->flags[fidx]);
+              fprintf(dump_file,
+                      "%d\t%d,%d\t%u\t%d,%d\t%d\t",
+                      fidx,
+                      tx,
+                      h - 1 - ty,
+                      tempPoints[index].tri_index,
+                      nidx < 0 ? -1 : (nidx % w),
+                      nidx < 0 ? -1 : h - 1 - (nidx / w),
+                      ed->flags[fidx]);
               for (int i = 0; i < ed->n_num[fidx]; i++) {
-                int tgt = tmp[ed->n_target[ed->n_index[fidx]+i]];
-                fprintf(dump_file, "%s%d,%d", i?" ":"", tgt%w, h-1-tgt/w);
+                int tgt = tmp[ed->n_target[ed->n_index[fidx] + i]];
+                fprintf(dump_file, "%s%d,%d", i ? " " : "", tgt % w, h - 1 - tgt / w);
               }
               fprintf(dump_file, "\n");
             }
index d54a3bd..3cecfb8 100644 (file)
@@ -79,21 +79,21 @@ void *fmodifiers_storage_get(FModifierStackStorage *storage, FModifier *fcm);
  */
 #if 0
 static FModifierTypeInfo FMI_MODNAME = {
-  FMODIFIER_TYPE_MODNAME, /* type */
-  sizeof(FMod_ModName), /* size */
-  FMI_TYPE_SOME_ACTION, /* action type */
-  FMI_REQUIRES_SOME_REQUIREMENT, /* requirements */
-  "Modifier Name", /* name */
-  "FMod_ModName", /* struct name */
-  fcm_modname_free, /* free data */
-  fcm_modname_relink, /* relink data */
-  fcm_modname_copy, /* copy data */
-  fcm_modname_new_data, /* new data */
-  fcm_modname_verify, /* verify */
-  fcm_modname_time, /* evaluate time */
-  fcm_modname_evaluate, /* evaluate */
-  fcm_modname_time_storage, /* evaluate time with storage */
-  fcm_modname_evaluate_storage, /* evaluate with storage */
+    FMODIFIER_TYPE_MODNAME,        /* type */
+    sizeof(FMod_ModName),          /* size */
+    FMI_TYPE_SOME_ACTION,          /* action type */
+    FMI_REQUIRES_SOME_REQUIREMENT, /* requirements */
+    "Modifier Name",               /* name */
+    "FMod_ModName",                /* struct name */
+    fcm_modname_free,              /* free data */
+    fcm_modname_relink,            /* relink data */
+    fcm_modname_copy,              /* copy data */
+    fcm_modname_new_data,          /* new data */
+    fcm_modname_verify,            /* verify */
+    fcm_modname_time,              /* evaluate time */
+    fcm_modname_evaluate,          /* evaluate */
+    fcm_modname_time_storage,      /* evaluate time with storage */
+    fcm_modname_evaluate_storage,  /* evaluate with storage */
 };
 #endif
 
index 8f3b1fe..c2c8fb7 100644 (file)
@@ -235,22 +235,28 @@ static const char *ob_adrcodes_to_paths(int adrcode, int *array_index)
       return "color";
 #if 0
     case OB_PD_FSTR:
-      if (ob->pd) poin = &(ob->pd->f_strength);
+      if (ob->pd)
+        poin = &(ob->pd->f_strength);
       break;
     case OB_PD_FFALL:
-      if (ob->pd) poin = &(ob->pd->f_power);
+      if (ob->pd)
+        poin = &(ob->pd->f_power);
       break;
     case OB_PD_SDAMP:
-      if (ob->pd) poin = &(ob->pd->pdef_damp);
+      if (ob->pd)
+        poin = &(ob->pd->pdef_damp);
       break;
     case OB_PD_RDAMP:
-      if (ob->pd) poin = &(ob->pd->pdef_rdamp);
+      if (ob->pd)
+        poin = &(ob->pd->pdef_rdamp);
       break;
     case OB_PD_PERM:
-      if (ob->pd) poin = &(ob->pd->pdef_perm);
+      if (ob->pd)
+        poin = &(ob->pd->pdef_perm);
       break;
     case OB_PD_FMAXD:
-      if (ob->pd) poin = &(ob->pd->maxdist);
+      if (ob->pd)
+        poin = &(ob->pd->maxdist);
       break;
 #endif
   }
@@ -414,31 +420,44 @@ static const char *mtex_adrcodes_to_paths(int adrcode, int *UNUSED(array_index))
   switch (adrcode) {
 #if 0  // XXX these are not wrapped in RNA yet!
     case MAP_OFS_X:
-      poin = &(mtex->ofs[0]); break;
+      poin = &(mtex->ofs[0]);
+      break;
     case MAP_OFS_Y:
-      poin = &(mtex->ofs[1]); break;
+      poin = &(mtex->ofs[1]);
+      break;
     case MAP_OFS_Z:
-      poin = &(mtex->ofs[2]); break;
+      poin = &(mtex->ofs[2]);
+      break;
     case MAP_SIZE_X:
-      poin = &(mtex->size[0]); break;
+      poin = &(mtex->size[0]);
+      break;
     case MAP_SIZE_Y:
-      poin = &(mtex->size[1]); break;
+      poin = &(mtex->size[1]);
+      break;
     case MAP_SIZE_Z:
-      poin = &(mtex->size[2]); break;
+      poin = &(mtex->size[2]);
+      break;
     case MAP_R:
-      poin = &(mtex->r); break;
+      poin = &(mtex->r);
+      break;
     case MAP_G:
-      poin = &(mtex->g); break;
+      poin = &(mtex->g);
+      break;
     case MAP_B:
-      poin = &(mtex->b); break;
+      poin = &(mtex->b);
+      break;
     case MAP_DVAR:
-      poin = &(mtex->def_var); break;
+      poin = &(mtex->def_var);
+      break;
     case MAP_COLF:
-      poin = &(mtex->colfac); break;
+      poin = &(mtex->colfac);
+      break;
     case MAP_NORF:
-      poin = &(mtex->norfac); break;
+      poin = &(mtex->norfac);
+      break;
     case MAP_VARF:
-      poin = &(mtex->varfac); break;
+      poin = &(mtex->varfac);
+      break;
 #endif
     case MAP_DISP:
       prop = "warp_factor";
@@ -659,9 +678,11 @@ static const char *camera_adrcodes_to_paths(int adrcode, int *array_index)
 
 #if 0   // XXX these are not defined in RNA
     case CAM_YF_APERT:
-      poin = &(ca->YF_aperture); break;
+      poin = &(ca->YF_aperture);
+      break;
     case CAM_YF_FDIST:
-      poin = &(ca->dof_distance); break;
+      poin = &(ca->dof_distance);
+      break;
 #endif  // XXX these are not defined in RNA
 
     case CAM_SHIFT_X:
@@ -837,22 +858,28 @@ static const char *particle_adrcodes_to_paths(int adrcode, int *array_index)
      * as the similar object forces */
 #if 0
     case PART_PD_FSTR:
-      if (part->pd) poin = &(part->pd->f_strength);
+      if (part->pd)
+        poin = &(part->pd->f_strength);
       break;
     case PART_PD_FFALL:
-      if (part->pd) poin = &(part->pd->f_power);
+      if (part->pd)
+        poin = &(part->pd->f_power);
       break;
     case PART_PD_FMAXD:
-      if (part->pd) poin = &(part->pd->maxdist);
+      if (part->pd)
+        poin = &(part->pd->maxdist);
       break;
     case PART_PD2_FSTR:
-      if (part->pd2) poin = &(part->pd2->f_strength);
+      if (part->pd2)
+        poin = &(part->pd2->f_strength);
       break;
     case PART_PD2_FFALL:
-      if (part->pd2) poin = &(part->pd2->f_power);
+      if (part->pd2)
+        poin = &(part->pd2->f_power);
       break;
     case PART_PD2_FMAXD:
-      if (part->pd2) poin = &(part->pd2->maxdist);
+      if (part->pd2)
+        poin = &(part->pd2->maxdist);
       break;
 #endif
   }
index 7152c97..a87f8a4 100644 (file)
@@ -1240,10 +1240,16 @@ static int foreach_libblock_id_users_callback(void *user_data,
 
     if (*id_p == iter->id) {
 #if 0
-      printf("%s uses %s (refcounted: %d, userone: %d, used_one: %d, used_one_active: %d, indirect_usage: %d)\n",
-             iter->curr_id->name, iter->id->name, (cb_flag & IDWALK_USER) ? 1 : 0, (cb_flag & IDWALK_USER_ONE) ? 1 : 0,
-             (iter->id->tag & LIB_TAG_EXTRAUSER) ? 1 : 0, (iter->id->tag & LIB_TAG_EXTRAUSER_SET) ? 1 : 0,
-             (cb_flag & IDWALK_INDIRECT_USAGE) ? 1 : 0);
+      printf(
+          "%s uses %s (refcounted: %d, userone: %d, used_one: %d, used_one_active: %d, "
+          "indirect_usage: %d)\n",
+          iter->curr_id->name,
+          iter->id->name,
+          (cb_flag & IDWALK_USER) ? 1 : 0,
+          (cb_flag & IDWALK_USER_ONE) ? 1 : 0,
+          (iter->id->tag & LIB_TAG_EXTRAUSER) ? 1 : 0,
+          (iter->id->tag & LIB_TAG_EXTRAUSER_SET) ? 1 : 0,
+          (cb_flag & IDWALK_INDIRECT_USAGE) ? 1 : 0);
 #endif
       if (cb_flag & IDWALK_CB_INDIRECT_USAGE) {
         iter->count_indirect++;
index 2b84c1f..d3e43a6 100644 (file)
@@ -879,7 +879,8 @@ void BKE_mask_layer_evaluate_animation(MaskLayer *masklay, const float ctime)
              __func__,
              (int)ctime,
              BLI_listbase_count(&masklay->splines_shapes),
-             masklay_shape_a->frame, masklay_shape_b->frame);
+             masklay_shape_a->frame,
+             masklay_shape_b->frame);
 #endif
       BKE_mask_layer_shape_to_mask_interp(
           masklay, masklay_shape_a, masklay_shape_b, (ctime - masklay_shape_a->frame) / w);
index 24137b6..0f5fd89 100644 (file)
@@ -1212,7 +1212,9 @@ void BKE_maskrasterize_handle_init(MaskRasterHandle *mr_handle,
 /* 2D ray test */
 #if 0
 static float maskrasterize_layer_z_depth_tri(const float pt[2],
-                                             const float v1[3], const float v2[3], const float v3[3])
+                                             const float v1[3],
+                                             const float v2[3],
+                                             const float v3[3])
 {
   float w[3];
   barycentric_weights_v2(v1, v2, v3, pt, w);
@@ -1240,10 +1242,7 @@ static float maskrasterize_layer_isect(unsigned int *face,
 
 #if 0
     /* not essential but avoids unneeded extra lookups */
-    if ((cos[0][2] < dist_orig) ||
-        (cos[1][2] < dist_orig) ||
-        (cos[2][2] < dist_orig))
-    {
+    if ((cos[0][2] < dist_orig) || (cos[1][2] < dist_orig) || (cos[2][2] < dist_orig)) {
       if (isect_point_tri_v2_cw(xy, cos[face[0]], cos[face[1]], cos[face[2]])) {
         /* we know all tris are close for now */
         return maskrasterize_layer_z_depth_tri(xy, cos[face[0]], cos[face[1]], cos[face[2]]);
index 2ef1a00..3982339 100644 (file)
@@ -1119,7 +1119,7 @@ static void split_loop_nor_fan_do(LoopSplitTaskDataCommon *common_data, LoopSpli
 
   MLoopNorSpace *lnor_space = data->lnor_space;
 #if 0 /* Not needed for 'fan' loops. */
-  float (*lnor)[3] = data->lnor;
+  float(*lnor)[3] = data->lnor;
 #endif
   const MLoop *ml_curr = data->ml_curr;
   const MLoop *ml_prev = data->ml_prev;
@@ -1537,7 +1537,7 @@ static void loop_split_generator(TaskPool *pool, LoopSplitTaskDataCommon *common
           data->ml_curr_index = ml_curr_index;
 #if 0 /* Not needed for 'single' loop. */
           data->ml_prev_index = ml_prev_index;
-          data->e2l_prev = NULL;  /* Tag as 'single' task. */
+          data->e2l_prev = NULL; /* Tag as 'single' task. */
 #endif
           data->mp_index = mp_index;
           if (lnors_spacearr) {
index c007d5e..40172a4 100644 (file)
@@ -431,7 +431,6 @@ static int pbvh_bmesh_node_offset_from_elem(PBVH *bvh, BMElem *ele)
       BLI_assert(ele->head.htype == BM_FACE);
       return bvh->cd_face_node_offset;
   }
-
 }
 
 static int pbvh_bmesh_node_index_from_elem(PBVH *bvh, void *key)
@@ -543,7 +542,7 @@ static int pbvh_bmesh_node_vert_use_count(PBVH *bvh, PBVHNode *node, BMVert *v)
   BMFace *f;
   int count = 0;
 
-  BM_FACES_OF_VERT_ITER_BEGIN(f, v) {
+  BM_FACES_OF_VERT_ITER_BEGIN (f, v) {
     PBVHNode *f_node = pbvh_bmesh_node_from_face(bvh, f);
     if (f_node == node) {
       count++;
@@ -2105,18 +2104,14 @@ static void pbvh_bmesh_print(PBVH *bvh)
 
   BMIter iter;
   BMFace *f;
-  BM_ITER_MESH(f, &iter, bvh->bm, BM_FACES_OF_MESH) {
-    fprintf(stderr, "  %d -> %d\n",
-            BM_elem_index_get(f),
-            pbvh_bmesh_node_index_from_face(bvh, f));
+  BM_ITER_MESH (f, &iter, bvh->bm, BM_FACES_OF_MESH) {
+    fprintf(stderr, "  %d -> %d\n", BM_elem_index_get(f), pbvh_bmesh_node_index_from_face(bvh, f));
   }
 
   fprintf(stderr, "bm_vert_to_node:\n");
   BMVert *v;
-  BM_ITER_MESH(v, &iter, bvh->bm, BM_FACES_OF_MESH) {
-    fprintf(stderr, "  %d -> %d\n",
-            BM_elem_index_get(v),
-            pbvh_bmesh_node_index_from_vert(bvh, v));
+  BM_ITER_MESH (v, &iter, bvh->bm, BM_FACES_OF_MESH) {
+    fprintf(stderr, "  %d -> %d\n", BM_elem_index_get(v), pbvh_bmesh_node_index_from_vert(bvh, v));
   }
 
   for (int n = 0; n < bvh->totnode; n++) {
@@ -2127,16 +2122,13 @@ static void pbvh_bmesh_print(PBVH *bvh)
     GSetIterator gs_iter;
     fprintf(stderr, "node %d\n  faces:\n", n);
     GSET_ITER (gs_iter, node->bm_faces)
-      fprintf(stderr, "    %d\n",
-              BM_elem_index_get((BMFace *)BLI_gsetIterator_getKey(&gs_iter)));
+      fprintf(stderr, "    %d\n", BM_elem_index_get((BMFace *)BLI_gsetIterator_getKey(&gs_iter)));
     fprintf(stderr, "  unique verts:\n");
     GSET_ITER (gs_iter, node->bm_unique_verts)
-      fprintf(stderr, "    %d\n",
-              BM_elem_index_get((BMVert *)BLI_gsetIterator_getKey(&gs_iter)));
+      fprintf(stderr, "    %d\n", BM_elem_index_get((BMVert *)BLI_gsetIterator_getKey(&gs_iter)));
     fprintf(stderr, "  other verts:\n");
     GSET_ITER (gs_iter, node->bm_other_verts)
-      fprintf(stderr, "    %d\n",
-              BM_elem_index_get((BMVert *)BLI_gsetIterator_getKey(&gs_iter)));
+      fprintf(stderr, "    %d\n", BM_elem_index_get((BMVert *)BLI_gsetIterator_getKey(&gs_iter)));
   }
 }
 
index 2d39140..1d0764d 100644 (file)
@@ -1838,9 +1838,7 @@ static bool foreach_object_particle_ptcache(Object *object,
     }
     /* Hair needs to be included in id-list for cache edit mode to work. */
 #if 0
-    if ((psys->part->type == PART_HAIR) &&
-        (psys->flag & PSYS_HAIR_DYNAMICS) == 0)
-    {
+    if ((psys->part->type == PART_HAIR) && (psys->flag & PSYS_HAIR_DYNAMICS) == 0) {
       continue;
     }
 #endif
index 4af0660..4f50dde 100644 (file)
@@ -121,12 +121,23 @@ SequencerDrawView sequencer_view3d_cb = NULL; /* NULL in background mode */
 #if 0 /* unused function */
 static void printf_strip(Sequence *seq)
 {
-  fprintf(stderr, "name: '%s', len:%d, start:%d, (startofs:%d, endofs:%d), "
+  fprintf(stderr,
+          "name: '%s', len:%d, start:%d, (startofs:%d, endofs:%d), "
           "(startstill:%d, endstill:%d), machine:%d, (startdisp:%d, enddisp:%d)\n",
-          seq->name, seq->len, seq->start, seq->startofs, seq->endofs, seq->startstill, seq->endstill, seq->machine,
-          seq->startdisp, seq->enddisp);
-
-  fprintf(stderr, "\tseq_tx_set_final_left: %d %d\n\n", seq_tx_get_final_left(seq, 0),
+          seq->name,
+          seq->len,
+          seq->start,
+          seq->startofs,
+          seq->endofs,
+          seq->startstill,
+          seq->endstill,
+          seq->machine,
+          seq->startdisp,
+          seq->enddisp);
+
+  fprintf(stderr,
+          "\tseq_tx_set_final_left: %d %d\n\n",
+          seq_tx_get_final_left(seq, 0),
           seq_tx_get_final_right(seq, 0));
 }
 #endif
index ba7e26e..65ad1c4 100644 (file)
@@ -1804,35 +1804,36 @@ static void dfdx_spring(int ia, int ic, int op, float dir[3], float L, float len
   float m, delta_ij;
   int i, j;
   if (L < len) {
-    for (i=0;i<3;i++) {
-      for (j=0;j<3;j++) {
-        delta_ij = (i==j ? (1.0f): (0.0f));
-        m=factor*(dir[i]*dir[j] + (1-L/len)*(delta_ij - dir[i]*dir[j]));
-        EIG_linear_solver_matrix_add(ia+i, op+ic+j, m);
+    for (i = 0; i < 3; i++) {
+      for (j = 0; j < 3; j++) {
+        delta_ij = (i == j ? (1.0f) : (0.0f));
+        m = factor * (dir[i] * dir[j] + (1 - L / len) * (delta_ij - dir[i] * dir[j]));
+        EIG_linear_solver_matrix_add(ia + i, op + ic + j, m);
       }
     }
   }
   else {
-    for (i=0;i<3;i++) {
-      for (j=0;j<3;j++) {
-        m=factor*dir[i]*dir[j];
-        EIG_linear_solver_matrix_add(ia+i, op+ic+j, m);
+    for (i = 0; i < 3; i++) {
+      for (j = 0; j < 3; j++) {
+        m = factor * dir[i] * dir[j];
+        EIG_linear_solver_matrix_add(ia + i, op + ic + j, m);
       }
     }
   }
 }
 
-
 static void dfdx_goal(int ia, int ic, int op, float factor)
 {
   int i;
-  for (i=0;i<3;i++) EIG_linear_solver_matrix_add(ia+i, op+ic+i, factor);
+  for (i = 0; i < 3; i++)
+    EIG_linear_solver_matrix_add(ia + i, op + ic + i, factor);
 }
 
 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);
+  for (i = 0; i < 3; i++)
+    EIG_linear_solver_matrix_add(ia + i, ic + i, factor);
 }
 #endif /* if 0 */
 
@@ -1852,16 +1853,16 @@ static void sb_spring_force(
     bp1 = &sb->bpoint[bs->v1];
     bp2 = &sb->bpoint[bs->v2];
 #if 0 /* UNUSED */
-    ia =3*bs->v1;
-    ic =3*bs->v2;
+    ia = 3 * bs->v1;
+    ic = 3 * bs->v2;
 #endif
   }
   else if (bpi == bs->v2) {
     bp1 = &sb->bpoint[bs->v2];
     bp2 = &sb->bpoint[bs->v1];
 #if 0 /* UNUSED */
-    ia =3*bs->v2;
-    ic =3*bs->v1;
+    ia = 3 * bs->v2;
+    ic = 3 * bs->v1;
 #endif
   }
   else {
@@ -2284,8 +2285,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 0
-  if (sb->nodemass > 0.009999f) timeovermass = forcetime / sb->nodemass;
-  else timeovermass = forcetime / 0.009999f;
+  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++) {
@@ -2339,11 +2342,11 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
 
       /* the freezer coming sooner or later */
 #if 0
-      if ((dot_v3v3(dx, dx)<freezeloc )&&(dot_v3v3(bp->force, bp->force)<freezeforce )) {
-        bp->frozen /=2;
+      if ((dot_v3v3(dx, dx) < freezeloc) && (dot_v3v3(bp->force, bp->force) < freezeforce)) {
+        bp->frozen /= 2;
       }
       else {
-        bp->frozen = min_ff(bp->frozen*1.05f, 1.0f);
+        bp->frozen = min_ff(bp->frozen * 1.05f, 1.0f);
       }
       mul_v3_fl(dx, bp->frozen);
 #endif
@@ -2417,73 +2420,72 @@ static void softbody_restore_prev_step(Object *ob)
 #if 0
 static void softbody_store_step(Object *ob)
 {
-  SoftBody *sb= ob->soft; /* is supposed to be there*/
+  SoftBody *sb = ob->soft; /* is supposed to be there*/
   BodyPoint *bp;
   int a;
 
-  for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
+  for (a = sb->totpoint, bp = sb->bpoint; a > 0; a--, bp++) {
     copy_v3_v3(bp->prevvec, bp->vec);
     copy_v3_v3(bp->prevpos, bp->pos);
   }
 }
 
-
 /* used by predictors and correctors */
 static void softbody_store_state(Object *ob, float *ppos, float *pvel)
 {
-  SoftBody *sb= ob->soft; /* is supposed to be there*/
+  SoftBody *sb = ob->soft; /* is supposed to be there*/
   BodyPoint *bp;
   int a;
-  float *pp=ppos, *pv=pvel;
+  float *pp = ppos, *pv = pvel;
 
-  for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
+  for (a = sb->totpoint, bp = sb->bpoint; a > 0; a--, bp++) {
 
     copy_v3_v3(pv, bp->vec);
-    pv+=3;
+    pv += 3;
 
     copy_v3_v3(pp, bp->pos);
-    pp+=3;
+    pp += 3;
   }
 }
 
 /* used by predictors and correctors */
 static void softbody_retrieve_state(Object *ob, float *ppos, float *pvel)
 {
-  SoftBody *sb= ob->soft; /* is supposed to be there*/
+  SoftBody *sb = ob->soft; /* is supposed to be there*/
   BodyPoint *bp;
   int a;
-  float *pp=ppos, *pv=pvel;
+  float *pp = ppos, *pv = pvel;
 
-  for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
+  for (a = sb->totpoint, bp = sb->bpoint; a > 0; a--, bp++) {
 
     copy_v3_v3(bp->vec, pv);
-    pv+=3;
+    pv += 3;
 
     copy_v3_v3(bp->pos, pp);
-    pp+=3;
+    pp += 3;
   }
 }
 
 /* used by predictors and correctors */
 static void softbody_swap_state(Object *ob, float *ppos, float *pvel)
 {
-  SoftBody *sb= ob->soft; /* is supposed to be there*/
+  SoftBody *sb = ob->soft; /* is supposed to be there*/
   BodyPoint *bp;
   int a;
-  float *pp=ppos, *pv=pvel;
+  float *pp = ppos, *pv = pvel;
   float temp[3];
 
-  for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
+  for (a = sb->totpoint, bp = sb->bpoint; a > 0; a--, bp++) {
 
     copy_v3_v3(temp, bp->vec);
     copy_v3_v3(bp->vec, pv);
     copy_v3_v3(pv, temp);
-    pv+=3;
+    pv += 3;
 
     copy_v3_v3(temp, bp->pos);
     copy_v3_v3(bp->pos, pp);
     copy_v3_v3(pp, temp);
-    pp+=3;
+    pp += 3;
   }
 }
 #endif
index 7a95ec3..df48e50 100644 (file)
@@ -485,12 +485,24 @@ static void studiolight_calculate_radiance_cubemap_buffers(StudioLight *sl)
           NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
 
 #if 0
-      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_X_POS], "/tmp/studiolight_radiance_left.png", IB_rectfloat);
-      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_X_NEG], "/tmp/studiolight_radiance_right.png", IB_rectfloat);
-      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_POS], "/tmp/studiolight_radiance_front.png", IB_rectfloat);
-      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_NEG], "/tmp/studiolight_radiance_back.png", IB_rectfloat);
-      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_POS], "/tmp/studiolight_radiance_bottom.png", IB_rectfloat);
-      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_NEG], "/tmp/studiolight_radiance_top.png", IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_X_POS],
+                  "/tmp/studiolight_radiance_left.png",
+                  IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_X_NEG],
+                  "/tmp/studiolight_radiance_right.png",
+                  IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_POS],
+                  "/tmp/studiolight_radiance_front.png",
+                  IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_NEG],
+                  "/tmp/studiolight_radiance_back.png",
+                  IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_POS],
+                  "/tmp/studiolight_radiance_bottom.png",
+                  IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_NEG],
+                  "/tmp/studiolight_radiance_top.png",
+                  IB_rectfloat);
 #endif
       MEM_freeN(colbuf);
     }
index ef4b9d9..930f9ac 100644 (file)
@@ -1563,7 +1563,8 @@ static void dump_buffer(TextUndoBuf *utxt)
 {
   int i = 0;
 
-  while (i++ < utxt->undo_pos) printf("%d: %d %c\n", i, utxt->buf[i], utxt->buf[i]);
+  while (i++ < utxt->undo_pos)
+    printf("%d: %d %c\n", i, utxt->buf[i], utxt->buf[i]);
 }
 
 /* Note: this function is outdated and must be updated if needed for future use */
@@ -1646,27 +1647,38 @@ void txt_print_undo(Text *text)
       i++;
       printf(" - Char is ");
       switch (op) {
-        case UNDO_INSERT_1: case UNDO_BS_1: case UNDO_DEL_1:
+        case UNDO_INSERT_1:
+        case UNDO_BS_1:
+        case UNDO_DEL_1:
           printf("%c", utxt->buf[i]);
           i++;
           break;
-        case UNDO_INSERT_2: case UNDO_BS_2: case UNDO_DEL_2:
+        case UNDO_INSERT_2:
+        case UNDO_BS_2:
+        case UNDO_DEL_2:
           printf("%c%c", utxt->buf[i], utxt->buf[i + 1]);
           i += 2;
           break;
-        case UNDO_INSERT_3: case UNDO_BS_3: case UNDO_DEL_3:
+        case UNDO_INSERT_3:
+        case UNDO_BS_3:
+        case UNDO_DEL_3:
           printf("%c%c%c", utxt->buf[i], utxt->buf[i + 1], utxt->buf[i + 2]);
           i += 3;
           break;
-        case UNDO_INSERT_4: case UNDO_BS_4: case UNDO_DEL_4:
-        {
+        case UNDO_INSERT_4:
+        case UNDO_BS_4:
+        case UNDO_DEL_4: {
           unsigned int uc;
           char c[BLI_UTF8_MAX + 1];
           size_t c_len;
-          uc = utxt->buf[i]; i++;
-          uc = uc + (utxt->buf[i] << 8); i++;
-          uc = uc + (utxt->buf[i] << 16); i++;
-          uc = uc + (utxt->buf[i] << 24); i++;
+          uc = utxt->buf[i];
+          i++;
+          uc = uc + (utxt->buf[i] << 8);
+          i++;
+          uc = uc + (utxt->buf[i] << 16);
+          i++;
+          uc = uc + (utxt->buf[i] << 24);
+          i++;
           c_len = BLI_str_utf8_from_unicode(uc, c);
           c[c_len] = '\0';
           puts(c);
@@ -1677,49 +1689,70 @@ void txt_print_undo(Text *text)
     else if (op == UNDO_DBLOCK || op == UNDO_IBLOCK) {
       i++;
 
-      linep = utxt->buf[i]; i++;
-      linep = linep + (utxt->buf[i] << 8); i++;
-      linep = linep + (utxt->buf[i] << 16); i++;
-      linep = linep + (utxt->buf[i] << 24); i++;
+      linep = utxt->buf[i];
+      i++;
+      linep = linep + (utxt->buf[i] << 8);
+      i++;
+      linep = linep + (utxt->buf[i] << 16);
+      i++;
+      linep = linep + (utxt->buf[i] << 24);
+      i++;
 
       printf(" (length %d) <", linep);
 
       while (linep > 0) {
         putchar(utxt->buf[i]);
-        linep--; i++;
+        linep--;
+        i++;
       }
 
-      linep = utxt->buf[i]; i++;
-      linep = linep + (utxt->buf[i] << 8); i++;
-      linep = linep + (utxt->buf[i] << 16); i++;
-      linep = linep + (utxt->buf[i] << 24); i++;
+      linep = utxt->buf[i];
+      i++;
+      linep = linep + (utxt->buf[i] << 8);
+      i++;
+      linep = linep + (utxt->buf[i] << 16);
+      i++;
+      linep = linep + (utxt->buf[i] << 24);
+      i++;
       printf("> (%d)", linep);
     }
     else if (op == UNDO_INDENT || op == UNDO_UNINDENT) {
       i++;
 
-      charp = utxt->buf[i]; i++;
-      charp = charp + (utxt->buf[i] << 8); i++;
+      charp = utxt->buf[i];
+      i++;
+      charp = charp + (utxt->buf[i] << 8);
+      i++;
 
-      linep = utxt->buf[i]; i++;
-      linep = linep + (utxt->buf[i] << 8); i++;
-      linep = linep + (utxt->buf[i] << 16); i++;
-      linep = linep + (utxt->buf[i] << 24); i++;
+      linep = utxt->buf[i];
+      i++;
+      linep = linep + (utxt->buf[i] << 8);
+      i++;
+      linep = linep + (utxt->buf[i] << 16);
+      i++;
+      linep = linep + (utxt->buf[i] << 24);
+      i++;
 
       printf("to <%d, %d> ", linep, charp);
 
-      charp = utxt->buf[i]; i++;
-      charp = charp + (utxt->buf[i] << 8); i++;
+      charp = utxt->buf[i];
+      i++;
+      charp = charp + (utxt->buf[i] << 8);
+      i++;
 
-      linep = utxt->buf[i]; i++;
-      linep = linep + (utxt->buf[i] << 8); i++;
-      linep = linep + (utxt->buf[i] << 16); i++;
-      linep = linep + (utxt->buf[i] << 24); i++;
+      linep = utxt->buf[i];
+      i++;
+      linep = linep + (utxt->buf[i] << 8);
+      i++;
+      linep = linep + (utxt->buf[i] << 16);
+      i++;
+      linep = linep + (utxt->buf[i] << 24);
+      i++;
 
       printf("from <%d, %d>", linep, charp);
     }
 
-    printf(" %d\n",  i);
+    printf(" %d\n", i);
     i++;
   }
 }
index 7787ca4..d8daa81 100644 (file)
@@ -51,8 +51,8 @@ int BLI_copy(const char *path, const char *to) ATTR_NONNULL();
 int BLI_rename(const char *from, const char *to) ATTR_NONNULL();
 int BLI_delete(const char *path, bool dir, bool recursive) ATTR_NONNULL();
 #if 0 /* Unused */
-int    BLI_move(const char *path, const char *to) ATTR_NONNULL();
-int    BLI_create_symlink(const char *path, const char *to) ATTR_NONNULL();
+int BLI_move(const char *path, const char *to) ATTR_NONNULL();
+int BLI_create_symlink(const char *path, const char *to) ATTR_NONNULL();
 #endif
 
 /* keep in sync with the definition of struct direntry in BLI_fileops_types.h */
@@ -113,7 +113,7 @@ bool BLI_file_is_writable(const char *file) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL
 bool BLI_file_touch(const char *file) ATTR_NONNULL();
 
 #if 0 /* UNUSED */
-int    BLI_file_gzip(const char *from, const char *to) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL();
+int BLI_file_gzip(const char *from, const char *to) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL();
 #endif
 char *BLI_file_ungzip_to_mem(const char *from_file, int *r_size) ATTR_WARN_UNUSED_RESULT
     ATTR_NONNULL();
index 0f65f8e..4860fa6 100644 (file)
@@ -608,11 +608,9 @@ static void *bli_mempool_iternext(BLI_mempool_iter *iter)
         if (iter->curchunk == NULL) {
           return ret;
         }
-        if (atomic_cas_ptr(
-                    (void **)iter->curchunk_threaded_shared,
-                    iter->curchunk,
-                    iter->curchunk->next) == iter->curchunk)
-        {
+        if (atomic_cas_ptr((void **)iter->curchunk_threaded_shared,
+                           iter->curchunk,
+                           iter->curchunk->next) == iter->curchunk) {
           break;
         }
       }
index 9e07b4d..f8a3440 100644 (file)
@@ -85,7 +85,7 @@ int BLI_file_gzip(const char *from, const char *to)
       break;
     }
     else if (readsize == 0)
-      break;  /* done reading */
+      break; /* done reading */
 
     if (gzwrite(gzfile, buffer, readsize) <= 0) {
       rval = -1; /* error happened in writing */
index 7d7ff3f..af0a665 100644 (file)
@@ -828,14 +828,9 @@ void dist_squared_to_projected_aabb_precalc(struct DistProjectedAABBPrecalc *pre
   float projmat_trans[4][4];
   transpose_m4_m4(projmat_trans, projmat);
   if (!isect_plane_plane_plane_v3(
-          projmat_trans[0], projmat_trans[1], projmat_trans[3],
-          precalc->ray_origin))
-  {
+          projmat_trans[0], projmat_trans[1], projmat_trans[3], precalc->ray_origin)) {
     /* Orthographic projection. */
-    isect_plane_plane_v3(
-            px, py,
-            precalc->ray_origin,
-            precalc->ray_direction);
+    isect_plane_plane_v3(px, py, precalc->ray_origin, precalc->ray_direction);
   }
   else {
     /* Perspective projection. */
@@ -1908,8 +1903,7 @@ bool isect_ray_tri_watertight_v3(const float ray_origin[3],
          * otherwise we won't match any of the other intersect functions here...
          * which would be confusing */
 #if 0
-        ||
-        (sign_T > *r_lambda * xor_signmask(det, sign_mask))
+        || (sign_T > *r_lambda * xor_signmask(det, sign_mask))
 #endif
     ) {
       return false;
@@ -1945,10 +1939,14 @@ bool isect_ray_tri_watertight_v3_simple(const float ray_origin[3],
  * A version of #isect_ray_tri_v3 which takes a threshold argument
  * so rays slightly outside the triangle to be considered as intersecting.
  */
-bool isect_ray_tri_threshold_v3(
-        const float ray_origin[3], const float ray_direction[3],
-        const float v0[3], const float v1[3], const float v2[3],
-        float *r_lambda, float r_uv[2], const float threshold)
+bool isect_ray_tri_threshold_v3(const float ray_origin[3],
+                                const float ray_direction[3],
+                                const float v0[3],
+                                const float v1[3],
+                                const float v2[3],
+                                float *r_lambda,
+                                float r_uv[2],
+                                const float threshold)
 {
   const float epsilon = 0.00000001f;
   float p[3], s[3], e1[3], e2[3], q[3];
@@ -1960,14 +1958,16 @@ bool isect_ray_tri_threshold_v3(
 
   cross_v3_v3v3(p, ray_direction, e2);
   a = dot_v3v3(e1, p);
-  if ((a > -epsilon) && (a < epsilon)) return false;
+  if ((a > -epsilon) && (a < epsilon))
+    return false;
   f = 1.0f / a;
 
   sub_v3_v3v3(s, ray_origin, v0);
 
   cross_v3_v3v3(q, s, e1);
   *r_lambda = f * dot_v3v3(e2, q);
-  if ((*r_lambda < 0.0f)) return false;
+  if ((*r_lambda < 0.0f))
+    return false;
 
   u = f * dot_v3v3(s, p);
   v = f * dot_v3v3(ray_direction, q);
@@ -1978,13 +1978,19 @@ bool isect_ray_tri_threshold_v3(
     dv = v - t;
   }
   else {
-    if      (u < 0) du = u;
-    else if (u > 1) du = u - 1;
-    else            du = 0.0f;
+    if (u < 0)
+      du = u;
+    else if (u > 1)
+      du = u - 1;
+    else
+      du = 0.0f;
 
-    if      (v < 0) dv = v;
-    else if (v > 1) dv = v - 1;
-    else            dv = 0.0f;
+    if (v < 0)
+      dv = v;
+    else if (v > 1)
+      dv = v - 1;
+    else
+      dv = 0.0f;
   }
 
   mul_v3_fl(e1, du);
@@ -5212,20 +5218,20 @@ typedef union {
 
 static vFloat vec_splat_float(float val)
 {
-  return (vFloat) {val, val, val, val};
+  return (vFloat){val, val, val, val};
 }
 
 static float ff_quad_form_factor(float *p, float *n, float *q0, float *q1, float *q2, float *q3)
 {
   vFloat vcos, rlen, vrx, vry, vrz, vsrx, vsry, vsrz, gx, gy, gz, vangle;
-  vUInt8 rotate = (vUInt8) {4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3};
+  vUInt8 rotate = (vUInt8){4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3};
   vFloatResult vresult;
   float result;
 
   /* compute r* */
-  vrx = (vFloat) {q0[0], q1[0], q2[0], q3[0]} -vec_splat_float(p[0]);
-  vry = (vFloat) {q0[1], q1[1], q2[1], q3[1]} -vec_splat_float(p[1]);
-  vrz = (vFloat) {q0[2], q1[2], q2[2], q3[2]} -vec_splat_float(p[2]);
+  vrx = (vFloat){q0[0], q1[0], q2[0], q3[0]} - vec_splat_float(p[0]);
+  vry = (vFloat){q0[1], q1[1], q2[1], q3[1]} - vec_splat_float(p[1]);
+  vrz = (vFloat){q0[2], q1[2], q2[2], q3[2]} - vec_splat_float(p[2]);
 
   /* normalize r* */
   rlen = vec_rsqrte(vrx * vrx + vry * vry + vrz * vrz + vec_splat_float(1e-16f));
@@ -5255,9 +5261,9 @@ static float ff_quad_form_factor(float *p, float *n, float *q0, float *q1, float
   vangle = vacosf(vcos);
 
   /* dot */
-  vresult.v = (vec_splat_float(n[0]) * gx +
-               vec_splat_float(n[1]) * gy +
-               vec_splat_float(n[2]) * gz) * vangle;
+  vresult.v = (vec_splat_float(n[0]) * gx + vec_splat_float(n[1]) * gy +
+               vec_splat_float(n[2]) * gz) *
+              vangle;
 
   result = (vresult.f[0] + vresult.f[1] + vresult.f[2] + vresult.f[3]) * (0.5f / (float)M_PI);
   result = MAX2(result, 0.0f);
index 6acfb53..3806039 100644 (file)
@@ -54,10 +54,8 @@ static float P(float k)
 static float P(float k)
 {
   return (float)(1.0f / 6.0f) *
-          (pow(MAX2(k + 2.0f, 0), 3.0f) - 4.0f *
-           pow(MAX2(k + 1.0f, 0), 3.0f) + 6.0f *
-           pow(MAX2(k, 0), 3.0f) - 4.0f *
-           pow(MAX2(k - 1.0f, 0), 3.0f));
+         (pow(MAX2(k + 2.0f, 0), 3.0f) - 4.0f * pow(MAX2(k + 1.0f, 0), 3.0f) +
+          6.0f * pow(MAX2(k, 0), 3.0f) - 4.0f * pow(MAX2(k - 1.0f, 0), 3.0f));
 }
 #endif
 
index e05edfd..6acf0a7 100644 (file)
@@ -3724,7 +3724,8 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree)
     bNodeInstanceHash *new_previews = BKE_node_instance_hash_new("node previews");
     bNodeInstanceHashIterator iter;
 
-    NODE_INSTANCE_HASH_ITER(iter, ntree->previews) {
+    NODE_INSTANCE_HASH_ITER(iter, ntree->previews)
+    {
       bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
       if (preview) {
         bNodePreview *new_preview = newimaadr(fd, preview);
index df56809..69416f0 100644 (file)
@@ -1156,9 +1156,12 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *bmain)
           /* Copy over the settings stored in the GP datablock linked to the scene, for minimal disruption */
           ts->gpencil_v3d_align = 0;
 
-          if (gpd->flag & GP_DATA_VIEWALIGN)    ts->gpencil_v3d_align |= GP_PROJECT_VIEWSPACE;
-          if (gpd->flag & GP_DATA_DEPTH_VIEW)   ts->gpencil_v3d_align |= GP_PROJECT_DEPTH_VIEW;
-          if (gpd->flag & GP_DATA_DEPTH_STROKE) ts->gpencil_v3d_align |= GP_PROJECT_DEPTH_STROKE;
+          if (gpd->flag & GP_DATA_VIEWALIGN)
+            ts->gpencil_v3d_align |= GP_PROJECT_VIEWSPACE;
+          if (gpd->flag & GP_DATA_DEPTH_VIEW)
+            ts->gpencil_v3d_align |= GP_PROJECT_DEPTH_VIEW;
+          if (gpd->flag & GP_DATA_DEPTH_STROKE)
+            ts->gpencil_v3d_align |= GP_PROJECT_DEPTH_STROKE;
 
           if (gpd->flag & GP_DATA_DEPTH_STROKE_ENDPOINTS)
             ts->gpencil_v3d_align |= GP_PROJECT_DEPTH_STROKE_ENDPOINTS;
index 16a534b..fd9439e 100644 (file)
@@ -1125,11 +1125,9 @@ void bm_log_print(const BMLog *log, const char *description)
   int i;
 
   printf("%s:\n", description);
-  printf("    % 2d: [ initial ]%s\n", 0,
-         (!log->current_entry) ? current : "");
+  printf("    % 2d: [ initial ]%s\n", 0, (!log->current_entry) ? current : "");
   for (entry = log->entries.first, i = 1; entry; entry = entry->next, i++) {
-    printf("    % 2d: [%p]%s\n", i, entry,
-           (entry == log->current_entry) ? current : "");
+    printf("    % 2d: [%p]%s\n", i, entry, (entry == log->current_entry) ? current : "");
   }
 }
 #endif
index 8d445d4..3673c29 100644 (file)
@@ -1026,19 +1026,24 @@ static void bm_mesh_loops_calc_normals_no_autosmooth(BMesh *bm,
  * Updates the loop normals of a mesh. Assumes vertex and face normals are valid (else call BM_mesh_normals_update()
  * first)!
  */
-void BM_mesh_loop_normals_update(
-        BMesh *bm, const bool use_split_normals, const float split_angle, float (*r_lnos)[3],
-        MLoopNorSpaceArray *r_lnors_spacearr, short (*clnors_data)[2], const int cd_loop_clnors_offset)
+void BM_mesh_loop_normals_update(BMesh *bm,
+                                 const bool use_split_normals,
+                                 const float split_angle,
+                                 float (*r_lnos)[3],
+                                 MLoopNorSpaceArray *r_lnors_spacearr,
+                                 short (*clnors_data)[2],
+                                 const int cd_loop_clnors_offset)
 {
   const bool has_clnors = clnors_data || (cd_loop_clnors_offset != -1);
 
   if (use_split_normals) {
-          /* Tag smooth edges and set lnos from vnos when they might be completely smooth...
+    /* Tag smooth edges and set lnos from vnos when they might be completely smooth...
            * When using custom loop normals, disable the angle feature! */
-          bm_mesh_edges_sharp_tag(bm, NULL, NULL, has_clnors ? (float)M_PI : split_angle, r_lnos);
+    bm_mesh_edges_sharp_tag(bm, NULL, NULL, has_clnors ? (float)M_PI : split_angle, r_lnos);
 
-          /* Finish computing lnos by accumulating face normals in each fan of faces defined by sharp edges. */
-          bm_mesh_loops_calc_normals(bm, NULL, NULL, r_lnos, r_lnors_spacearr, clnors_data, cd_loop_clnors_offset);
+    /* Finish computing lnos by accumulating face normals in each fan of faces defined by sharp edges. */
+    bm_mesh_loops_calc_normals(
+        bm, NULL, NULL, r_lnos, r_lnors_spacearr, clnors_data, cd_loop_clnors_offset);
   }
   else {
     BLI_assert(!r_lnors_spacearr);
@@ -1839,8 +1844,13 @@ void BM_mesh_elem_index_validate(
 
       /* dirty may have been incorrectly set */
       fprintf(stderr,
-              "Invalid Dirty: at %s, %s (%s), dirty flag was set but all index values are correct, '%s', '%s'\n",
-              location, func, type_names[i], msg_a, msg_b);
+              "Invalid Dirty: at %s, %s (%s), dirty flag was set but all index values are "
+              "correct, '%s', '%s'\n",
+              location,
+              func,
+              type_names[i],
+              msg_a,
+              msg_b);
 #endif
     }
   }
@@ -1848,9 +1858,7 @@ void BM_mesh_elem_index_validate(
 #if 0 /* mostly annoying, even in debug mode */
 #  ifdef DEBUG
   if (is_any_error == 0) {
-    fprintf(stderr,
-            "Valid Index Success: at %s, %s, '%s', '%s'\n",
-            location, func, msg_a, msg_b);
+    fprintf(stderr, "Valid Index Success: at %s, %s, '%s', '%s'\n", location, func, msg_a, msg_b);
   }
 #  endif
 #endif
index 1075b37..606051e 100644 (file)
@@ -531,14 +531,15 @@ BMEdge *BM_vert_collapse_edge(
 
   /* in this case we want to keep all faces and not join them,
    * rather just get rid of the vertex - see bug [#28645] */
-  BMVert *tv  = BM_edge_other_vert(e_kill, v_kill);
+  BMVert *tv = BM_edge_other_vert(e_kill, v_kill);
   if (tv) {
     BMEdge *e2 = bmesh_disk_edge_next(e_kill, v_kill);
     if (e2) {
       BMVert *tv2 = BM_edge_other_vert(e2, v_kill);
       if (tv2) {
         /* only action, other calls here only get the edge to return */
-        e_new = bmesh_kernel_join_edge_kill_vert(bm, e_kill, v_kill, do_del, true, kill_degenerate_faces);
+        e_new = bmesh_kernel_join_edge_kill_vert(
+            bm, e_kill, v_kill, do_del, true, kill_degenerate_faces);
       }
     }
   }
@@ -748,11 +749,12 @@ bool BM_face_validate(BMFace *face, FILE *err)
   }
 
   BLI_array_grow_items(verts, face->len);
-  BM_ITER_ELEM_INDEX (l, &iter, face, BM_LOOPS_OF_FACE, i) {
+  BM_ITER_ELEM_INDEX(l, &iter, face, BM_LOOPS_OF_FACE, i)
+  {
     verts[i] = l->v;
     if (l->e->v1 == l->e->v2) {
       fprintf(err, "Found bmesh edge with identical verts!\n");
-      fprintf(err, "  edge ptr: %p, vert: %p\n",  l->e, l->e->v1);
+      fprintf(err, "  edge ptr: %p, vert: %p\n", l->e, l->e->v1);
       fflush(err);
       ret = false;
     }
index a778308..0e9b615 100644 (file)
@@ -741,7 +741,8 @@ void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slot_code, int totadd)
     if (slot->len >= slot->size) {
       slot->size = (slot->size + 1 + totadd) * 2;
 
-      allocsize = BMO_OPSLOT_TYPEINFO[bmo_opdefines[op->type]->slot_types[slot_code].type] * slot->size;
+      allocsize = BMO_OPSLOT_TYPEINFO[bmo_opdefines[op->type]->slot_types[slot_code].type] *
+                  slot->size;
 
       tmp = slot->data.buf;
       slot->data.buf = MEM_callocN(allocsize, "opslot dynamic array");
@@ -756,7 +757,8 @@ void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slot_code, int totadd)
     slot->len += totadd;
     slot->size = slot->len + 2;
 
-    allocsize = BMO_OPSLOT_TYPEINFO[bmo_opdefines[op->type]->slot_types[slot_code].type] * slot->len;
+    allocsize = BMO_OPSLOT_TYPEINFO[bmo_opdefines[op->type]->slot_types[slot_code].type] *
+                slot->len;
 
     tmp = slot->data.buf;
     slot->data.buf = MEM_callocN(allocsize, "opslot dynamic array");
index 2a734c2..6f363e5 100644 (file)
@@ -1587,7 +1587,7 @@ void BM_mesh_calc_tessellation_beauty(BMesh *bm, BMLoop *(*looptris)[3], int *r_
        */
 #if 0
       const bool split_13 = (BM_verts_calc_rotate_beauty(
-              l_v1->v, l_v2->v, l_v3->v, l_v4->v, 0, 0) < 0.0f);
+                                 l_v1->v, l_v2->v, l_v3->v, l_v4->v, 0, 0) < 0.0f);
 #else
       float axis_mat[3][3], v_quad[4][2];
       axis_dominant_v3_to_m3(axis_mat, efa->no);
index 98ad30b..1986a1c 100644 (file)
@@ -1917,7 +1917,6 @@ BMEdge *BM_edge_exists(BMVert *v_a, BMVert *v_b)
   BMIter iter;
   BMEdge *e;
 
-
   BLI_assert(v_a != v_b);
   BLI_assert(v_a->head.htype == BM_VERT && v_b->head.htype == BM_VERT);
 
index c327c10..0097e0a 100644 (file)
@@ -209,14 +209,13 @@ static void *bmw_VertShellWalker_step(BMWalker *walker)
 
   BMW_state_remove(walker);
 
-
   /* find the next edge whose other vertex has not been visite */
   curedge = shellWalk.curedge;
   do {
     if (!BLI_gset_haskey(walker->visit_set, curedge)) {
       if (!walker->restrictflag ||
-          (walker->restrictflag && BMO_edge_flag_test(walker->bm, curedge, walker->restrictflag)))
-      {
+          (walker->restrictflag &&
+           BMO_edge_flag_test(walker->bm, curedge, walker->restrictflag))) {
         BMwShellWalker *newstate;
 
         v_old = BM_edge_other_vert(curedge, shellWalk.base);
index e8a49c8..be7527a 100644 (file)
@@ -66,15 +66,24 @@ static int erot_gsetutil_cmp(const void *a, const void *b)
 {
   const EdRotState *e_state_a = (const EdRotState *)a;
   const EdRotState *e_state_b = (const EdRotState *)b;
-  if      (e_state_a->v1 < e_state_b->v1) return -1;
-  else if (e_state_a->v1 > e_state_b->v1) return  1;
-  else if (e_state_a->v2 < e_state_b->v2) return -1;
-  else if (e_state_a->v2 > e_state_b->v2) return  1;
-  else if (e_state_a->f1 < e_state_b->f1) return -1;
-  else if (e_state_a->f1 > e_state_b->f1) return  1;
-  else if (e_state_a->f2 < e_state_b->f2) return -1;
-  else if (e_state_a->f2 > e_state_b->f2) return  1;
-  else                                    return  0;
+  if (e_state_a->v1 < e_state_b->v1)
+    return -1;
+  else if (e_state_a->v1 > e_state_b->v1)
+    return 1;
+  else if (e_state_a->v2 < e_state_b->v2)
+    return -1;
+  else if (e_state_a->v2 > e_state_b->v2)
+    return 1;
+  else if (e_state_a->f1 < e_state_b->f1)
+    return -1;
+  else if (e_state_a->f1 > e_state_b->f1)
+    return 1;
+  else if (e_state_a->f2 < e_state_b->f2)
+    return -1;
+  else if (e_state_a->f2 > e_state_b->f2)
+    return 1;
+  else
+    return 0;
 }
 #endif
 static GSet *erot_gset_new(void)
index f6695db..e7a48ee 100644 (file)
@@ -351,7 +351,8 @@ virtual void AnimationImporter::change_eul_to_quat(Object *ob, bAction *act)
 
     std::vector<FCurve *> &rot_fcurves = fcurves_actionGroup_map[grp];
 
-    if (rot_fcurves.size() > 3) continue;
+    if (rot_fcurves.size() > 3)
+      continue;
 
     for (i = 0; i < rot_fcurves.size(); i++)
       eulcu[rot_fcurves[i]->array_index] = rot_fcurves[i];
@@ -366,7 +367,7 @@ virtual void AnimationImporter::change_eul_to_quat(Object *ob, bAction *act)
       create_fcurve(0, rna_path),
       create_fcurve(1, rna_path),
       create_fcurve(2, rna_path),
-      create_fcurve(3, rna_path)
+      create_fcurve(3, rna_path),
     };
 
     bPoseChannel *chan = BKE_pose_channel_find_name(ob->pose, grp->name);
@@ -379,7 +380,8 @@ virtual void AnimationImporter::change_eul_to_quat(Object *ob, bAction *act)
 
       FCurve *cu = eulcu[i];
 
-      if (!cu) continue;
+      if (!cu)
+        continue;
 
       for (int j = 0; j < cu->totvert; j++) {
         float frame = cu->bezt[j].vec[1][0];
@@ -387,7 +389,7 @@ virtual void AnimationImporter::change_eul_to_quat(Object *ob, bAction *act)
         float eul[3] = {
           eulcu[0] ? evaluate_fcurve(eulcu[0], frame) : 0.0f,
           eulcu[1] ? evaluate_fcurve(eulcu[1], frame) : 0.0f,
-          eulcu[2] ? evaluate_fcurve(eulcu[2], frame) : 0.0f
+          eulcu[2] ? evaluate_fcurve(eulcu[2], frame) : 0.0f,
         };
 
         // make eul relative to bone rest pose
@@ -410,7 +412,8 @@ virtual void AnimationImporter::change_eul_to_quat(Object *ob, bAction *act)
     // now replace old Euler curves
 
     for (i = 0; i < 3; i++) {
-      if (!eulcu[i]) continue;
+      if (!eulcu[i])
+        continue;
 
       action_groups_remove_channel(act, eulcu[i]);
       free_fcurve(eulcu[i]);
@@ -574,14 +577,13 @@ void AnimationImporter::Assign_transform_animations(
 
     case COLLADAFW::Transformation::MATRIX:
 #if 0
-      {
-        COLLADAFW::Matrix *mat = (COLLADAFW::Matrix*)transform;
-        COLLADABU::Math::Matrix4 mat4 = mat->getMatrix();
-        switch (binding->animationClass) {
-          case COLLADAFW::AnimationList::TRANSFORM:
-
-        }
+    {
+      COLLADAFW::Matrix *mat = (COLLADAFW::Matrix *)transform;
+      COLLADABU::Math::Matrix4 mat4 = mat->getMatrix();
+      switch (binding->animationClass) {
+        case COLLADAFW::AnimationList::TRANSFORM:
       }
+    }
 #endif
       unused_fcurve(curves);
       break;
@@ -2045,7 +2047,8 @@ Object *AnimationImporter::get_joint_object(COLLADAFW::Node *root,
 #if 0
 // recursively evaluates joint tree until end is found, mat then is world-space matrix of end
 // mat must be identity on enter, node must be root
-bool AnimationImporter::evaluate_joint_world_transform_at_frame(float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end, float fra)
+bool AnimationImporter::evaluate_joint_world_transform_at_frame(
+    float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end, float fra)
 {
   float m[4][4];
   if (par) {
@@ -2062,7 +2065,7 @@ bool AnimationImporter::evaluate_joint_world_transform_at_frame(float mat[4][4],
     return true;
   }
   else {
-    COLLADAFW::NodePointerArraychildren = node->getChildNodes();
+    COLLADAFW::NodePointerArray &children = node->getChildNodes();
     for (int i = 0; i < children.getCount(); i++) {
       if (evaluate_joint_world_transform_at_frame(mat, m, children[i], end, fra))
         return true;
index 65e9974..f15c021 100644 (file)
@@ -238,7 +238,8 @@ class AnimationImporter : private TransformReader, public AnimationImporterBase
 #if 0
   // recursively evaluates joint tree until end is found, mat then is world-space matrix of end
   // mat must be identity on enter, node must be root
-  bool evaluate_joint_world_transform_at_frame(float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end, float fra);
+  bool evaluate_joint_world_transform_at_frame(
+      float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end, float fra);
 #endif
 
   void add_bone_fcurve(Object *ob, COLLADAFW::Node *node, FCurve *fcu);
index ea1e98c..5abe099 100644 (file)
@@ -119,12 +119,12 @@ bool ArmatureExporter::add_instance_controller(Object *ob)
 void ArmatureExporter::operator()(Object *ob)
 {
   Object *ob_arm = bc_get_assigned_armature(ob);
-
 }
 
 bool ArmatureExporter::already_written(Object *ob_arm)
 {
-  return std::find(written_armatures.begin(), written_armatures.end(), ob_arm) != written_armatures.end();
+  return std::find(written_armatures.begin(), written_armatures.end(), ob_arm) !=
+         written_armatures.end();
 }
 
 void ArmatureExporter::wrote(Object *ob_arm)
@@ -132,11 +132,13 @@ void ArmatureExporter::wrote(Object *ob_arm)
   written_armatures.push_back(ob_arm);
 }
 
-void ArmatureExporter::find_objects_using_armature(Object *ob_arm, std::vector<Object *>& objects, Scene *sce)
+void ArmatureExporter::find_objects_using_armature(Object *ob_arm,
+                                                   std::vector<Object *> &objects,
+                                                   Scene *sce)
 {
   objects.clear();
 
-  Base *base = (Base *) sce->base.first;
+  Base *base = (Base *)sce->base.first;
   while (base) {
     Object *ob = base->object;
 
index f0da868..6ef6007 100644 (file)
@@ -81,7 +81,7 @@ class ArmatureExporter : public COLLADASW::LibraryControllers,
 
   void wrote(Object *ob_arm);
 
-  void find_objects_using_armature(Object *ob_arm, std::vector<Object *>objects, Scene *sce);
+  void find_objects_using_armature(Object *ob_arm, std::vector<Object *> &objects, Scene *sce);
 #endif
 
   // Scene, SceneExporter and the list of child_objects
index 038dbd0..315ae91 100644 (file)
@@ -75,11 +75,11 @@ ArmatureImporter::~ArmatureImporter()
 #if 0
 JointData *ArmatureImporter::get_joint_data(COLLADAFW::Node *node);
 {
-  const COLLADAFW::UniqueIdjoint_id = node->getUniqueId();
+  const COLLADAFW::UniqueId &joint_id = node->getUniqueId();
 
   if (joint_id_to_joint_index_map.find(joint_id) == joint_id_to_joint_index_map.end()) {
-    fprintf(stderr, "Cannot find a joint index by joint id for %s.\n",
-            node->getOriginalId().c_str());
+    fprintf(
+        stderr, "Cannot find a joint index by joint id for %s.\n", node->getOriginalId().c_str());
     return NULL;
   }
 
@@ -371,7 +371,7 @@ void ArmatureImporter::set_leaf_bone_shapes(Object *ob_arm)
 
   std::vector<LeafBone>::iterator it;
   for (it = leaf_bones.begin(); it != leaf_bones.end(); it++) {
-    LeafBoneleaf = *it;
+    LeafBone &leaf = *it;
 
     bPoseChannel *pchan = BKE_pose_channel_find_name(pose, leaf.name);
     if (pchan) {
@@ -396,7 +396,7 @@ void ArmatureImporter::set_euler_rotmode()
     std::map<COLLADAFW::UniqueId, SkinInfo>::iterator sit;
 
     for (sit = skin_by_data_uid.begin(); sit != skin_by_data_uid.end(); sit++) {
-      SkinInfoskin = sit->second;
+      SkinInfo &skin = sit->second;
 
       if (skin.uses_joint_or_descendant(joint)) {
         bPoseChannel *pchan = skin.get_pose_channel_from_node(joint);
@@ -430,23 +430,26 @@ Object *ArmatureImporter::get_empty_for_leaves()
 Object *ArmatureImporter::find_armature(COLLADAFW::Node *node)
 {
   JointData *jd = get_joint_data(node);
-  if (jd) return jd->ob_arm;
+  if (jd)
+    return jd->ob_arm;
 
-  COLLADAFW::NodePointerArraychildren = node->getChildNodes();
+  COLLADAFW::NodePointerArray &children = node->getChildNodes();
   for (int i = 0; i < children.getCount(); i++) {
     Object *ob_arm = find_armature(children[i]);
-    if (ob_arm) return ob_arm;
+    if (ob_arm)
+      return ob_arm;
   }
 
   return NULL;
 }
 
-ArmatureJointsArmatureImporter::get_armature_joints(Object *ob_arm)
+ArmatureJoints &ArmatureImporter::get_armature_joints(Object *ob_arm)
 {
   // try finding it
   std::vector<ArmatureJoints>::iterator it;
   for (it = armature_joints.begin(); it != armature_joints.end(); it++) {
-    if ((*it).ob_arm == ob_arm) return *it;
+    if ((*it).ob_arm == ob_arm)
+      return *it;
   }
 
   // not found, create one
@@ -800,7 +803,9 @@ void ArmatureImporter::make_armatures(bContext *C, std::vector<Object *> &object
 
 #if 0
 // link with meshes, create vertex groups, assign weights
-void ArmatureImporter::link_armature(Object *ob_arm, const COLLADAFW::UniqueId& geom_id, const COLLADAFW::UniqueId& controller_data_id)
+void ArmatureImporter::link_armature(Object *ob_arm,
+                                     const COLLADAFW::UniqueId &geom_id,
+                                     const COLLADAFW::UniqueId &controller_data_id)
 {
   Object *ob = mesh_importer->get_object_by_geom_uid(geom_id);
 
@@ -814,7 +819,7 @@ void ArmatureImporter::link_armature(Object *ob_arm, const COLLADAFW::UniqueId&
     return;
   }
 
-  SkinInfoskin = skin_by_data_uid[conroller_data_id];
+  SkinInfo &skin = skin_by_data_uid[conroller_data_id];
 
   // create vertex groups
 }
index cfcd950..19f053c 100644 (file)
@@ -73,7 +73,7 @@ class ArmatureImporter : private TransformReader {
 #if 0
   struct ArmatureJoints {
     Object *ob_arm;
-    std::vector<COLLADAFW::Node*> root_joints;
+    std::vector<COLLADAFW::Node *> root_joints;
   };
   std::vector<ArmatureJoints> armature_joints;
 #endif
@@ -133,7 +133,7 @@ class ArmatureImporter : private TransformReader {
 #if 0
   Object *find_armature(COLLADAFW::Node *node);
 
-  ArmatureJointsget_armature_joints(Object *ob_arm);
+  ArmatureJoints &get_armature_joints(Object *ob_arm);
 #endif
 
   Object *create_armature_bones(Main *bmain, SkinInfo &skin);
@@ -161,7 +161,9 @@ class ArmatureImporter : private TransformReader {
 
 #if 0
   // link with meshes, create vertex groups, assign weights
-  void link_armature(Object *ob_arm, const COLLADAFW::UniqueId& geom_id, const COLLADAFW::UniqueId& controller_data_id);
+  void link_armature(Object *ob_arm,
+                     const COLLADAFW::UniqueId &geom_id,
+                     const COLLADAFW::UniqueId &controller_data_id);
 #endif
 
   bool write_skin_controller_data(const COLLADAFW::SkinControllerData *data);
index 9a281e2..e8b1015 100644 (file)
@@ -332,10 +332,9 @@ bool BCAnimationSampler::get_object_samples(BCMatrixSampleMap &samples, Object *
    animation_type BC_ANIMATION_EXPORT_KEYS: Only take data from matrices for keyframes
 */
 
-void BCAnimationSampler::add_value_set(
-  BCAnimationCurve &curve,
-  BCFrameSampleMap &samples,
-  BC_export_animation_type animation_type)
+void BCAnimationSampler::add_value_set(BCAnimationCurve &curve,
+                                       BCFrameSampleMap &samples,
+                                       BC_export_animation_type animation_type)
 {
   int array_index = curve.get_array_index();
   const BC_animation_transform_type tm_type = curve.get_transform_type();
index dc9a701..0c9ca40 100644 (file)
@@ -123,7 +123,8 @@ void ControllerExporter::operator()(Object *ob)
 
 bool ArmatureExporter::already_written(Object *ob_arm)
 {
-  return std::find(written_armatures.begin(), written_armatures.end(), ob_arm) != written_armatures.end();
+  return std::find(written_armatures.begin(), written_armatures.end(), ob_arm) !=
+         written_armatures.end();
 }
 
 void ArmatureExporter::wrote(Object *ob_arm)
@@ -131,11 +132,13 @@ void ArmatureExporter::wrote(Object *ob_arm)
   written_armatures.push_back(ob_arm);
 }
 
-void ArmatureExporter::find_objects_using_armature(Object *ob_arm, std::vector<Object *>& objects, Scene *sce)
+void ArmatureExporter::find_objects_using_armature(Object *ob_arm,
+                                                   std::vector<Object *> &objects,
+                                                   Scene *sce)
 {
   objects.clear();
 
-  Base *base = (Base *) sce->base.first;
+  Base *base = (Base *)sce->base.first;
   while (base) {
     Object *ob = base->object;
 
@@ -174,10 +177,10 @@ void ControllerExporter::export_skin_controller(Object *ob, Object *ob_arm)
 #if 0
   me->dvert :
 
-  typedef struct MDeformVert {
+      typedef struct MDeformVert {
     struct MDeformWeight *dw;
     int totweight;
-    int flag;   // flag only in use for weightpaint now
+    int flag;  // flag only in use for weightpaint now
   } MDeformVert;
 
   typedef struct MDeformWeight {
index 50056df..38d85cb 100644 (file)
@@ -85,7 +85,7 @@ class ControllerExporter : public COLLADASW::LibraryControllers,
 
   void wrote(Object *ob_arm);
 
-  void find_objects_using_armature(Object *ob_arm, std::vector<Object *>objects, Scene *sce);
+  void find_objects_using_armature(Object *ob_arm, std::vector<Object *> &objects, Scene *sce);
 #endif
 
   std::string get_controller_id(Object *ob_arm, Object *ob);
index d21e71b..4286781 100644 (file)
@@ -294,10 +294,10 @@ void DocumentImporter::translate_anim_recursive(COLLADAFW::Node *node,
 
 #if 0
   COLLADAFW::Transformation::TransformationType types[] = {
-    COLLADAFW::Transformation::ROTATE,
-    COLLADAFW::Transformation::SCALE,
-    COLLADAFW::Transformation::TRANSLATE,
-    COLLADAFW::Transformation::MATRIX,
+      COLLADAFW::Transformation::ROTATE,
+      COLLADAFW::Transformation::SCALE,
+      COLLADAFW::Transformation::TRANSLATE,
+      COLLADAFW::Transformation::MATRIX,
   };
 
   Object *ob;
index 58435c4..280a0c4 100644 (file)
@@ -198,7 +198,8 @@ void EffectsExporter::operator()(Material *ma, Object *ob)
     Image *ima = t->tex->ima;
 
     // Image not set for texture
-    if (!ima) continue;
+    if (!ima)
+      continue;
 
     std::string key(id_name(ima));
     key = translate_id(key);
@@ -206,10 +207,9 @@ void EffectsExporter::operator()(Material *ma, Object *ob)
     // create only one <sampler>/<surface> pair for each unique image
     if (im_samp_map.find(key) == im_samp_map.end()) {
       //<newparam> <sampler> <source>
-      COLLADASW::Sampler sampler(
-              COLLADASW::Sampler::SAMPLER_TYPE_2D,
-              key + COLLADASW::Sampler::SAMPLER_SID_SUFFIX,
-              key + COLLADASW::Sampler::SURFACE_SID_SUFFIX);
+      COLLADASW::Sampler sampler(COLLADASW::Sampler::SAMPLER_TYPE_2D,
+                                 key + COLLADASW::Sampler::SAMPLER_SID_SUFFIX,
+                                 key + COLLADASW::Sampler::SURFACE_SID_SUFFIX);
       sampler.setImageId(key);
       // copy values to arrays since they will live longer
       samplers[a] = sampler;
@@ -235,7 +235,8 @@ void EffectsExporter::operator()(Material *ma, Object *ob)
     key = translate_id(key);
     int i = im_samp_map[key];
     std::string uvname = strlen(t->uvname) ? t->uvname : active_uv;
-    COLLADASW::Sampler *sampler = (COLLADASW::Sampler *)samp_surf[i]; // possibly uninitialised memory ...
+    COLLADASW::Sampler *sampler = (COLLADASW::Sampler *)
+        samp_surf[i];  // possibly uninitialised memory ...
     writeTextures(ep, key, sampler, t, ima, uvname);
   }
 #endif
index 2e964bb..9ce6b39 100644 (file)
@@ -264,13 +264,11 @@ Mesh *bc_get_mesh_copy(BlenderContext &blender_context,
   if (apply_modifiers) {
 #if 0 /* Not supported by new system currently... */
     switch (export_mesh_type) {
-      case BC_MESH_TYPE_VIEW:
-      {
+      case BC_MESH_TYPE_VIEW: {
         dm = mesh_create_derived_view(depsgraph, scene, ob, &mask);
         break;
       }
-      case BC_MESH_TYPE_RENDER:
-      {
+      case BC_MESH_TYPE_RENDER: {
         dm = mesh_create_derived_render(depsgraph, scene, ob, &mask);
         break;
       }
@@ -826,18 +824,16 @@ void bc_set_IDPropertyMatrix(EditBone *ebone, const char *key, float mat[4][4])
  */
 static void bc_set_IDProperty(EditBone *ebone, const char *key, float value)
 {
-  if (ebone->prop == NULL)
-  {
-    IDPropertyTemplate val = { 0 };
+  if (ebone->prop == NULL) {
+    IDPropertyTemplate val = {0};
     ebone->prop = IDP_New(IDP_GROUP, &val, "RNA_EditBone ID properties");
   }
 
   IDProperty *pgroup = (IDProperty *)ebone->prop;
-  IDPropertyTemplate val = { 0 };
+  IDPropertyTemplate val = {0};
   IDProperty *prop = IDP_New(IDP_FLOAT, &val, key);
   IDP_Float(prop) = value;
   IDP_AddToGroup(pgroup, prop);
-
 }
 #endif
 
@@ -1262,7 +1258,10 @@ bNode *bc_add_node(bContext *C, bNodeTree *ntree, int node_type, int locx, int l
 
 #if 0
 // experimental, probably not used
-static bNodeSocket *bc_group_add_input_socket(bNodeTree *ntree, bNode *to_node, int to_index, std::string label)
+static bNodeSocket *bc_group_add_input_socket(bNodeTree *ntree,
+                                              bNode *to_node,
+                                              int to_index,
+                                              std::string label)
 {
   bNodeSocket *to_socket = (bNodeSocket *)BLI_findlink(&to_node->inputs, to_index);
 
@@ -1278,7 +1277,10 @@ static bNodeSocket *bc_group_add_input_socket(bNodeTree *ntree, bNode *to_node,
   return newsock;
 }
 
-static bNodeSocket *bc_group_add_output_socket(bNodeTree *ntree, bNode *from_node, int from_index, std::string label)
+static bNodeSocket *bc_group_add_output_socket(bNodeTree *ntree,
+                                               bNode *from_node,
+                                               int from_index,
+                                               std::string label)
 {
   bNodeSocket *from_socket = (bNodeSocket *)BLI_findlink(&from_node->outputs, from_index);
 
@@ -1294,7 +1296,6 @@ static bNodeSocket *bc_group_add_output_socket(bNodeTree *ntree, bNode *from_nod
   return newsock;
 }
 
-
 void bc_make_group(bContext *C, bNodeTree *ntree, std::map<std::string, bNode *> nmap)
 {
   bNode *gnode = node_group_make_from_selected(C, ntree, "ShaderNodeGroup", "ShaderNodeTree");
index 61b5e30..dfd5519 100644 (file)
@@ -181,9 +181,10 @@ inline bool bc_startswith(std::string const &value, std::string const &starting)
 }
 
 #if 0 /* UNUSED */
-inline bool bc_endswith(std::string const & value, std::string const & ending)
+inline bool bc_endswith(std::string const &value, std::string const &ending)
 {
-  if (ending.size() > value.size()) return false;
+  if (ending.size() > value.size())
+    return false;
   return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
 }
 #endif
index 018b166..6caaf22 100644 (file)
@@ -181,7 +181,7 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/)
      *                      Full frame
      */
 
-    int full_width  = rd->xsch * rd->size / 100;
+    int full_width = rd->xsch * rd->size / 100;
     int full_height = rd->ysch * rd->size / 100;
 
     dx = rd->border.xmin * full_width - (full_width - this->getWidth()) / 2.0f;
index 0ebb60c..e7f33cd 100644 (file)
@@ -119,7 +119,7 @@ void RenderLayersProg::executePixelSampled(float output[4], float x, float y, Pi
     /* see comment in executeRegion describing coordinate mapping,
      * here it simply goes other way around
      */
-    int full_width  = rd->xsch * rd->size / 100;
+    int full_width = rd->xsch * rd->size / 100;
     int full_height = rd->ysch * rd->size / 100;
 
     dx = rd->border.xmin * full_width - (full_width - this->getWidth()) / 2.0f;
index e77d7b1..79b4cb2 100644 (file)
@@ -413,7 +413,8 @@ void EEVEE_create_minmax_buffer(EEVEE_Data *vedata, GPUTexture *depth_src, int l
   GPU_framebuffer_texture_detach(stl->g_data->minzbuffer);
 
   /* Create lower levels */
-  GPU_framebuffer_recursive_downsample(fbl->downsample_fb, stl->g_data->minzbuffer, 8, &min_downsample_cb, vedata);
+  GPU_framebuffer_recursive_downsample(
+      fbl->downsample_fb, stl->g_data->minzbuffer, 8, &min_downsample_cb, vedata);
   DRW_stats_group_end();
 #endif
   int minmax_size[3], depth_size[3];
index 9268f2e..0557fd1 100644 (file)
@@ -115,15 +115,15 @@ static struct GPUTexture *create_ggx_lut_texture(int UNUSED(w), int UNUSED(h))
   static float samples_len = 8192.0f;
   static float inv_samples_len = 1.0f / 8192.0f;
 
-  char *lib_str = BLI_string_joinN(
-          datatoc_bsdf_common_lib_glsl,
-          datatoc_bsdf_sampling_lib_glsl);
+  char *lib_str = BLI_string_joinN(datatoc_bsdf_common_lib_glsl, datatoc_bsdf_sampling_lib_glsl);
 
-  struct GPUShader *sh = DRW_shader_create_with_lib(
-          datatoc_lightprobe_vert_glsl, datatoc_lightprobe_geom_glsl, datatoc_bsdf_lut_frag_glsl, lib_str,
-          "#define HAMMERSLEY_SIZE 8192\n"
-          "#define BRDF_LUT_SIZE 64\n"
-          "#define NOISE_SIZE 64\n");
+  struct GPUShader *sh = DRW_shader_create_with_lib(datatoc_lightprobe_vert_glsl,
+                                                    datatoc_lightprobe_geom_glsl,
+                                                    datatoc_bsdf_lut_frag_glsl,
+                                                    lib_str,
+                                                    "#define HAMMERSLEY_SIZE 8192\n"
+                                                    "#define BRDF_LUT_SIZE 64\n"
+                                                    "#define NOISE_SIZE 64\n");
 
   DRWPass *pass = DRW_pass_create("LightProbe Filtering", DRW_STATE_WRITE_COLOR);
   DRWShadingGroup *grp = DRW_shgroup_create(sh, pass);
@@ -150,11 +150,14 @@ static struct GPUTexture *create_ggx_lut_texture(int UNUSED(w), int UNUSED(h))
   glReadPixels(0, 0, w, h, GL_RGB, GL_FLOAT, data);
 
   printf("{");
-  for (int i = 0; i < w*h * 3; i+=3) {
-    printf("%ff, %ff, ", data[i],  data[i+1]); i+=3;
-    printf("%ff, %ff, ", data[i],  data[i+1]); i+=3;
-    printf("%ff, %ff, ", data[i],  data[i+1]); i+=3;
-    printf("%ff, %ff, \n", data[i],  data[i+1]);
+  for (int i = 0; i < w * h * 3; i += 3) {
+    printf("%ff, %ff, ", data[i], data[i + 1]);
+    i += 3;
+    printf("%ff, %ff, ", data[i], data[i + 1]);
+    i += 3;
+    printf("%ff, %ff, ", data[i], data[i + 1]);
+    i += 3;
+    printf("%ff, %ff, \n", data[i], data[i + 1]);
   }
   printf("}");
 
@@ -174,15 +177,13 @@ static struct GPUTexture *create_ggx_refraction_lut_texture(int w, int h)
   static float inv_samples_len = 1.0f / 8192.0f;
 
   char *frag_str = BLI_string_joinN(
-          datatoc_bsdf_common_lib_glsl,
-          datatoc_bsdf_sampling_lib_glsl,
-          datatoc_btdf_lut_frag_glsl);
+      datatoc_bsdf_common_lib_glsl, datatoc_bsdf_sampling_lib_glsl, datatoc_btdf_lut_frag_glsl);
 
   struct GPUShader *sh = DRW_shader_create_fullscreen(frag_str,
-          "#define HAMMERSLEY_SIZE 8192\n"
-          "#define BRDF_LUT_SIZE 64\n"
-          "#define NOISE_SIZE 64\n"
-          "#define LUT_SIZE 64\n");
+                                                      "#define HAMMERSLEY_SIZE 8192\n"
+                                                      "#define BRDF_LUT_SIZE 64\n"
+                                                      "#define NOISE_SIZE 64\n"
+                                                      "#define LUT_SIZE 64\n");
 
   MEM_freeN(frag_str);
 
@@ -222,20 +223,28 @@ static struct GPUTexture *create_ggx_refraction_lut_texture(int w, int h)
 
 #  if 1
     fprintf(f, "\t{\n\t\t");
-    for (int i = 0; i < w*h * 3; i+=3) {
+    for (int i = 0; i < w * h * 3; i += 3) {
       fprintf(f, "%ff,", data[i]);
-      if (((i/3)+1) % 12 == 0) fprintf(f, "\n\t\t");
-      else fprintf(f, " ");
+      if (((i / 3) + 1) % 12 == 0)
+        fprintf(f, "\n\t\t");
+      else
+        fprintf(f, " ");
     }
     fprintf(f, "\n\t},\n");
 #  else
-    for (int i = 0; i < w*h * 3; i+=3) {
-      if (data[i] < 0.01) printf(" ");
-      else if (data[i] < 0.3) printf(".");
-      else if (data[i] < 0.6) printf("+");
-      else if (data[i] < 0.9) printf("%%");
-      else printf("#");
-      if ((i/3+1) % 64 == 0) printf("\n");
+    for (int i = 0; i < w * h * 3; i += 3) {
+      if (data[i] < 0.01)
+        printf(" ");
+      else if (data[i] < 0.3)
+        printf(".");
+      else if (data[i] < 0.6)
+        printf("+");
+      else if (data[i] < 0.9)
+        printf("%%");
+      else
+        printf("#");
+      if ((i / 3 + 1) % 64 == 0)
+        printf("\n");
     }
 #  endif
 
index f2863d5..f8795a7 100644 (file)
@@ -165,11 +165,7 @@ int EEVEE_motion_blur_init(EEVEE_ViewLayerData *UNUSED(sldata), EEVEE_Data *veda
 #if 0 /* for future high quality blur */
           /* Future matrix */
           eevee_motion_blur_camera_get_matrix_at_time(
-                  scene,
-                  ar, rv3d, v3d,
-                  ob_camera_eval,
-                  ctime + delta,
-                  effects->future_world_to_ndc);
+              scene, ar, rv3d, v3d, ob_camera_eval, ctime + delta, effects->future_world_to_ndc);
 #endif
           invert_m4_m4(effects->current_ndc_to_world, effects->current_world_to_ndc);
         }
index 3e35f81..f55b744 100644 (file)
@@ -185,9 +185,12 @@ void workbench_dof_engine_init(WORKBENCH_Data *vedata, Object *camera)
   wpd->dof_blur_tx = DRW_texture_pool_query_2d(
       size[0], size[1], GPU_R11F_G11F_B10F, &draw_engine_workbench_solid);
 #if 0
-  wpd->coc_temp_tx     = DRW_texture_pool_query_2d(shrink_h_size[0], shrink_h_size[1], GPU_RG8, &draw_engine_workbench_solid);
-  wpd->coc_tiles_tx[0] = DRW_texture_pool_query_2d(shrink_w_size[0], shrink_w_size[1], GPU_RG8, &draw_engine_workbench_solid);
-  wpd->coc_tiles_tx[1] = DRW_texture_pool_query_2d(shrink_w_size[0], shrink_w_size[1], GPU_RG8, &draw_engine_workbench_solid);
+  wpd->coc_temp_tx = DRW_texture_pool_query_2d(
+      shrink_h_size[0], shrink_h_size[1], GPU_RG8, &draw_engine_workbench_solid);
+  wpd->coc_tiles_tx[0] = DRW_texture_pool_query_2d(
+      shrink_w_size[0], shrink_w_size[1], GPU_RG8, &draw_engine_workbench_solid);
+  wpd->coc_tiles_tx[1] = DRW_texture_pool_query_2d(
+      shrink_w_size[0], shrink_w_size[1], GPU_RG8, &draw_engine_workbench_solid);
 #endif
 
   GPU_framebuffer_ensure_config(&fbl->dof_downsample_fb,
@@ -197,18 +200,21 @@ void workbench_dof_engine_init(WORKBENCH_Data *vedata, Object *camera)
                                     GPU_ATTACHMENT_TEXTURE(txl->coc_halfres_tx),
                                 });
 #if 0
-  GPU_framebuffer_ensure_config(&fbl->dof_coc_tile_h_fb, {
-    GPU_ATTACHMENT_NONE,
-    GPU_ATTACHMENT_TEXTURE(wpd->coc_temp_tx),
-  });
-  GPU_framebuffer_ensure_config(&fbl->dof_coc_tile_v_fb, {
-    GPU_ATTACHMENT_NONE,
-    GPU_ATTACHMENT_TEXTURE(wpd->coc_tiles_tx[0]),
-  });
-  GPU_framebuffer_ensure_config(&fbl->dof_coc_dilate_fb, {
-    GPU_ATTACHMENT_NONE,
-    GPU_ATTACHMENT_TEXTURE(wpd->coc_tiles_tx[1]),
-  });
+  GPU_framebuffer_ensure_config(&fbl->dof_coc_tile_h_fb,
+                                {
+                                    GPU_ATTACHMENT_NONE,
+                                    GPU_ATTACHMENT_TEXTURE(wpd->coc_temp_tx),
+                                });
+  GPU_framebuffer_ensure_config(&fbl->dof_coc_tile_v_fb,
+                                {
+                                    GPU_ATTACHMENT_NONE,
+                                    GPU_ATTACHMENT_TEXTURE(wpd->coc_tiles_tx[0]),
+                                });
+  GPU_framebuffer_ensure_config(&fbl->dof_coc_dilate_fb,
+                                {
+                                    GPU_ATTACHMENT_NONE,
+                                    GPU_ATTACHMENT_TEXTURE(wpd->coc_tiles_tx[1]),
+                                });
 #endif
   GPU_framebuffer_ensure_config(&fbl->dof_blur1_fb,
                                 {
@@ -318,12 +324,14 @@ void workbench_dof_create_pass(WORKBENCH_Data *vedata,
   }
 #if 0
   {
-    DRWShadingGroup *grp = DRW_shgroup_create(e_data.effect_dof_flatten_h_sh, psl->dof_flatten_h_ps);
+    DRWShadingGroup *grp = DRW_shgroup_create(e_data.effect_dof_flatten_h_sh,
+                                              psl->dof_flatten_h_ps);
     DRW_shgroup_uniform_texture(grp, "inputCocTex", txl->coc_halfres_tx);
     DRW_shgroup_call_add(grp, quad, NULL);
   }
   {
-    DRWShadingGroup *grp = DRW_shgroup_create(e_data.effect_dof_flatten_v_sh, psl->dof_flatten_v_ps);
+    DRWShadingGroup *grp = DRW_shgroup_create(e_data.effect_dof_flatten_v_sh,
+                                              psl->dof_flatten_v_ps);
     DRW_shgroup_uniform_texture(grp, "inputCocTex", wpd->coc_temp_tx);
     DRW_shgroup_call_add(grp, quad, NULL);
   }
index 5c95a83..3fc83fe 100644 (file)
@@ -78,12 +78,12 @@ void studiolight_update_world(WORKBENCH_PrivateData *wpd,
   mul_v3_v3fl(wd->spherical_harmonics_coefs[0], sl->spherical_harmonics_coefs[0], M_1_PI);
   /* Swizzle to make shader code simpler. */
   for (int i = 0; i < 3; ++i) {
-    copy_v3_fl3(
-            wd->spherical_harmonics_coefs[i + 1],
-            -sl->spherical_harmonics_coefs[3][i],
-            sl->spherical_harmonics_coefs[2][i],
-            -sl->spherical_harmonics_coefs[1][i]);
-    mul_v3_fl(wd->spherical_harmonics_coefs[i + 1], M_1_PI * 1.5f); /* 1.5f is to improve the contrast a bit. */
+    copy_v3_fl3(wd->spherical_harmonics_coefs[i + 1],
+                -sl->spherical_harmonics_coefs[3][i],
+                sl->spherical_harmonics_coefs[2][i],
+                -sl->spherical_harmonics_coefs[1][i]);
+    mul_v3_fl(wd->spherical_harmonics_coefs[i + 1],
+              M_1_PI * 1.5f); /* 1.5f is to improve the contrast a bit. */
   }
 
   /* Precompute as much as we can. See shader code for derivation. */
index 74c8716..7099f6c 100644 (file)
@@ -161,9 +161,13 @@ static void UNUSED_FUNCTION(add_fancy_edge)(GPUVertBuf *vbo,
 }
 
 #if 0  /* UNUSED */
-static void add_lat_lon_vert(
-        GPUVertBuf *vbo, uint pos_id, uint nor_id,
-        uint *v_idx, const float rad, const float lat, const float lon)
+static void add_lat_lon_vert(GPUVertBuf *vbo,
+                             uint pos_id,
+                             uint nor_id,
+                             uint *v_idx,
+                             const float rad,
+                             const float lat,
+                             const float lon)
 {
   float pos[3], nor[3];
   nor[0] = sinf(lat) * cosf(lon);
@@ -178,8 +182,10 @@ static void add_lat_lon_vert(
 static GPUVertBuf *fill_arrows_vbo(const float scale)
 {
   /* Position Only 3D format */
-  static GPUVertFormat format = { 0 };
-  static struct { uint pos; } attr_id;
+  static GPUVertFormat format = {0};
+  static struct {
+    uint pos;
+  } attr_id;
   if (format.attr_len == 0) {
     attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
   }
@@ -2039,10 +2045,10 @@ static const float bone_octahedral_verts[6][3] = {
 static const float bone_octahedral_smooth_normals[6][3] = {
     {0.0f, -1.0f, 0.0f},
 #if 0 /* creates problems for outlines when scaled */
-  { 0.943608f * M_SQRT1_2, -0.331048f,  0.943608f * M_SQRT1_2},
-  0.943608f * M_SQRT1_2, -0.331048f, -0.943608f * M_SQRT1_2},
-  {-0.943608f * M_SQRT1_2, -0.331048f, -0.943608f * M_SQRT1_2},
-  {-0.943608f * M_SQRT1_2, -0.331048f,  0.943608f * M_SQRT1_2},
+    {0.943608f * M_SQRT1_2, -0.331048f, 0.943608f * M_SQRT1_2},
+    {0.943608f * M_SQRT1_2, -0.331048f, -0.943608f * M_SQRT1_2},
+    {-0.943608f * M_SQRT1_2, -0.331048f, -0.943608f * M_SQRT1_2},
+    {-0.943608f * M_SQRT1_2, -0.331048f, 0.943608f * M_SQRT1_2},
 #else
     {M_SQRT1_2, 0.0f, M_SQRT1_2},
     {M_SQRT1_2, 0.0f, -M_SQRT1_2},
@@ -2055,17 +2061,13 @@ static const float bone_octahedral_smooth_normals[6][3] = {
 #if 0 /* UNUSED */
 
 static const uint bone_octahedral_wire[24] = {
-  0, 1,  1, 5,  5, 3,  3, 0,
-  0, 4,  4, 5,  5, 2,  2, 0,
-  1, 2,  2, 3,  3, 4,  4, 1,
+    0, 1, 1, 5, 5, 3, 3, 0, 0, 4, 4, 5, 5, 2, 2, 0, 1, 2, 2, 3, 3, 4, 4, 1,
 };
 
 /* aligned with bone_octahedral_wire
  * Contains adjacent normal index */
 static const uint bone_octahedral_wire_adjacent_face[24] = {
-  0, 3,  4, 7,  5, 6,  1, 2,
-  2, 3,  6, 7,  4, 5,  0, 1,
-  0, 4,  1, 5,  2, 6,  3, 7,
+    0, 3, 4, 7, 5, 6, 1, 2, 2, 3, 6, 7, 4, 5, 0, 1, 0, 4, 1, 5, 2, 6, 3, 7,
 };
 #endif
 
@@ -2109,15 +2111,15 @@ static const uint bone_octahedral_wire_lines_adjacency[12][4] = {
 
 #if 0 /* UNUSED */
 static const uint bone_octahedral_solid_tris_adjacency[8][6] = {
-  { 0, 12,  1, 10,  2,  3},
-  { 3, 15,  4,  1,  5,  6},
-  { 6, 18,  7,  4,  8,  9},
-  { 9, 21, 10,  7, 11,  0},
-
-  {12, 22, 13,  2, 14, 17},
-  {15, 13, 16,  5, 17, 20},
-  {18, 16, 19,  8, 20, 23},
-  {21, 19, 22, 11, 23, 14},
+    {0, 12, 1, 10, 2, 3},
+    {3, 15, 4, 1, 5, 6},
+    {6, 18, 7, 4, 8, 9},
+    {9, 21, 10, 7, 11, 0},
+
+    {12, 22, 13, 2, 14, 17},
+    {15, 13, 16, 5, 17, 20},
+    {18, 16, 19, 8, 20, 23},
+    {21, 19, 22, 11, 23, 14},
 };
 #endif
 
@@ -2219,17 +2221,13 @@ static const float bone_box_smooth_normals[8][3] = {
 
 #if 0 /* UNUSED */
 static const uint bone_box_wire[24] = {
-  0, 1,  1, 2,  2, 3,  3, 0,
-  4, 5,  5, 6,  6, 7,  7, 4,
-  0, 4,  1, 5,  2, 6,  3, 7,
+    0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7,
 };
 
 /* aligned with bone_octahedral_wire
  * Contains adjacent normal index */
 static const uint bone_box_wire_adjacent_face[24] = {
-  0,  2,   0,  4,   1,  6,   1,  8,
-  3, 10,   5, 10,   7, 11,   9, 11,
-  3,  8,   2,  5,   4,  7,   6,  9,
+    0, 2, 0, 4, 1, 6, 1, 8, 3, 10, 5, 10, 7, 11, 9, 11, 3, 8, 2, 5, 4, 7, 6, 9,
 };
 #endif
 
@@ -2274,23 +2272,23 @@ static const uint bone_box_wire_lines_adjacency[12][4] = {
 
 #if 0 /* UNUSED */
 static const uint bone_box_solid_tris_adjacency[12][6] = {
-  { 0,  5,  1, 14,  2,  8},
-  { 3, 26,  4, 20,  5,  1},
+    {0, 5, 1, 14, 2, 8},
+    {3, 26, 4, 20, 5, 1},
 
-  { 6,  2,  7, 16,  8, 11},
-  { 9,  7, 10, 32, 11, 24},
+    {6, 2, 7, 16, 8, 11},
+    {9, 7, 10, 32, 11, 24},
 
-  {12,  0, 13, 22, 14, 17},
-  {15, 13, 16, 30, 17,  6},
+    {12, 0, 13, 22, 14, 17},
+    {15, 13, 16, 30, 17, 6},
 
-  {18,  3, 19, 28, 20, 23},
-  {21, 19, 22, 33, 23, 12},
+    {18, 3, 19, 28, 20, 23},
+    {21, 19, 22, 33, 23, 12},
 
-  {24,  4, 25, 10, 26, 29},
-  {27, 25, 28, 34, 29, 18},
+    {24, 4, 25, 10, 26, 29},
+    {27, 25, 28, 34, 29, 18},
 
-  {30,  9, 31, 15, 32, 35},
-  {33, 31, 34, 21, 35, 27},
+    {30, 9, 31, 15, 32, 35},
+    {33, 31, 34, 21, 35, 27},
 };
 #endif
 
@@ -2499,8 +2497,10 @@ GPUBatch *DRW_cache_bone_point_get(void)
     const float lat_inc = M_PI / lat_res;
     uint v_idx = 0;
 
-    static GPUVertFormat format = { 0 };
-    static struct { uint pos, nor; } attr_id;
+    static GPUVertFormat format = {0};
+    static struct {
+      uint pos, nor;
+    } attr_id;
     if (format.attr_len == 0) {
       attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
       attr_id.nor = GPU_vertformat_attr_add(&format, "nor", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
@@ -2515,15 +2515,17 @@ GPUBatch *DRW_cache_bone_point_get(void)
       float lat = 0.0f;
       for (int j = 0; j < lat_res; j++, lat += lat_inc) {
         if (j != lat_res - 1) { /* Pole */
-          add_lat_lon_vert(vbo, attr_id.pos, attr_id.nor, &v_idx, rad, lat + lat_inc, lon + lon_inc);
+          add_lat_lon_vert(
+              vbo, attr_id.pos, attr_id.nor, &v_idx, rad, lat + lat_inc, lon + lon_inc);
           add_lat_lon_vert(vbo, attr_id.pos, attr_id.nor, &v_idx, rad, lat + lat_inc, lon);
-          add_lat_lon_vert(vbo, attr_id.pos, attr_id.nor, &v_idx, rad, lat,           lon);
+          add_lat_lon_vert(vbo, attr_id.pos, attr_id.nor, &v_idx, rad, lat, lon);
         }
 
         if (j != 0) { /* Pole */
-          add_lat_lon_vert(vbo, attr_id.pos, attr_id.nor, &v_idx, rad, lat,           lon + lon_inc);
-          add_lat_lon_vert(vbo, attr_id.pos, attr_id.nor, &v_idx, rad, lat + lat_inc, lon + lon_inc);
-          add_lat_lon_vert(vbo, attr_id.pos, attr_id.nor, &v_idx, rad, lat,           lon);
+          add_lat_lon_vert(vbo, attr_id.pos, attr_id.nor, &v_idx, rad, lat, lon + lon_inc);
+          add_lat_lon_vert(
+              vbo, attr_id.pos, attr_id.nor, &v_idx, rad, lat + lat_inc, lon + lon_inc);
+          add_lat_lon_vert(vbo, attr_id.pos, attr_id.nor, &v_idx, rad, lat, lon);
         }
       }
     }
@@ -2755,10 +2757,14 @@ static float z_axis_name[10][2] = {
 #define S_Y 0.007f
 static float axis_marker[8][2] = {
 #if 0 /* square */
-  {-1.0f * S_X,  1.0f * S_Y}, { 1.0f * S_X,  1.0f * S_Y},
-  { 1.0f * S_X,  1.0f * S_Y}, { 1.0f * S_X, -1.0f * S_Y},
-  { 1.0f * S_X, -1.0f * S_Y}, {-1.0f * S_X, -1.0f * S_Y},
-  {-1.0f * S_X, -1.0f * S_Y}, {-1.0f * S_X,  1.0f * S_Y}
+    {-1.0f * S_X, 1.0f * S_Y},
+    {1.0f * S_X, 1.0f * S_Y},
+    {1.0f * S_X, 1.0f * S_Y},
+    {1.0f * S_X, -1.0f * S_Y},
+    {1.0f * S_X, -1.0f * S_Y},
+    {-1.0f * S_X, -1.0f * S_Y},
+    {-1.0f * S_X, -1.0f * S_Y},
+    {-1.0f * S_X, 1.0f * S_Y}
 #else /* diamond */
     {-S_X, 0.f},
     {0.f, S_Y},
index ded9d09..73c68d0 100644 (file)
@@ -3128,7 +3128,8 @@ static void mesh_create_loop_uv_and_tan(MeshRenderData *rdata, GPUVertBuf *vbo)
   for (uint i = 0; i < uv_len; i++) {
     const char *attr_name = mesh_render_data_uv_layer_uuid_get(rdata, i);
 #if 0 /* these are clamped. Maybe use them as an option in the future */
-    uv_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_I16, 2, GPU_FETCH_INT_TO_FLOAT_UNIT);
+    uv_id[i] = GPU_vertformat_attr_add(
+        &format, attr_name, GPU_COMP_I16, 2, GPU_FETCH_INT_TO_FLOAT_UNIT);
 #else
     uv_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
 #endif
@@ -4433,8 +4434,10 @@ BLI_INLINE void edit_uv_preprocess_stretch_angle(float (*auv)[2],
 }
 
 #if 0 /* here for reference, this is done in shader now. */
-BLI_INLINE float edit_uv_get_loop_stretch_angle(
-        const float auv0[2], const float auv1[2], const float av0[3], const float av1[3])
+BLI_INLINE float edit_uv_get_loop_stretch_angle(const float auv0[2],
+                                                const float auv1[2],
+                                                const float av0[3],
+                                                const float av1[3])
 {
   float uvang = angle_normalized_v2v2(auv0, auv1);
   float ang = angle_normalized_v3v3(av0, av1);
index db675ee..79c1d77 100644 (file)
@@ -498,7 +498,8 @@ static void draw_clipping_setup_from_view(void)
   /* Extract Clipping Planes */
   BoundBox bbox;
 #if 0 /* It has accuracy problems. */
-  BKE_boundbox_init_from_minmax(&bbox, (const float[3]){-1.0f, -1.0f, -1.0f}, (const float[3]){1.0f, 1.0f, 1.0f});
+  BKE_boundbox_init_from_minmax(
+      &bbox, (const float[3]){-1.0f, -1.0f, -1.0f}, (const float[3]){1.0f, 1.0f, 1.0f});
   for (int i = 0; i < 8; i++) {
     mul_project_m4_v3(projinv, bbox.vec[i]);
   }
index 78c17ac..a4fc022 100644 (file)
@@ -405,7 +405,9 @@ static bool acf_generic_idfill_name_prop(bAnimListElem *ale, PointerRNA *ptr, Pr
 
 #if 0
 /* channel type has no settings */
-static bool acf_generic_none_setting_valid(bAnimContext *ac, bAnimListElem *ale, eAnimChannel_Settings setting)
+static bool acf_generic_none_setting_valid(bAnimContext *ac,
+                                           bAnimListElem *ale,
+                                           eAnimChannel_Settings setting)
 {
   return false;
 }
@@ -4715,15 +4717,43 @@ void ANIM_channel_draw_widgets(const bContext *C,
       RNA_pointer_create(ale->id, &RNA_GPencilLayer, ale->data, &ptr);
 
       UI_block_align_begin(block);
-      UI_block_emboss_set(block, RNA_boolean_get(&ptr, "is_stroke_visible") ? UI_EMBOSS : UI_EMBOSS_NONE);
-      uiDefButR(block, UI_BTYPE_COLOR, 1, "", offset, yminc, w, ICON_WIDTH,
-                &ptr, "color", -1,
-                0, 0, 0, 0, gpl->info);
-
-      UI_block_emboss_set(block, RNA_boolean_get(&ptr, "is_fill_visible") ? UI_EMBOSS : UI_EMBOSS_NONE);
-      uiDefButR(block, UI_BTYPE_COLOR, 1, "", offset + w, yminc, w, ICON_WIDTH,
-                &ptr, "fill_color", -1,
-                0, 0, 0, 0, gpl->info);
+      UI_block_emboss_set(block,
+                          RNA_boolean_get(&ptr, "is_stroke_visible") ? UI_EMBOSS : UI_EMBOSS_NONE);
+      uiDefButR(block,
+                UI_BTYPE_COLOR,
+                1,
+                "",
+                offset,
+                yminc,
+                w,
+                ICON_WIDTH,
+                &ptr,
+                "color",
+                -1,
+                0,
+                0,
+                0,
+                0,
+                gpl->info);
+
+      UI_block_emboss_set(block,
+                          RNA_boolean_get(&ptr, "is_fill_visible") ? UI_EMBOSS : UI_EMBOSS_NONE);
+      uiDefButR(block,
+                UI_BTYPE_COLOR,
+                1,
+                "",
+                offset + w,
+                yminc,
+                w,
+                ICON_WIDTH,
+                &ptr,
+                "fill_color",
+                -1,
+                0,
+                0,
+                0,
+                0,
+                gpl->info);
       UI_block_emboss_set(block, UI_EMBOSS_NONE);
       UI_block_align_end(block);
 
index 53fec2e..df73c78 100644 (file)
@@ -408,7 +408,10 @@ void ANIM_animdata_update(bAnimContext *ac, ListBase *anim_data)
 #if 0
       if (G.debug & G_DEBUG) {
         printf("%s: Unhandled animchannel updates (%d) for type=%d (%p)\n",
-               __func__, ale->update, ale->type, ale->data);
+               __func__,
+               ale->update,
+               ale->type,
+               ale->data);
       }
 #endif
       /* Prevent crashes in cases where it can't be handled */
index 5028919..1afcfac 100644 (file)
@@ -610,7 +610,7 @@ static void armature_finalize_restpose(ListBase *bonelist, ListBase *editbonelis
         print_m4("premat", premat);
         print_m4("postmat", postmat);
         print_m4("difmat", difmat);
-        printf("Roll = %f\n",  RAD2DEGF(-atan2(difmat[2][0], difmat[2][2])));
+        printf("Roll = %f\n", RAD2DEGF(-atan2(difmat[2][0], difmat[2][2])));
 #endif
 
         curBone->roll = -atan2f(difmat[2][0], difmat[2][2]);
index febe2a4..a9f8925 100644 (file)
@@ -1476,7 +1476,10 @@ static void meshdeform_matrix_solve(MeshDeformModifierData *mmd, MeshDeformBind
     if (mdb->tag[b] != MESHDEFORM_TAG_EXTERIOR)
       if (fabsf(mdb->totalphi[b] - 1.0f) > 1e-4f)
         printf("totalphi deficiency [%s|%d] %d: %.10f\n",
-               (mdb->tag[b] == MESHDEFORM_TAG_INTERIOR) ? "interior" : "boundary", mdb->semibound[b], mdb->varidx[b], mdb->totalphi[b]);
+               (mdb->tag[b] == MESHDEFORM_TAG_INTERIOR) ? "interior" : "boundary",
+               mdb->semibound[b],
+               mdb->varidx[b],
+               mdb->totalphi[b]);
 #endif
 
   /* free */
index 5164104..599823a 100644 (file)
@@ -167,7 +167,8 @@ static bool pose_has_protected_selected(Object *ob, short warn)
       }
     }
     if (pchan) {
-      if (warn) error("Cannot change Proxy protected bones");
+      if (warn)
+        error("Cannot change Proxy protected bones");
       return 1;
     }
   }
index 443bcdd..ce809be 100644 (file)
@@ -1834,9 +1834,15 @@ void POSELIB_OT_browse_interactive(wmOperatorType *ot)
   // XXX: percentage vs factor?
   /* not used yet */
 #if 0
-  RNA_def_float_factor(
-          ot->srna, "blend_factor", 1.0f, 0.0f, 1.0f, "Blend Factor",
-          "Amount that the pose is applied on top of the existing poses", 0.0f, 1.0f);
+  RNA_def_float_factor(ot->srna,
+                       "blend_factor",
+                       1.0f,
+                       0.0f,
+                       1.0f,
+                       "Blend Factor",
+                       "Amount that the pose is applied on top of the existing poses",
+                       0.0f,
+                       1.0f);
 #endif
 }
 
index c37ce4c..17582da 100644 (file)
@@ -104,11 +104,13 @@ void printknots(Object *obedit)
     if (ED_curve_nurb_select_check(nu) && nu->type == CU_NURBS) {
       if (nu->knotsu) {
         num = KNOTSU(nu);
-        for (a = 0; a < num; a++) printf("knotu %d: %f\n", a, nu->knotsu[a]);
+        for (a = 0; a < num; a++)
+          printf("knotu %d: %f\n", a, nu->knotsu[a]);
       }
       if (nu->knotsv) {
         num = KNOTSV(nu);
-        for (a = 0; a < num; a++) printf("knotv %d: %f\n", a, nu->knotsv[a]);
+        for (a = 0; a < num; a++)
+          printf("knotv %d: %f\n", a, nu->knotsv[a]);
       }
     }
   }
index 3273012..441ebac 100644 (file)
@@ -338,10 +338,10 @@ static void gizmo_cage3d_draw_intern(
   else {
 #if 0
     const rctf _r = {
-      .xmin = -size_real[0],
-      .ymin = -size_real[1],
-      .xmax = size_real[0],
-      .ymax = size_real[1],
+        .xmin = -size_real[0],
+        .ymin = -size_real[1],
+        .xmax = size_real[0],
+        .ymax = size_real[1],
     };
 #endif
     if (draw_style == ED_GIZMO_CAGE2D_STYLE_BOX) {
index 4933f08..b64bccd 100644 (file)
@@ -2429,7 +2429,9 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
       /* event doesn't need to be handled */
 #if 0
       printf("unhandled event -> %d (mmb? = %d | mmv? = %d)\n",
-             event->type, event->type == MIDDLEMOUSE, event->type==MOUSEMOVE);
+             event->type,
+             event->type == MIDDLEMOUSE,
+             event->type == MOUSEMOVE);
 #endif
       break;
   }
index 24bdbcc..2caaf7f 100644 (file)
@@ -375,7 +375,7 @@ static int gp_set_filling_texture(Image *image, short flag)
   ImBuf *ibuf;
   uint *bind = &image->bindcode[TEXTARGET_TEXTURE_2D];
   int error = GL_NO_ERROR;
-  ImageUser iuser = { NULL };
+  ImageUser iuser = {NULL};
   void *lock;
 
   iuser.ok = true;
@@ -388,8 +388,7 @@ static int gp_set_filling_texture(Image *image, short flag)
   }
 
   GPU_create_gl_tex(
-          bind, ibuf->rect, ibuf->rect_float, ibuf->x, ibuf->y, GL_TEXTURE_2D,
-          false, false, image);
+      bind, ibuf->rect, ibuf->rect_float, ibuf->x, ibuf->y, GL_TEXTURE_2D, false, false, image);
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@@ -452,7 +451,8 @@ static void gp_draw_stroke_fill(bGPdata *gpd,
   immUniform1i("t_flip", (gp_style->flag & GP_STYLE_COLOR_FLIP_FILL) != 0);
 #if 0 /* GPXX disabled, not used in annotations */
   /* image texture */
-  if ((gp_style->fill_style == GP_STYLE_FILL_STYLE_TEXTURE) || (gp_style->flag & GP_STYLE_COLOR_TEX_MIX)) {
+  if ((gp_style->fill_style == GP_STYLE_FILL_STYLE_TEXTURE) ||
+      (gp_style->flag & GP_STYLE_COLOR_TEX_MIX)) {
     gp_set_filling_texture(gp_style->ima, gp_style->flag);
   }
 #endif
index bfdfe64..a12e9a3 100644 (file)
@@ -3748,7 +3748,9 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
       /* event doesn't need to be handled */
 #if 0
       printf("unhandled event -> %d (mmb? = %d | mmv? = %d)\n",
-             event->type, event->type == MIDDLEMOUSE, event->type == MOUSEMOVE);
+             event->type,
+             event->type == MIDDLEMOUSE,
+             event->type == MOUSEMOVE);
 #endif
       break;
   }
index e747dda..fe7ccb7 100644 (file)
@@ -707,7 +707,10 @@ void ED_scene_draw_fps(struct Scene *scene, int xoffset, int *yoffset);
 #if 0
 void ED_view3d_operator_properties_viewmat(struct wmOperatorType *ot);
 void ED_view3d_operator_properties_viewmat_set(struct bContext *C, struct wmOperator *op);
-void ED_view3d_operator_properties_viewmat_get(struct wmOperator *op, int *winx, int *winy, float persmat[4][4]);
+void ED_view3d_operator_properties_viewmat_get(struct wmOperator *op,
+                                               int *winx,
+                                               int *winy,
+                                               float persmat[4][4]);
 #endif
 
 /* render */
index d3cce4a..dd08646 100644 (file)
@@ -416,8 +416,16 @@ void UI_draw_roundbox_shade_x(bool filled,
                               const float col[4]);
 
 #if 0 /* unused */
-int  UI_draw_roundbox_corner_get(void);
-void UI_draw_roundbox_shade_y(bool filled, float minx, float miny, float maxx, float maxy, float rad, float shadeleft, float shaderight, const float col[4]);
+int UI_draw_roundbox_corner_get(void);
+void UI_draw_roundbox_shade_y(bool filled,
+                              float minx,
+                              float miny,
+                              float maxx,
+                              float maxy,
+                              float rad,
+                              float shadeleft,
+                              float shaderight,
+                              const float col[4]);
 #endif
 
 void UI_draw_box_shadow(unsigned char alpha, float minx, float miny, float maxx, float maxy);
@@ -587,7 +595,10 @@ void UI_popup_block_ex(struct bContext *C,
                        void *arg,
                        struct wmOperator *op);
 #if 0 /* UNUSED */
-void uiPupBlockOperator(struct bContext *C, uiBlockCreateFunc func, struct wmOperator *op, int opcontext);
+void uiPupBlockOperator(struct bContext *C,
+                        uiBlockCreateFunc func,
+                        struct wmOperator *op,
+                        int opcontext);
 #endif
 
 void UI_popup_block_close(struct bContext *C, struct wmWindow *win, uiBlock *block);
index 06b0634..a9079cd 100644 (file)
@@ -1274,7 +1274,8 @@ static bool ui_but_event_property_operator_string(const bContext *C,
 #if 0
           else {
             printf("ERROR in %s(): Couldn't get path for scene property - %s\n",
-                   __func__, RNA_property_identifier(prop));
+                   __func__,
+                   RNA_property_identifier(prop));
           }
 #endif
         }
index afa1b5c..c8800f4 100644 (file)
@@ -655,12 +655,16 @@ bool ui_popup_context_menu_for_button(bContext *C, uiBut *but)
 #if 0 /* Disabled for now. */
           ot = WM_operatortype_find("UI_OT_override_type_set_button", false);
           uiItemFullO_ptr(
-                  layout, ot, "Overrides Type", ICON_NONE,
-                  NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
+              layout, ot, "Overrides Type", ICON_NONE, NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
           RNA_boolean_set(&op_ptr, "all", true);
-          uiItemFullO_ptr(
-                  layout, ot, "Single Override Type", ICON_NONE,
-                  NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
+          uiItemFullO_ptr(layout,
+                          ot,
+                          "Single Override Type",
+                          ICON_NONE,
+                          NULL,
+                          WM_OP_INVOKE_DEFAULT,
+                          0,
+                          &op_ptr);
           RNA_boolean_set(&op_ptr, "all", false);
 #endif
           uiItemBooleanO(layout,
@@ -678,9 +682,14 @@ bool ui_popup_context_menu_for_button(bContext *C, uiBut *but)
         }
         else {
 #if 0 /* Disabled for now. */
-          uiItemFullO(
-                  layout, "UI_OT_override_type_set_button", "Override Type", ICON_NONE,
-                  NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
+          uiItemFullO(layout,
+                      "UI_OT_override_type_set_button",
+                      "Override Type",
+                      ICON_NONE,
+                      NULL,
+                      WM_OP_INVOKE_DEFAULT,
+                      0,
+                      &op_ptr);
           RNA_boolean_set(&op_ptr, "all", false);
 #endif
           uiItemBooleanO(layout,
@@ -896,9 +905,15 @@ bool ui_popup_context_menu_for_button(bContext *C, uiBut *but)
     if (kmi) {
       if (ISKEYBOARD(kmi->type)) {
 #if 0 /* would rather use a block but, but gets weirdly positioned... */
-        uiDefBlockBut(
-                block, menu_change_shortcut, but, "Change Shortcut",
-                0, 0, uiLayoutGetWidth(layout), UI_UNIT_Y, "");
+        uiDefBlockBut(block,
+                      menu_change_shortcut,
+                      but,
+                      "Change Shortcut",
+                      0,
+                      0,
+                      uiLayoutGetWidth(layout),
+                      UI_UNIT_Y,
+                      "");
 #endif
 
         but2 = uiDefIconTextBut(block,
@@ -1005,9 +1020,14 @@ bool ui_popup_context_menu_for_button(bContext *C, uiBut *but)
 
       /* XXX inactive option, not for public! */
 #if 0
-      uiItemFullO(
-              layout, "WM_OT_doc_edit", "Submit Description", ICON_NONE,
-              NULL, WM_OP_INVOKE_DEFAULT, 0, &ptr_props);
+      uiItemFullO(layout,
+                  "WM_OT_doc_edit",
+                  "Submit Description",
+                  ICON_NONE,
+                  NULL,
+                  WM_OP_INVOKE_DEFAULT,
+                  0,
+                  &ptr_props);
       RNA_string_set(&ptr_props, "doc_id", buf);
       RNA_string_set(&ptr_props, "doc_new", RNA_property_description(but->rnaprop));
 #endif
index 0517278..efc748d 100644 (file)
@@ -167,8 +167,13 @@ void UI_draw_roundbox_4fv(
 {
 #if 0
   float vec[7][2] = {
-    {0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},
-    {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805},
+      {0.195, 0.02},
+      {0.383, 0.067},
+      {0.55, 0.169},
+      {0.707, 0.293},
+      {0.831, 0.45},
+      {0.924, 0.617},
+      {0.98, 0.805},
   };
   int a;
 
@@ -270,13 +275,16 @@ void UI_draw_roundbox_4fv(
 }
 
 #if 0
-static void round_box_shade_col(uint attr, const float col1[3], float const col2[3], const float fac)
+static void round_box_shade_col(uint attr,
+                                const float col1[3],
+                                float const col2[3],
+                                const float fac)
 {
   float col[4] = {
-    fac * col1[0] + (1.0f - fac) * col2[0],
-    fac * col1[1] + (1.0f - fac) * col2[1],
-    fac * col1[2] + (1.0f - fac) * col2[2],
-    1.0f,
+      fac * col1[0] + (1.0f - fac) * col2[0],
+      fac * col1[1] + (1.0f - fac) * col2[1],
+      fac * col1[2] + (1.0f - fac) * col2[2],
+      1.0f,
   };
   immAttr4fv(attr, col);
 }
@@ -296,8 +304,13 @@ void UI_draw_roundbox_shade_x(bool filled,
 {
 #if 0
   float vec[7][2] = {
-    {0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},
-    {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805},
+      {0.195, 0.02},
+      {0.383, 0.067},
+      {0.55, 0.169},
+      {0.707, 0.293},
+      {0.831, 0.45},
+      {0.924, 0.617},
+      {0.98, 0.805},
   };
   const float div = maxy - miny;
   const float idiv = 1.0f / div;
@@ -317,9 +330,9 @@ void UI_draw_roundbox_shade_x(bool filled,
   }
 
   /* 'shade' defines strength of shading */
-  coltop[0]  = min_ff(1.0f, col[0] + shadetop);
-  coltop[1]  = min_ff(1.0f, col[1] + shadetop);
-  coltop[2]  = min_ff(1.0f, col[2] + shadetop);
+  coltop[0] = min_ff(1.0f, col[0] + shadetop);
+  coltop[1] = min_ff(1.0f, col[1] + shadetop);
+  coltop[2] = min_ff(1.0f, col[2] + shadetop);
   coldown[0] = max_ff(0.0f, col[0] + shadedown);
   coldown[1] = max_ff(0.0f, col[1] + shadedown);
   coldown[2] = max_ff(0.0f, col[2] + shadedown);
@@ -440,13 +453,24 @@ void UI_draw_roundbox_shade_x(bool filled,
 #if 0  /* unused */
 /* linear vertical shade within button or in outline */
 /* view2d scrollers use it */
-void UI_draw_roundbox_shade_y(
-        bool filled, float minx, float miny, float maxx, float maxy,
-        float rad, float shadeleft, float shaderight, const float col[4])
+void UI_draw_roundbox_shade_y(bool filled,
+                              float minx,
+                              float miny,
+                              float maxx,
+                              float maxy,
+                              float rad,
+                              float shadeleft,
+                              float shaderight,
+                              const float col[4])
 {
   float vec[7][2] = {
-    {0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},
-    {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805},
+      {0.195, 0.02},
+      {0.383, 0.067},
+      {0.55, 0.169},
+      {0.707, 0.293},
+      {0.831, 0.45},
+      {0.924, 0.617},
+      {0.98, 0.805},
   };
   const float div = maxx - minx;
   const float idiv = 1.0f / div;
@@ -466,14 +490,13 @@ void UI_draw_roundbox_shade_y(
   immBindBuiltinProgram(GPU_SHADER_2D_SMOOTH_COLOR);
 
   /* 'shade' defines strength of shading */
-  colLeft[0]  = min_ff(1.0f, col[0] + shadeleft);
-  colLeft[1]  = min_ff(1.0f, col[1] + shadeleft);
-  colLeft[2]  = min_ff(1.0f, col[2] + shadeleft);
+  colLeft[0] = min_ff(1.0f, col[0] + shadeleft);
+  colLeft[1] = min_ff(1.0f, col[1] + shadeleft);
+  colLeft[2] = min_ff(1.0f, col[2] + shadeleft);
   colRight[0] = max_ff(0.0f, col[0] + shaderight);
   colRight[1] = max_ff(0.0f, col[1] + shaderight);
   colRight[2] = max_ff(0.0f, col[2] + shaderight);
 
-
   vert_count += (roundboxtype & UI_CNR_BOTTOM_RIGHT) ? 9 : 1;
   vert_count += (roundboxtype & UI_CNR_TOP_RIGHT) ? 9 : 1;
   vert_count += (roundboxtype & UI_CNR_TOP_LEFT) ? 9 : 1;
@@ -2461,7 +2484,8 @@ void ui_draw_dropshadow(
     /* alpha ranges from 2 to 20 or so */
 #if 0 /* Old Method (pre 2.8) */
     float color[4] = {0.0f, 0.0f, 0.0f, calpha};
-    UI_draw_roundbox_4fv(true, rct->xmin - a, rct->ymin - a, rct->xmax + a, rct->ymax - 10.0f + a, rad + a, color);
+    UI_draw_roundbox_4fv(
+        true, rct->xmin - a, rct->ymin - a, rct->xmax + a, rct->ymax - 10.0f + a, rad + a, color);
 #endif
     /* Compute final visibility to match old method result. */
     /* TODO we could just find a better fit function inside the shader instead of this. */
index 8e463bf..9b54192 100644 (file)
@@ -112,7 +112,7 @@ typedef enum uiItemType {
 
   ITEM_LAYOUT_ROOT
 #if 0
-  TEMPLATE_COLUMN_FLOW,
+      TEMPLATE_COLUMN_FLOW,
   TEMPLATE_SPLIT,
   TEMPLATE_BOX,
 
@@ -1538,7 +1538,8 @@ void uiItemsFullEnumO(uiLayout *layout,
        * introduction of GP editing modes)
        */
 #if 0
-      RNA_property_enum_items_gettexted_all(block->evil_C, &ptr, prop, &item_array, &totitem, &free);
+      RNA_property_enum_items_gettexted_all(
+          block->evil_C, &ptr, prop, &item_array, &totitem, &free);
 #else
       RNA_property_enum_items_gettexted(block->evil_C, &ptr, prop, &item_array, &totitem, &free);
 #endif
index 6666991..7e6b58b 100644 (file)
@@ -2354,8 +2354,14 @@ void uiTemplateOperatorRedoProperties(uiLayout *layout, const bContext *C)
   /* Disable for now, doesn't fit well in popover. */
 #if 0
   /* Repeat button with operator name as text. */
-  uiItemFullO(layout, "SCREEN_OT_repeat_last", RNA_struct_ui_name(op->type->srna),
-              ICON_NONE, NULL, WM_OP_INVOKE_DEFAULT, 0, NULL);
+  uiItemFullO(layout,
+              "SCREEN_OT_repeat_last",
+              RNA_struct_ui_name(op->type->srna),
+              ICON_NONE,
+              NULL,
+              WM_OP_INVOKE_DEFAULT,
+              0,
+              NULL);
 #endif
 
   if (WM_operator_repeat_check(C, op)) {
index 9ee2e8b..166201a 100644 (file)
@@ -102,8 +102,7 @@ static int validate_undoLatt(void *data, void *edata)
   UndoLattice *ult = (UndoLattice *)data;
   EditLatt *editlatt = (EditLatt *)edata;
 
-  return (ult->pntsu == editlatt->latt->pntsu &&
-          ult->pntsv == editlatt->latt->pntsv &&
+  return (ult->pntsu == editlatt->latt->pntsu && ult->pntsv == editlatt->latt->pntsv &&
           ult->pntsw == editlatt->latt->pntsw);
 }
 #endif
index 42521d0..a341b51 100644 (file)
@@ -86,8 +86,7 @@ static float edbm_rip_edgedist_squared(ARegion *ar,
 
 #if 0
 static float edbm_rip_linedist(
-        ARegion *ar, float mat[4][4],
-        const float co1[3], const float co2[3], const float mvalf[2])
+    ARegion *ar, float mat[4][4], const float co1[3], const float co2[3], const float mvalf[2])
 {
   float vec1[2], vec2[2];
 
index 9488626..69066ad 100644 (file)
@@ -1173,9 +1173,7 @@ bool EDBM_unified_findnearest_from_raycast(ViewContext *vc,
               float point[3];
 #if 0
               const float dist_sq_test = dist_squared_ray_to_seg_v3(
-                      ray_origin, ray_direction,
-                      e->v1->co,  e->v2->co,
-                      point, &depth);
+                  ray_origin, ray_direction, e->v1->co, e->v2->co, point, &depth);
 #else
               if (coords) {
                 mid_v3_v3v3(
@@ -1801,7 +1799,8 @@ static bool mouse_mesh_loop(
         length_2 = len_squared_v2v2(mvalf, v2_co);
       }
 #if 0
-      printf("mouse to v1: %f\nmouse to v2: %f\n", len_squared_v2v2(mvalf, v1_co),
+      printf("mouse to v1: %f\nmouse to v2: %f\n",
+             len_squared_v2v2(mvalf, v1_co),
              len_squared_v2v2(mvalf, v2_co));
 #endif
       BM_select_history_store(em->bm, (length_1 < length_2) ? eed->v1 : eed->v2);
index 1cb550f..7d318fb 100644 (file)
@@ -363,10 +363,8 @@ void EDBM_mesh_load(Main *bmain, Object *ob)
    * cycles.
    */
 #if 0
-  for (Object *other_object = bmain->objects.first;
-       other_object != NULL;
-       other_object = other_object->id.next)
-  {
+  for (Object *other_object = bmain->objects.first; other_object != NULL;
+       other_object = other_object->id.next) {
     if (other_object->data == ob->data) {
       BKE_object_free_derived_caches(other_object);
     }
index ce7908b..8cc23ed 100644 (file)
@@ -900,17 +900,15 @@ int ED_mesh_mirror_get_vert(Object *ob, int index)
 
 #if 0
 
-static float *editmesh_get_mirror_uv(BMEditMesh *em, int axis, float *uv, float *mirrCent, float *face_cent)
+static float *editmesh_get_mirror_uv(
+    BMEditMesh *em, int axis, float *uv, float *mirrCent, float *face_cent)
 {
   float vec[2];
   float cent_vec[2];
   float cent[2];
 
   /* ignore nan verts */
-  if (isnan(uv[0]) || !isfinite(uv[0]) ||
-      isnan(uv[1]) || !isfinite(uv[1])
-      )
-  {
+  if (isnan(uv[0]) || !isfinite(uv[0]) || isnan(uv[1]) || !isfinite(uv[1])) {
     return NULL;
   }
 
@@ -937,15 +935,14 @@ static float *editmesh_get_mirror_uv(BMEditMesh *em, int axis, float *uv, float
     BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
       uv_poly_center(efa, cent, cd_loop_uv_offset);
 
-      if ( (fabsf(cent[0] - cent_vec[0]) < 0.001f) && (fabsf(cent[1] - cent_vec[1]) < 0.001f) ) {
+      if ((fabsf(cent[0] - cent_vec[0]) < 0.001f) && (fabsf(cent[1] - cent_vec[1]) < 0.001f)) {
         BMIter liter;
         BMLoop *l;
 
         BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
           MLoopUV *luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
-          if ( (fabsf(luv->uv[0] - vec[0]) < 0.001f) && (fabsf(luv->uv[1] - vec[1]) < 0.001f) ) {
+          if ((fabsf(luv->uv[0] - vec[0]) < 0.001f) && (fabsf(luv->uv[1] - vec[1]) < 0.001f)) {
             return luv->uv;
-
           }
         }
       }
index 57c7ff1..986055d 100644 (file)
@@ -65,11 +65,11 @@ static const EnumPropertyItem DT_layer_items[] = {
      "Vertex Group(s)",
      "Transfer active or all vertex groups"},
 #if 0 /* XXX For now, would like to finish/merge work from 2014 gsoc first. */
-  {DT_TYPE_SHAPEKEY, "SHAPEKEYS", 0, "Shapekey(s)", "Transfer active or all shape keys"},
+    {DT_TYPE_SHAPEKEY, "SHAPEKEYS", 0, "Shapekey(s)", "Transfer active or all shape keys"},
 #endif
 #if 0 /* XXX When SkinModifier is enabled,
         * it seems to erase its own CD_MVERT_SKIN layer from final DM :( */
-  {DT_TYPE_SKIN, "SKIN", 0, "Skin Weight", "Transfer skin weights"},
+    {DT_TYPE_SKIN, "SKIN", 0, "Skin Weight", "Transfer skin weights"},
 #endif
     {DT_TYPE_BWEIGHT_VERT, "BEVEL_WEIGHT_VERT", 0, "Bevel Weight", "Transfer bevel weights"},
     {0, "", 0, "Edge Data", ""},
index 3744632..63cacc2 100644 (file)
@@ -1339,11 +1339,13 @@ void OBJECT_OT_track_set(wmOperatorType *ot)
 #if 0
 static void link_to_scene(Main *UNUSED(bmain), unsigned short UNUSED(nr))
 {
-  Scene *sce = (Scene *) BLI_findlink(&bmain->scene, G.curscreen->scenenr - 1);
+  Scene *sce = (Scene *)BLI_findlink(&bmain->scene, G.curscreen->scenenr - 1);
   Base *base, *nbase;
 
-  if (sce == NULL) return;
-  if (sce->id.lib) return;
+  if (sce == NULL)
+    return;
+  if (sce->id.lib)
+    return;
 
   for (base = FIRSTBASE; base; base = base->next) {
     if (BASE_SELECTED(v3d, base)) {
index 627ffd6..d592bbd 100644 (file)
@@ -510,9 +510,11 @@ static bool key_test_depth(const PEData *data, const float co[3], const int scre
 
     /* used to calculate here but all callers have  the screen_co already, so pass as arg */
 #if 0
-  if (ED_view3d_project_int_global(data->vc.ar, co, screen_co,
-                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN | V3D_PROJ_TEST_CLIP_NEAR) != V3D_PROJ_RET_OK)
-  {
+  if (ED_view3d_project_int_global(data->vc.ar,
+                                   co,
+                                   screen_co,
+                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN |
+                                       V3D_PROJ_TEST_CLIP_NEAR) != V3D_PROJ_RET_OK) {
     return 0;
   }
 #endif
index c62d653..9b31b63 100644 (file)
@@ -1241,7 +1241,7 @@ static void icon_preview_endjob(void *customdata)
         if (prv_img->gputexture[i]) {
           GPU_texture_free(prv_img->gputexture[i]);
           prv_img->gputexture[i] = NULL;
-          WM_main_add_notifier(NC_MATERIAL|ND_SHADING_DRAW, ip->id);
+          WM_main_add_notifier(NC_MATERIAL | ND_SHADING_DRAW, ip->id);
         }
       }
     }
index 4ca26d1..ce952b5 100644 (file)
@@ -530,8 +530,11 @@ void ED_region_do_draw(bContext *C, ARegion *ar)
   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
   immUniformColor4f(drand48(), drand48(), drand48(), 0.1f);
-  immRectf(pos, ar->drawrct.xmin - ar->winrct.xmin, ar->drawrct.ymin - ar->winrct.ymin,
-          ar->drawrct.xmax - ar->winrct.xmin, ar->drawrct.ymax - ar->winrct.ymin);
+  immRectf(pos,
+           ar->drawrct.xmin - ar->winrct.xmin,
+           ar->drawrct.ymin - ar->winrct.ymin,
+           ar->drawrct.xmax - ar->winrct.xmin,
+           ar->drawrct.ymax - ar->winrct.ymin);
   immUnbindProgram();
   GPU_blend(false);
 #endif
index 94b5f69..f059659 100644 (file)
@@ -3660,8 +3660,10 @@ static int region_quadview_exec(bContext *C, wmOperator *op)
                                 RV3D_ORTHO);
       /* forcing camera is distracting */
 #if 0
-      if (v3d->camera) region_quadview_init_rv3d(sa, (ar = ar->next), 0, RV3D_VIEW_CAMERA, RV3D_CAMOB);
-      else             region_quadview_init_rv3d(sa, (ar = ar->next), 0, RV3D_VIEW_USER,   RV3D_PERSP);
+      if (v3d->camera)
+        region_quadview_init_rv3d(sa, (ar = ar->next), 0, RV3D_VIEW_CAMERA, RV3D_CAMOB);
+      else
+        region_quadview_init_rv3d(sa, (ar = ar->next), 0, RV3D_VIEW_USER, RV3D_PERSP);
 #else
       (void)v3d;
 #endif
index 5750a1f..ce64bdc 100644 (file)
@@ -89,8 +89,7 @@ static void workspace_change_update(WorkSpace *workspace_new,
   /* needs to be done before changing mode! (to ensure right context) */
   UNUSED_VARS(workspace_old, workspace_new, C, wm);
 #if 0
-  Object *ob_act = CTX_data_active_object(C)
-  eObjectMode mode_old = workspace_old->object_mode;
+  Object *ob_act = CTX_data_active_object(C) eObjectMode mode_old = workspace_old->object_mode;
   eObjectMode mode_new = workspace_new->object_mode;
 
   if (mode_old != mode_new) {
index 3a3f433..4c978f5 100644 (file)
@@ -632,9 +632,15 @@ static void paint_stroke_done(const bContext *C, struct PaintStroke *stroke)
   /* duplicate warning, see texpaint_init */
 #if 0
   if (pop->s.warnmultifile)
-    BKE_reportf(op->reports, RPT_WARNING, "Image requires 4 color channels to paint: %s", pop->s.warnmultifile);
+    BKE_reportf(op->reports,
+                RPT_WARNING,
+                "Image requires 4 color channels to paint: %s",
+                pop->s.warnmultifile);
   if (pop->s.warnpackedfile)
-    BKE_reportf(op->reports, RPT_WARNING, "Packed MultiLayer files cannot be painted: %s", pop->s.warnpackedfile);
+    BKE_reportf(op->reports,
+                RPT_WARNING,
+                "Packed MultiLayer files cannot be painted: %s",
+                pop->s.warnpackedfile);
 #endif
   MEM_freeN(pop);
 }
index 7a99f81..7f88878 100644 (file)
@@ -2351,8 +2351,10 @@ static float angle_2d_clockwise(const float p1[2], const float p2[2], const floa
 {
   float v1[2], v2[2];
 
-  v1[0] = p1[0] - p2[0];    v1[1] = p1[1] - p2[1];
-  v2[0] = p3[0] - p2[0];    v2[1] = p3[1] - p2[1];
+  v1[0] = p1[0] - p2[0];
+  v1[1] = p1[1] - p2[1];
+  v2[0] = p3[0] - p2[0];
+  v2[1] = p3[1] - p2[1];
 
   return -atan2f(v1[0] * v2[1] - v1[1] * v2[0], v1[0] * v2[0] + v1[1] * v2[1]);
 }
@@ -3035,8 +3037,7 @@ static void project_paint_face_init(const ProjPaintState *ps,
     if (pixel_bounds_array(uv_clip, &bounds_px, ibuf->x, ibuf->y, uv_clip_tot)) {
 #if 0
       project_paint_undo_tiles_init(
-              &bounds_px, ps->projImages + image_index, tmpibuf,
-              tile_width, threaded, ps->do_masking);
+          &bounds_px, ps->projImages + image_index, tmpibuf, tile_width, threaded, ps->do_masking);
 #endif
       /* clip face and */
 
index 68abdfb..b80144a 100644 (file)
@@ -417,7 +417,8 @@ static void paint_undosys_step_decode_restore_ids(ImageUndoStep *us)
 {
   ID *image_prev[2] = {NULL};
   for (UndoImageTile *tile = us->tiles.first; tile; tile = tile->next) {
-    tile->ima = (Image *)BKE_undosys_ID_map_lookup_with_prev(us->id_map, &tile->ima->id, image_prev);
+    tile->ima = (Image *)BKE_undosys_ID_map_lookup_with_prev(
+        us->id_map, &tile->ima->id, image_prev);
   }
 }
 #endif
index 4a586f4..8c1ba21 100644 (file)
@@ -479,8 +479,7 @@ static void paint_brush_stroke_add_step(bContext *C,
   if (tablet && (pressure >= 0.99f) &&
       ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) ||
        BKE_brush_use_alpha_pressure(scene, pop->s.brush) ||
-       BKE_brush_use_size_pressure(scene, pop->s.brush)))
-  {
+       BKE_brush_use_size_pressure(scene, pop->s.brush))) {
     return;
   }
 
@@ -493,8 +492,7 @@ static void paint_brush_stroke_add_step(bContext *C,
   if (tablet && (pressure < 0.0002f) &&
       ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) ||
        BKE_brush_use_alpha_pressure(scene, pop->s.brush) ||
-       BKE_brush_use_size_pressure(scene, pop->s.brush)))
-  {
+       BKE_brush_use_size_pressure(scene, pop->s.brush))) {
     return;
   }
 #endif
index 70783ff..291320a 100644 (file)
@@ -565,9 +565,11 @@ static void do_weight_paint_normalize_all_locked_try_active(MDeformVert *dvert,
 }
 
 #if 0 /* UNUSED */
-static bool has_unselected_unlocked_bone_group(
-        int defbase_tot, bool *defbase_sel, int selected,
-        const bool *lock_flags, const bool *vgroup_validmap)
+static bool has_unselected_unlocked_bone_group(int defbase_tot,
+                                               bool *defbase_sel,
+                                               int selected,
+                                               const bool *lock_flags,
+                                               const bool *vgroup_validmap)
 {
   int i;
   if (defbase_tot == selected) {
index 9309def..6882b24 100644 (file)
@@ -676,7 +676,10 @@ static float frontface(const Brush *br,
 
 #if 0
 
-static bool sculpt_brush_test_cyl(SculptBrushTest *test, float co[3], float location[3], const float area_no[3])
+static bool sculpt_brush_test_cyl(SculptBrushTest *test,
+                                  float co[3],
+                                  float location[3],
+                                  const float area_no[3])
 {
   if (sculpt_brush_test_sphere_fast(test, co)) {
     float t1[3], t2[3], t3[3], dist;
index 7499458..6b37cd8 100644 (file)
@@ -275,8 +275,7 @@ static void box_select_action(bAnimContext *ac, const rcti rect, short mode, sho
       /* loop over data selecting */
       switch (ale->type) {
 #if 0 /* XXX: Keyframes are not currently shown here */
-        case ANIMTYPE_GPDATABLOCK:
-        {
+        case ANIMTYPE_GPDATABLOCK: {
           bGPdata *gpd = ale->data;
           bGPDlayer *gpl;
           for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
@@ -478,8 +477,7 @@ static void region_select_action_keys(
       /* loop over data selecting */
       switch (ale->type) {
 #if 0 /* XXX: Keyframes are not currently shown here */
-        case ANIMTYPE_GPDATABLOCK:
-        {
+        case ANIMTYPE_GPDATABLOCK: {
           bGPdata *gpd = ale->data;
           bGPDlayer *gpl;
           for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
index a17c1b6..1fc218c 100644 (file)
@@ -144,14 +144,12 @@ static void console_lb_debug__internal(ListBase *lb)
   for (cl = lb->first; cl; cl = cl->next)
     printf("<%s> ", cl->line);
   printf("\n");
-
 }
 
 static void console_history_debug(const bContext *C)
 {
   SpaceConsole *sc = CTX_wm_space_console(C);
 
-
   console_lb_debug__internal(&sc->history);
 }
 #endif
index 31a59f0..21b0eef 100644 (file)
@@ -2420,11 +2420,13 @@ static void filelist_readjob_main_rec(Main *bmain, FileList *filelist)
 
   BLI_assert(filelist->filelist.entries == NULL);
 
-  if (filelist->filelist.root[0] == '/') filelist->filelist.root[0] = '\0';
+  if (filelist->filelist.root[0] == '/')
+    filelist->filelist.root[0] = '\0';
 
   if (filelist->filelist.root[0]) {
     idcode = groupname_to_code(filelist->filelist.root);
-    if (idcode == 0) filelist->filelist.root[0] = '\0';
+    if (idcode == 0)
+      filelist->filelist.root[0] = '\0';
   }
 
   if (filelist->dir[0] == 0) {
@@ -2472,7 +2474,8 @@ static void filelist_readjob_main_rec(Main *bmain, FileList *filelist)
     idcode = groupname_to_code(filelist->filelist.root);
 
     lb = which_libbase(bmain, idcode);
-    if (lb == NULL) return;
+    if (lb == NULL)
+      return;
 
     filelist->filelist.nbr_entries = 0;
     for (id = lb->first; id; id = id->next) {
@@ -2523,19 +2526,21 @@ static void filelist_readjob_main_rec(Main *bmain, FileList *filelist)
             }
           }
 #  endif
-//                  files->entry->nr = totbl + 1;
+          //                  files->entry->nr = totbl + 1;
           files->entry->poin = id;
           fake = id->flag & LIB_FAKEUSER;
-          if (idcode == ID_MA || idcode == ID_TE || idcode == ID_LA || idcode == ID_WO || idcode == ID_IM) {
+          if (idcode == ID_MA || idcode == ID_TE || idcode == ID_LA || idcode == ID_WO ||
+              idcode == ID_IM) {
             files->typeflag |= FILE_TYPE_IMAGE;
           }
-//                  if      (id->lib && fake) BLI_snprintf(files->extra, sizeof(files->entry->extra), "LF %d",    id->us);
-//                  else if (id->lib)         BLI_snprintf(files->extra, sizeof(files->entry->extra), "L    %d",  id->us);
-//                  else if (fake)            BLI_snprintf(files->extra, sizeof(files->entry->extra), "F    %d",  id->us);
-//                  else                      BLI_snprintf(files->extra, sizeof(files->entry->extra), "      %d", id->us);
+          //                  if      (id->lib && fake) BLI_snprintf(files->extra, sizeof(files->entry->extra), "LF %d",    id->us);
+          //                  else if (id->lib)         BLI_snprintf(files->extra, sizeof(files->entry->extra), "L    %d",  id->us);
+          //                  else if (fake)            BLI_snprintf(files->extra, sizeof(files->entry->extra), "F    %d",  id->us);
+          //                  else                      BLI_snprintf(files->extra, sizeof(files->entry->extra), "      %d", id->us);
 
           if (id->lib) {
-            if (totlib == 0) firstlib = files;
+            if (totlib == 0)
+              firstlib = files;
             totlib++;
           }
 
index 5bfe1c1..eb9860b 100644 (file)
@@ -315,8 +315,8 @@ static bool draw_fcurve_handles_check(SpaceGraph *sipo, FCurve *fcu)
       /* keyframes aren't editable */
       (fcu->flag & FCURVE_PROTECTED) ||
 #if 0 /* handles can still be selected and handle types set, better draw - campbell */
-          /* editing the handles here will cause weird/incorrect interpolation issues */
-          (fcu->flag & FCURVE_INT_VALUES) ||
+      /* editing the handles here will cause weird/incorrect interpolation issues */
+      (fcu->flag & FCURVE_INT_VALUES) ||
 #endif
       /* group that curve belongs to is not editable */
       ((fcu->grp) && (fcu->grp->flag & AGRP_PROTECTED)) ||
index e217987..66e5607 100644 (file)
@@ -191,7 +191,8 @@ void image_preview_event(int event)
     BIF_store_spare();
 
     /* 1 is do_previews */
-    ntreeCompositExecTree(scene->nodetree, &scene->r, 1, &scene->view_settings, &scene->display_settings);
+    ntreeCompositExecTree(
+        scene->nodetree, &scene->r, 1, &scene->view_settings, &scene->display_settings);
 
     G.scene->nodetree->timecursor = NULL;
     G.scene->nodetree->test_break = NULL;
@@ -203,7 +204,6 @@ void image_preview_event(int event)
   }
 }
 
-
 /* nothing drawn here, we use it to store values */
 static void preview_cb(ScrArea *sa, struct uiBlock *block)
 {
@@ -221,18 +221,24 @@ static void preview_cb(ScrArea *sa, struct uiBlock *block)
 
   /* while dragging we need to update the rects, otherwise it doesn't end with correct one */
 
-  BLI_rctf_init(&dispf, 15.0f, BLI_rcti_size_x(&block->rect) - 15.0f, 15.0f, (BLI_rctf_size_y(&block->rect)) - 15.0f);
+  BLI_rctf_init(&dispf,
+                15.0f,
+                BLI_rcti_size_x(&block->rect) - 15.0f,
+                15.0f,
+                (BLI_rctf_size_y(&block->rect)) - 15.0f);
   ui_graphics_to_window_rct(sa->win, &dispf, disprect);
 
   /* correction for gla draw */
   BLI_rcti_translate(disprect, -curarea->winrct.xmin, -curarea->winrct.ymin);
 
   calc_image_view(sima, 'p');
-//  printf("winrct %d %d %d %d\n", disprect->xmin, disprect->ymin, disprect->xmax, disprect->ymax);
+  //  printf("winrct %d %d %d %d\n", disprect->xmin, disprect->ymin, disprect->xmax, disprect->ymax);
   /* map to image space coordinates */
-  mval[0] = disprect->xmin; mval[1] = disprect->ymin;
+  mval[0] = disprect->xmin;
+  mval[1] = disprect->ymin;
   areamouseco_to_ipoco(v2d, mval, &dispf.xmin, &dispf.ymin);
-  mval[0] = disprect->xmax; mval[1] = disprect->ymax;
+  mval[0] = disprect->xmax;
+  mval[1] = disprect->ymax;
   areamouseco_to_ipoco(v2d, mval, &dispf.xmax, &dispf.ymax);
 
   /* map to render coordinates */
@@ -245,8 +251,7 @@ static void preview_cb(ScrArea *sa, struct uiBlock *block)
   CLAMP(disprect->xmax, 0, winx);
   CLAMP(disprect->ymin, 0, winy);
   CLAMP(disprect->ymax, 0, winy);
-//  printf("drawrct %d %d %d %d\n", disprect->xmin, disprect->ymin, disprect->xmax, disprect->ymax);
-
+  //  printf("drawrct %d %d %d %d\n", disprect->xmin, disprect->ymin, disprect->xmax, disprect->ymax);
 }
 
 static bool is_preview_allowed(ScrArea *cur)
@@ -268,8 +273,7 @@ static bool is_preview_allowed(ScrArea *cur)
   return 1;
 }
 
-
-static void image_panel_preview(ScrArea *sa, short cntrl)   // IMAGE_HANDLER_PREVIEW
+static void image_panel_preview(ScrArea *sa, short cntrl)  // IMAGE_HANDLER_PREVIEW
 {
   uiBlock *block;
   SpaceImage *sima = sa->spacedata.first;
@@ -287,10 +291,10 @@ static void image_panel_preview(ScrArea *sa, short cntrl)   // IMAGE_HANDLER_PRE
 
   ofsx = -150 + (sa->winx / 2) / sima->blockscale;
   ofsy = -100 + (sa->winy / 2) / sima->blockscale;
-  if (uiNewPanel(C, ar, block, "Preview", "Image", ofsx, ofsy, 300, 200) == 0) return;
+  if (uiNewPanel(C, ar, block, "Preview", "Image", ofsx, ofsy, 300, 200) == 0)
+    return;
 
   UI_but_func_drawextra_set(block, preview_cb);
-
 }
 #endif
 
@@ -1063,17 +1067,73 @@ void uiTemplateImage(uiLayout *layout,
         iuser = ntree_get_active_iuser(scene->nodetree);
         if (iuser) {
           UI_block_align_begin(block);
-          uiDefIconTextBut(block, UI_BTYPE_BUT, B_SIMA_RECORD, ICON_REC, "Record", 10, 120, 100, 20, 0, 0, 0, 0, 0, "");
-          uiDefIconTextBut(block, UI_BTYPE_BUT, B_SIMA_PLAY, ICON_PLAY, "Play",    110, 120, 100, 20, 0, 0, 0, 0, 0, "");
-          but = uiDefBut(block, UI_BTYPE_BUT, B_NOP, "Free Cache", 210, 120, 100, 20, 0, 0, 0, 0, 0, "");
+          uiDefIconTextBut(block,
+                           UI_BTYPE_BUT,
+                           B_SIMA_RECORD,
+                           ICON_REC,
+                           "Record",
+                           10,
+                           120,
+                           100,
+                           20,
+                           0,
+                           0,
+                           0,
+                           0,
+                           0,
+                           "");
+          uiDefIconTextBut(block,
+                           UI_BTYPE_BUT,
+                           B_SIMA_PLAY,
+                           ICON_PLAY,
+                           "Play",
+                           110,
+                           120,
+                           100,
+                           20,
+                           0,
+                           0,
+                           0,
+                           0,
+                           0,
+                           "");
+          but = uiDefBut(
+              block, UI_BTYPE_BUT, B_NOP, "Free Cache", 210, 120, 100, 20, 0, 0, 0, 0, 0, "");
           UI_but_func_set(but, image_freecache_cb, ima, NULL);
 
           if (iuser->frames)
             BLI_snprintf(str, sizeof(str), "(%d) Frames:", iuser->framenr);
-          else strcpy(str, "Frames:");
+          else
+            strcpy(str, "Frames:");
           UI_block_align_begin(block);
-          uiDefButI(block, UI_BTYPE_NUM, imagechanged, str,        10, 90, 150, 20, &iuser->frames, 0.0, MAXFRAMEF, 0, 0, "Number of images of a movie to use");
-          uiDefButI(block, UI_BTYPE_NUM, imagechanged, "StartFr:", 160, 90, 150, 20, &iuser->sfra, 1.0, MAXFRAMEF, 0, 0, "Global starting frame of the movie");
+          uiDefButI(block,
+                    UI_BTYPE_NUM,
+                    imagechanged,
+                    str,
+                    10,
+                    90,
+                    150,
+                    20,
+                    &iuser->frames,
+                    0.0,
+                    MAXFRAMEF,
+                    0,
+                    0,
+                    "Number of images of a movie to use");
+          uiDefButI(block,
+                    UI_BTYPE_NUM,
+                    imagechanged,
+                    "StartFr:",
+                    160,
+                    90,
+                    150,
+                    20,
+                    &iuser->sfra,
+                    1.0,
+                    MAXFRAMEF,
+                    0,
+                    0,
+                    "Global starting frame of the movie");
         }
 #endif
       }
index 06bacab..086f310 100644 (file)
@@ -3403,14 +3403,14 @@ static void image_sample_apply(bContext *C, wmOperator *op, const wmEvent *event
     {
       ScrArea *sa, *cur = curarea;
 
-      node_curvemap_sample(fp);   /* sends global to node editor */
+      node_curvemap_sample(fp); /* sends global to node editor */
       for (sa = G.curscreen->areabase.first; sa; sa = sa->next) {
         if (sa->spacetype == SPACE_NODE) {
           areawinset(sa->win);
           scrarea_do_windraw(sa);
         }
       }
-      node_curvemap_sample(NULL);     /* clears global in node editor */
+      node_curvemap_sample(NULL); /* clears global in node editor */
       curarea = cur;
     }
 #endif
@@ -3650,8 +3650,12 @@ static int image_record_composite_apply(bContext *C, wmOperator *op)
 
   BKE_image_all_free_anim_ibufs(scene->r.cfra);
   ntreeCompositTagAnimated(scene->nodetree);
-  ntreeCompositExecTree(scene->nodetree, &scene->r, 0, scene->r.cfra != rcd->old_cfra,
-                        &scene->view_settings, &scene->display_settings);  /* 1 is no previews */
+  ntreeCompositExecTree(scene->nodetree,
+                        &scene->r,
+                        0,
+                        scene->r.cfra != rcd->old_cfra,
+                        &scene->view_settings,
+                        &scene->display_settings); /* 1 is no previews */
 
   ED_area_tag_redraw(CTX_wm_area(C));
 
@@ -3714,7 +3718,8 @@ static int image_record_composite_exec(bContext *C, wmOperator *op)
   if (!image_record_composite_init(C, op))
     return OPERATOR_CANCELLED;
 
-  while (image_record_composite_apply(C, op)) {}
+  while (image_record_composite_apply(C, op)) {
+  }
 
   image_record_composite_exit(C, op);
 
index e1875fd..9c834f0 100644 (file)
@@ -745,7 +745,8 @@ static void image_main_region_draw(const bContext *C, ARegion *ar)
 
   /* scrollers? */
 #if 0
-  scrollers = UI_view2d_scrollers_calc(C, v2d, V2D_UNIT_VALUES, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY);
+  scrollers = UI_view2d_scrollers_calc(
+      C, v2d, V2D_UNIT_VALUES, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY);
   UI_view2d_scrollers_draw(C, v2d, scrollers);
   UI_view2d_scrollers_free(scrollers);
 #endif
index 707838c..1521a40 100644 (file)
@@ -46,11 +46,16 @@ int info_report_mask(SpaceInfo *UNUSED(sinfo))
 #if 0
   int report_mask = 0;
 
-  if (sinfo->rpt_mask & INFO_RPT_DEBUG) report_mask |= RPT_DEBUG_ALL;
-  if (sinfo->rpt_mask & INFO_RPT_INFO)  report_mask |= RPT_INFO_ALL;
-  if (sinfo->rpt_mask & INFO_RPT_OP)    report_mask |= RPT_OPERATOR_ALL;
-  if (sinfo->rpt_mask & INFO_RPT_WARN)  report_mask |= RPT_WARNING_ALL;
-  if (sinfo->rpt_mask & INFO_RPT_ERR)   report_mask |= RPT_ERROR_ALL;
+  if (sinfo->rpt_mask & INFO_RPT_DEBUG)
+    report_mask |= RPT_DEBUG_ALL;
+  if (sinfo->rpt_mask & INFO_RPT_INFO)
+    report_mask |= RPT_INFO_ALL;
+  if (sinfo->rpt_mask & INFO_RPT_OP)
+    report_mask |= RPT_OPERATOR_ALL;
+  if (sinfo->rpt_mask & INFO_RPT_WARN)
+    report_mask |= RPT_WARNING_ALL;
+  if (sinfo->rpt_mask & INFO_RPT_ERR)
+    report_mask |= RPT_ERROR_ALL;
 
   return report_mask;
 #endif
@@ -71,10 +76,8 @@ static int report_replay_exec(bContext *C, wmOperator *UNUSED(op))
   sc->type = CONSOLE_TYPE_PYTHON;
 
   for (report = reports->list.last; report; report = report->prev) {
-    if ((report->type & report_mask) &&
-        (report->type & RPT_OPERATOR_ALL | RPT_PROPERTY_ALL) &&
-        (report->flag & SELECT))
-    {
+    if ((report->type & report_mask) && (report->type & RPT_OPERATOR_ALL | RPT_PROPERTY_ALL) &&
+        (report->flag & SELECT)) {
       console_history_add_str(sc, report->message, 0);
       WM_operator_name_call(C, "CONSOLE_OT_execute", WM_OP_EXEC_DEFAULT, NULL);
 
index 7072f34..327aa94 100644 (file)
@@ -204,7 +204,8 @@ static void node_browse_tex_cb(bContext *C, void *ntree_v, void *node_v)
   bNode *node = node_v;
   Tex *tex;
 
-  if (node->menunr < 1) return;
+  if (node->menunr < 1)
+    return;
 
   if (node->id) {
     id_us_min(node->id);
index 84f5129..09af141 100644 (file)
@@ -752,8 +752,8 @@ void ED_node_set_active(Main *bmain, bNodeTree *ntree, bNode *node)
 #if 0
       if (node->id)
         ;  // XXX BIF_preview_changed(-1);
-      // allqueue(REDRAWBUTSSHADING, 1);
-      // allqueue(REDRAWIPO, 0);
+           // allqueue(REDRAWBUTSSHADING, 1);
+           // allqueue(REDRAWIPO, 0);
 #endif
     }
   }
@@ -804,7 +804,8 @@ static int edit_node_invoke_properties(bContext *C, wmOperator *op)
   return 1;
 }
 
-static void edit_node_properties_get(wmOperator *op, bNodeTree *ntree, bNode **rnode, bNodeSocket **rsock, int *rin_out)
+static void edit_node_properties_get(
+    wmOperator *op, bNodeTree *ntree, bNode **rnode, bNodeSocket **rsock, int *rin_out)
 {
   bNode *node;
   bNodeSocket *sock = NULL;
@@ -819,8 +820,12 @@ static void edit_node_properties_get(wmOperator *op, bNodeTree *ntree, bNode **r
 
   sockindex = RNA_int_get(op->ptr, "socket");
   switch (in_out) {
-    case SOCK_IN:   sock = BLI_findlink(&node->inputs, sockindex);  break;
-    case SOCK_OUT:  sock = BLI_findlink(&node->outputs, sockindex); break;
+    case SOCK_IN:
+      sock = BLI_findlink(&node->inputs, sockindex);
+      break;
+    case SOCK_OUT:
+      sock = BLI_findlink(&node->outputs, sockindex);
+      break;
   }
 
   if (rnode)
index 2d33c5d..f0dface 100644 (file)
@@ -100,7 +100,7 @@ static void outliner_width(SpaceOutliner *soops, ListBase *lb, int *w)
 {
   TreeElement *te = lb->first;
   while (te) {
-//      TreeStoreElem *tselem = TREESTORE(te);
+    //      TreeStoreElem *tselem = TREESTORE(te);
 
     // XXX fixme... te->xend is not set yet
     if (!TSELEM_OPEN(tselem, soops)) {
index 11d0193..6cfb5ce 100644 (file)
@@ -1296,8 +1296,8 @@ void OUTLINER_OT_scroll_page(wmOperatorType *ot)
 #if 0
 
 /* find next element that has this name */
-static TreeElement *outliner_find_name(SpaceOutliner *soops, ListBase *lb, char *name, int flags,
-                                       TreeElement *prev, int *prevFound)
+static TreeElement *outliner_find_name(
+    SpaceOutliner *soops, ListBase *lb, char *name, int flags, TreeElement *prev, int *prevFound)
 {
   TreeElement *te, *tes;
 
@@ -1318,16 +1318,18 @@ static TreeElement *outliner_find_name(SpaceOutliner *soops, ListBase *lb, char
     }
 
     tes = outliner_find_name(soops, &te->subtree, name, flags, prev, prevFound);
-    if (tes) return tes;
+    if (tes)
+      return tes;
   }
 
   /* nothing valid found */
   return NULL;
 }
 
-static void outliner_find_panel(Scene *UNUSED(scene), ARegion *ar, SpaceOutliner *soops, int again, int flags)
+static void outliner_find_panel(
+    Scene *UNUSED(scene), ARegion *ar, SpaceOutliner *soops, int again, int flags)
 {
-  ReportList *reports = NULL; // CTX_wm_reports(C);
+  ReportList *reports = NULL;  // CTX_wm_reports(C);
   TreeElement *te = NULL;
   TreeElement *last_find;
   TreeStoreElem *tselem;
@@ -1354,10 +1356,10 @@ static void outliner_find_panel(Scene *UNUSED(scene), ARegion *ar, SpaceOutliner
   else {
     /* pop up panel - no previous, or user didn't want search after previous */
     name[0] = '\0';
-// XXX      if (sbutton(name, 0, sizeof(name) - 1, "Find: ") && name[0]) {
-//          te = outliner_find_name(soops, &soops->tree, name, flags, NULL, &prevFound);
-//      }
-//      else return; /* XXX RETURN! XXX */
+    // XXX      if (sbutton(name, 0, sizeof(name) - 1, "Find: ") && name[0]) {
+    //          te = outliner_find_name(soops, &soops->tree, name, flags, NULL, &prevFound);
+    //      }
+    //      else return; /* XXX RETURN! XXX */
   }
 
   /* do selection and reveal */
@@ -1374,7 +1376,8 @@ static void outliner_find_panel(Scene *UNUSED(scene), ARegion *ar, SpaceOutliner
 
       /* make te->ys center of view */
       ytop = (int)(te->ys + BLI_rctf_size_y(&ar->v2d.mask) / 2);
-      if (ytop > 0) ytop = 0;
+      if (ytop > 0)
+        ytop = 0;
       ar->v2d.cur.ymax = (float)ytop;
       ar->v2d.cur.ymin = (float)(ytop - BLI_rctf_size_y(&ar->v2d.mask));
 
index a03d9b6..6b24e83 100644 (file)
@@ -372,9 +372,12 @@ static void outliner_add_object_contents(SpaceOutliner *soops,
                 soops, &tenla1->subtree, ob, tenla1, TSE_CONSTRAINT, const_index);
 #if 0 /* disabled as it needs to be reworked for recoded constraints system */
             target = get_constraint_target(con, &str);
-            if (str && str[0]) ten1->name = str;
-            else if (target) ten1->name = target->id.name + 2;
-            else ten1->name = con->name;
+            if (str && str[0])
+              ten1->name = str;
+            else if (target)
+              ten1->name = target->id.name + 2;
+            else
+              ten1->name = con->name;
 #endif
             ten1->name = con->name;
             ten1->directdata = con;
@@ -434,9 +437,12 @@ static void outliner_add_object_contents(SpaceOutliner *soops,
       ten = outliner_add_element(soops, &tenla->subtree, ob, tenla, TSE_CONSTRAINT, a);
 #if 0 /* disabled due to constraints system targets recode... code here needs review */
       target = get_constraint_target(con, &str);
-      if (str && str[0]) ten->name = str;
-      else if (target) ten->name = target->id.name + 2;
-      else ten->name = con->name;
+      if (str && str[0])
+        ten->name = str;
+      else if (target)
+        ten->name = target->id.name + 2;
+      else
+        ten->name = con->name;
 #endif
       ten->name = con->name;
       ten->directdata = con;
@@ -1548,15 +1554,20 @@ static int treesort_obtype_alpha(const void *v1, const void *v2)
   else {
     /* 2nd we check ob type */
     if (x1->idcode == ID_OB && x2->idcode == ID_OB) {
-      if      (((Object *)x1->id)->type > ((Object *)x2->id)->type) return  1;
-      else if (((Object *)x1->id)->type > ((Object *)x2->id)->type) return -1;
-      else return 0;
+      if (((Object *)x1->id)->type > ((Object *)x2->id)->type)
+        return 1;
+      else if (((Object *)x1->id)->type > ((Object *)x2->id)->type)
+        return -1;
+      else
+        return 0;
     }
     else {
       int comp = strcmp(x1->name, x2->name);
 
-      if      (comp > 0) return  1;
-      else if (comp < 0) return -1;
+      if (comp > 0)
+        return 1;
+      else if (comp < 0)
+        return -1;
       return 0;
     }
   }
index e2140fb..628d487 100644 (file)
@@ -1201,13 +1201,19 @@ void sequencer_draw_maskedit(const bContext *C, Scene *scene, ARegion *ar, Space
       width = (scene->r.size * scene->r.xsch) / 100;
       height = (scene->r.size * scene->r.ysch) / 100;
 
-      ED_mask_draw_region(
-              mask, ar,
-              0, 0, 0,  /* TODO */
-              width, height,
-              aspx, aspy,
-              false, true,
-              NULL, C);
+      ED_mask_draw_region(mask,
+                          ar,
+                          0,
+                          0,
+                          0, /* TODO */
+                          width,
+                          height,
+                          aspx,
+                          aspy,
+                          false,
+                          true,
+                          NULL,
+                          C);
     }
   }
 }
@@ -1623,9 +1629,7 @@ void drawprefetchseqspace(Scene *scene, ARegion *UNUSED(ar), SpaceSeq *sseq)
   recty = (render_size * scene->r.ysch) / 100;
 
   if (sseq->mainb != SEQ_DRAW_SEQUENCE) {
-    give_ibuf_prefetch_request(
-        rectx, recty, (scene->r.cfra), sseq->chanshown,
-        proxy_size);
+    give_ibuf_prefetch_request(rectx, recty, (scene->r.cfra), sseq->chanshown, proxy_size);
   }
 }
 #endif
index cf07e25..c94da4a 100644 (file)
@@ -1036,22 +1036,22 @@ static void set_filter_seq(Scene *scene)
   Sequence *seq;
   Editing *ed = BKE_sequencer_editing_get(scene, false);
 
+  if (ed == NULL)
+    return;
 
-  if (ed == NULL) return;
-
-  if (okee("Set Deinterlace") == 0) return;
+  if (okee("Set Deinterlace") == 0)
+    return;
 
-  SEQP_BEGIN (ed, seq)
-  {
+  SEQP_BEGIN (ed, seq) {
     if (seq->flag & SELECT) {
       if (seq->type == SEQ_TYPE_MOVIE) {
         seq->flag |= SEQ_FILTERY;
         BKE_sequence_reload_new_file(scene, seq, false);
         BKE_sequence_calc(scene, seq);
       }
-
     }
-  } SEQ_END;
+  }
+  SEQ_END;
 }
 #endif
 
@@ -1228,7 +1228,8 @@ bool sequencer_edit_poll(bContext *C)
 bool sequencer_strip_poll(bContext *C)
 {
   Editing *ed;
-  return (((ed = BKE_sequencer_editing_get(CTX_data_scene(C), false)) != NULL) && (ed->act_seq != NULL));
+  return (((ed = BKE_sequencer_editing_get(CTX_data_scene(C), false)) != NULL) &&
+          (ed->act_seq != NULL));
 }
 #endif
 
@@ -2886,9 +2887,7 @@ static int sequencer_view_all_preview_exec(bContext *C, wmOperator *UNUSED(op))
   /* Apply aspect, dosnt need to be that accurate */
   imgwidth = (int)(imgwidth * (scene->r.xasp / scene->r.yasp));
 
-  if (((imgwidth >= width) || (imgheight >= height)) &&
-      ((width > 0) && (height > 0)))
-  {
+  if (((imgwidth >= width) || (imgheight >= height)) && ((width > 0) && (height > 0))) {
     /* Find the zoom value that will fit the image in the image space */
     zoomX = ((float)width) / ((float)imgwidth);
     zoomY = ((float)height) / ((float)imgheight);
@@ -2965,10 +2964,14 @@ void SEQUENCER_OT_view_zoom_ratio(wmOperatorType *ot)
 
 #if 0
 static const EnumPropertyItem view_type_items[] = {
-  {SEQ_VIEW_SEQUENCE, "SEQUENCER", ICON_SEQ_SEQUENCER, "Sequencer", ""},
-  {SEQ_VIEW_PREVIEW,  "PREVIEW", ICON_SEQ_PREVIEW, "Image Preview", ""},
-  {SEQ_VIEW_SEQUENCE_PREVIEW,  "SEQUENCER_PREVIEW", ICON_SEQ_SEQUENCER, "Sequencer and Image Preview", ""},
-  {0, NULL, 0, NULL, NULL},
+    {SEQ_VIEW_SEQUENCE, "SEQUENCER", ICON_SEQ_SEQUENCER, "Sequencer", ""},
+    {SEQ_VIEW_PREVIEW, "PREVIEW", ICON_SEQ_PREVIEW, "Image Preview", ""},
+    {SEQ_VIEW_SEQUENCE_PREVIEW,
+     "SEQUENCER_PREVIEW",
+     ICON_SEQ_SEQUENCER,
+     "Sequencer and Image Preview",
+     ""},
+    {0, NULL, 0, NULL, NULL},
 };
 #endif
 
@@ -3169,7 +3172,8 @@ static Sequence *sequence_find_parent(Scene *scene, Sequence *child)
   Sequence *parent = NULL;
   Sequence *seq;
 
-  if (ed == NULL) return NULL;
+  if (ed == NULL)
+    return NULL;
 
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
     if ((seq != child) && seq_is_parent(seq, child)) {
index a59a3b8..09cc463 100644 (file)
@@ -541,12 +541,12 @@ static int sequencer_select_invoke(bContext *C, wmOperator *op, const wmEvent *e
 #if 0  // XXX probably need to redo this differently for 2.5
   if (marker) {
     int mval[2], xo, yo;
-//      getmouseco_areawin(mval);
+    //      getmouseco_areawin(mval);
     xo = mval[0];
     yo = mval[1];
 
     while (get_mbut()) {
-//          getmouseco_areawin(mval);
+      //          getmouseco_areawin(mval);
       if (abs(mval[0] - xo) + abs(mval[1] - yo) > 4) {
         transform_markers('g', 0);
         return;
index dadb86f..b2c5f42 100644 (file)
@@ -107,7 +107,8 @@ static void txt_format_text(SpaceText *st)
 {
   TextLine *linep;
 
-  if (!st->text) return;
+  if (!st->text)
+    return;
 
   for (linep = st->text->lines.first; linep; linep = linep->next)
     txt_format_line(st, linep, 0);
@@ -989,18 +990,23 @@ static void draw_documentation(const SpaceText *st, ARegion *ar)
   int i, br, lines;
   int boxw, boxh, l, x, y /* , top */ /* UNUSED */;
 
-  if (!st || !st->text) return;
-  if (!texttool_text_is_active(st->text)) return;
+  if (!st || !st->text)
+    return;
+  if (!texttool_text_is_active(st->text))
+    return;
 
   docs = texttool_docs_get();
 
-  if (!docs) return;
+  if (!docs)
+    return;
 
   text_draw_context_init(st, &tdc);
 
   /* Count the visible lines to the cursor */
-  for (tmp = st->text->curl, l = -st->top; tmp; tmp = tmp->prev, l++) ;
-  if (l < 0) return;
+  for (tmp = st->text->curl, l = -st->top; tmp; tmp = tmp->prev, l++)
+    ;
+  if (l < 0)
+    return;
 
   if (st->showlinenrs) {
     x = st->cwidth * (st->text->curc - st->left) + TXT_OFFSET + TEXTXLOC - 4;
@@ -1017,7 +1023,8 @@ static void draw_documentation(const SpaceText *st, ARegion *ar)
   boxh = (DOC_HEIGHT + 1) * (st->lheight_dpi + TXT_LINE_SPACING);
 
   /* Draw panel */
-  uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
+  uint pos = GPU_vertformat_attr_add(
+      immVertexFormat(), "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
 
   immUniformThemeColor(TH_BACK);
@@ -1044,9 +1051,12 @@ static void draw_documentation(const SpaceText *st, ARegion *ar)
 
   UI_FontThemeColor(tdc.font_id, TH_TEXT);
 
-  i = 0; br = DOC_WIDTH; lines = 0; // XXX -doc_scroll;
+  i = 0;
+  br = DOC_WIDTH;
+  lines = 0;  // XXX -doc_scroll;
   for (p = docs; *p; p++) {
-    if (*p == '\r' && *(++p) != '\n') *(--p) = '\n';  /* Fix line endings */
+    if (*p == '\r' && *(++p) != '\n')
+      *(--p) = '\n'; /* Fix line endings */
     if (*p == ' ' || *p == '\t')
       br = i;
     else if (*p == '\n') {
@@ -1055,7 +1065,9 @@ static void draw_documentation(const SpaceText *st, ARegion *ar)
         y -= st->lheight_dpi;
         text_draw(st, &tdc, buf, 0, 0, x + 4, y - 3, NULL);
       }
-      i = 0; br = DOC_WIDTH; lines++;
+      i = 0;
+      br = DOC_WIDTH;
+      lines++;
     }
     buf[i++] = *p;
     if (i == DOC_WIDTH) { /* Reached the width, go to last break and wrap there */
@@ -1065,9 +1077,12 @@ static void draw_documentation(const SpaceText *st, ARegion *ar)
         text_draw(st, &tdc, buf, 0, 0, x + 4, y - 3, NULL);
       }
       p -= i - br - 1; /* Rewind pointer to last break */
-      i = 0; br = DOC_WIDTH; lines++;
+      i = 0;
+      br = DOC_WIDTH;
+      lines++;
     }
-    if (lines >= DOC_HEIGHT) break;
+    if (lines >= DOC_HEIGHT)
+      break;
   }
 }
 #endif
index 435a6fd..cbb3be0 100644 (file)
@@ -195,13 +195,30 @@ void TEXT_OT_start_find(wmOperatorType *ot)
   uiPopupMenu *pup;
 
   pup = UI_popup_menu_begin(C, IFACE_("Text"), ICON_NONE);
-  uiItemEnumO(layout, "TEXT_OT_move", CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Top of File"),
-              0, "type", FILE_TOP);
-  uiItemEnumO(layout, "TEXT_OT_move", CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Bottom of File"),
-              0, "type", FILE_BOTTOM);
-  uiItemEnumO(layout, "TEXT_OT_move", CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Page Up"), 0, "type", PREV_PAGE);
-  uiItemEnumO(layout, "TEXT_OT_move", CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Page Down"),
-              0, "type", NEXT_PAGE);
+  uiItemEnumO(layout,
+              "TEXT_OT_move",
+              CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Top of File"),
+              0,
+              "type",
+              FILE_TOP);
+  uiItemEnumO(layout,
+              "TEXT_OT_move",
+              CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Bottom of File"),
+              0,
+              "type",
+              FILE_BOTTOM);
+  uiItemEnumO(layout,
+              "TEXT_OT_move",
+              CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Page Up"),
+              0,
+              "type",
+              PREV_PAGE);
+  uiItemEnumO(layout,
+              "TEXT_OT_move",
+              CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Page Down"),
+              0,
+              "type",
+              NEXT_PAGE);
   UI_popup_menu_end(C, pup);
 }
 #endif
index 1d2d361..84ebacc 100644 (file)
@@ -1646,7 +1646,8 @@ void viewmove_modal_keymap(wmKeyConfig *keyconf)
 #if 0
   WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ZOOM);
   WM_modalkeymap_add_item(keymap, LEFTCTRLKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ZOOM);
-  WM_modalkeymap_add_item(keymap, LEFTSHIFTKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
+  WM_modalkeymap_add_item(
+      keymap, LEFTSHIFTKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
 #endif
 
   /* assign map to operators */
index 6932e94..f50f6f8 100644 (file)
@@ -498,7 +498,10 @@ void ED_view3d_global_to_vector(const RegionView3D *rv3d, const float coord[3],
 
 /* very similar to ED_view3d_win_to_3d() but has no advantage, de-duplicating */
 #if 0
-bool view3d_get_view_aligned_coordinate(ARegion *ar, float fp[3], const int mval[2], const bool do_fallback)
+bool view3d_get_view_aligned_coordinate(ARegion *ar,
+                                        float fp[3],
+                                        const int mval[2],
+                                        const bool do_fallback)
 {
   RegionView3D *rv3d = ar->regiondata;
   float dvec[3];
@@ -508,8 +511,7 @@ bool view3d_get_view_aligned_coordinate(ARegion *ar, float fp[3], const int mval
   ret = ED_view3d_project_int_global(ar, fp, mval_cpy, V3D_PROJ_TEST_NOP);
 
   if (ret == V3D_PROJ_RET_OK) {
-    const float mval_f[2] = {(float)(mval_cpy[0] - mval[0]),
-                             (float)(mval_cpy[1] - mval[1])};
+    const float mval_f[2] = {(float)(mval_cpy[0] - mval[0]), (float)(mval_cpy[1] - mval[1])};
     const float zfac = ED_view3d_calc_zfac(rv3d, fp, NULL);
     ED_view3d_win_to_delta(ar, mval_f, dvec, zfac);
     sub_v3_v3(fp, dvec);
index c0f2e56..088b611 100644 (file)
@@ -1080,9 +1080,8 @@ static void do_lasso_select_node(int mcords[][2], short moves, const eSelectOp s
 
     ipoco_to_areaco_noclip(G.v2d, node_centf, node_cent);
     const bool is_select = node->flag & SELECT;
-    const bool is_inside = (
-            BLI_rcti_isect_pt_v(&rect, node_cent) &&
-            BLI_lasso_is_point_inside(mcords, moves, node_cent[0], node_cent[1]));
+    const bool is_inside = (BLI_rcti_isect_pt_v(&rect, node_cent) &&
+                            BLI_lasso_is_point_inside(mcords, moves, node_cent[0], node_cent[1]));
     const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
     if (sel_op_result != -1) {
       SET_FLAG_FROM_TEST(node->flag, sel_op_result, SELECT);
index e313ed3..0738703 100644 (file)
@@ -739,9 +739,16 @@ void view3d_winmatrix_set(Depsgraph *depsgraph, ARegion *ar, const View3D *v3d,
   rv3d->is_persp = !is_ortho;
 
 #if 0
-  printf("%s: %d %d %f %f %f %f %f %f\n", __func__, winx, winy,
-         viewplane.xmin, viewplane.ymin, viewplane.xmax, viewplane.ymax,
-         clipsta, clipend);
+  printf("%s: %d %d %f %f %f %f %f %f\n",
+         __func__,
+         winx,
+         winy,
+         viewplane.xmin,
+         viewplane.ymin,
+         viewplane.xmax,
+         viewplane.ymax,
+         clipsta,
+         clipend);
 #endif
 
   if (rect) { /* picking */
index 944c643..76bd66f 100644 (file)
@@ -6731,7 +6731,8 @@ static BMLoop *get_next_loop(
           cross_v3_v3v3(vec_accum, l_tmp->f->no, tdir);
 #if 0
           /* rough guess, we can  do better! */
-          normalize_v3_length(vec_accum, (BM_edge_calc_length(e_prev) + BM_edge_calc_length(e_next)) / 2.0f);
+          normalize_v3_length(vec_accum,
+                              (BM_edge_calc_length(e_prev) + BM_edge_calc_length(e_next)) / 2.0f);
 #else
           /* be clever, check the opposite ngon edge to slide into.
            * this gives best results */
index b682617..ef8089b 100644 (file)
@@ -6932,7 +6932,8 @@ void special_aftertrans_update(bContext *C, TransInfo *t)
 #if 0
         if (ELEM(t->frame_side, 'L', 'R')) { /* TFM_TIME_EXTEND */
           /* same as below */
-          ED_markers_post_apply_transform(ED_context_get_markers(C), t->scene, t->mode, t->values[0], t->frame_side);
+          ED_markers_post_apply_transform(
+              ED_context_get_markers(C), t->scene, t->mode, t->values[0], t->frame_side);
         }
         else /* TFM_TIME_TRANSLATE */
 #endif
index 18b19d9..8b4c1c3 100644 (file)
@@ -587,8 +587,7 @@ static unsigned int bm_mesh_edges_select_get_n(BMesh *bm, BMEdge **elems, const
 static unsigned int bm_mesh_faces_select_get_n(BMesh *bm, BMVert **elems, const unsigned int n)
 {
   return bm_mesh_elems_select_get_n__internal(
-          bm, (BMElem **)elems, min_ii(n, bm->totfacesel),
-          BM_FACES_OF_MESH, BM_FACE);
+      bm, (BMElem **)elems, min_ii(n, bm->totfacesel), BM_FACES_OF_MESH, BM_FACE);
 }
 #endif
 
index 291dbdf..d1e63ad 100644 (file)
@@ -2649,8 +2649,10 @@ static int uv_mouse_select_multi(
     /* before bmesh */
 #if 0
     if (ts->selectmode != SCE_SELECT_FACE) {
-      if (flush == 1) EDBM_select_flush(em);
-      else if (flush == -1) EDBM_deselect_flush(em);
+      if (flush == 1)
+        EDBM_select_flush(em);
+      else if (flush == -1)
+        EDBM_deselect_flush(em);
     }
 #else
     if (flush != 0) {
index 69183d0..913aace 100644 (file)
@@ -1393,7 +1393,12 @@ static int p_polygon_point_in(float *cp1, float *cp2, float *p)
     return (p_area_signed(cp1, cp2, p) >= 0.0f);
 }
 
-static void p_polygon_kernel_clip(float (*oldpoints)[2], int noldpoints, float (*newpoints)[2], int *nnewpoints, float *cp1, float *cp2)
+static void p_polygon_kernel_clip(float (*oldpoints)[2],
+                                  int noldpoints,
+                                  float (*newpoints)[2],
+                                  int *nnewpoints,
+                                  float *cp1,
+                                  float *cp2)
 {
   float *p2, *p1, isect[2];
   int i, p2in, p1in;
@@ -1438,7 +1443,7 @@ static void p_polygon_kernel_clip(float (*oldpoints)[2], int noldpoints, float (
 static void p_polygon_kernel_center(float (*points)[2], int npoints, float *center)
 {
   int i, size, nnewpoints = npoints;
-  float (*oldpoints)[2], (*newpoints)[2], *p1, *p2;
+  float(*oldpoints)[2], (*newpoints)[2], *p1, *p2;
 
   size = npoints * 3;
   oldpoints = MEM_mallocN(sizeof(float) * 2 * size, "PPolygonOldPoints");
@@ -1477,7 +1482,7 @@ static void p_polygon_kernel_center(float (*points)[2], int npoints, float *cent
       newpoints = MEM_mallocN(sizeof(float) * 2 * size, "newpoints");
     }
     else {
-      float (*sw_points)[2] = oldpoints;
+      float(*sw_points)[2] = oldpoints;
       oldpoints = newpoints;
       newpoints = sw_points;
     }
@@ -1616,7 +1621,7 @@ static void p_vert_harmonic_insert(PVert *v)
      * weights fails */
 
     int npoints = 0, i;
-    float (*points)[2];
+    float(*points)[2];
 
     e = v->edge;
     do {
@@ -1939,8 +1944,7 @@ static PBool p_collapse_allowed(PEdge *edge, PEdge *pair)
   if (oldv->flag & PVERT_PIN)
     return P_FALSE;
 
-  return (p_collapse_allowed_topologic(edge, pair) &&
-          p_collapse_allowed_geometric(edge, pair));
+  return (p_collapse_allowed_topologic(edge, pair) && p_collapse_allowed_geometric(edge, pair));
 }
 
 static float p_collapse_cost(PEdge *edge, PEdge *pair)
index 8248266..ab1da79 100644 (file)
@@ -135,8 +135,18 @@ void AppCanvas::readColorPixels(int x, int y, int w, int h, RGBImage &oImage) co
     float yfac = ((float)recty) / ((float)(ymax - ymin));
 #if 0
     if (G.debug & G_DEBUG_FREESTYLE) {
-      printf("readColorPixels %d x %d @ (%d, %d) in %d x %d [%d x %d] -- %d x %d @ %d%%\n", w, h, x, y,
-             xsch, ysch, xmax - xmin, ymax - ymin, rectx, recty, (int)(xfac * 100.0f));
+      printf("readColorPixels %d x %d @ (%d, %d) in %d x %d [%d x %d] -- %d x %d @ %d%%\n",
+             w,
+             h,
+             x,
+             y,
+             xsch,
+             ysch,
+             xmax - xmin,
+             ymax - ymin,
+             rectx,
+             recty,
+             (int)(xfac * 100.0f));
     }
 #endif
     int ii, jj;
@@ -173,8 +183,18 @@ void AppCanvas::readDepthPixels(int x, int y, int w, int h, GrayImage &oImage) c
     float yfac = ((float)recty) / ((float)(ymax - ymin));
 #if 0
     if (G.debug & G_DEBUG_FREESTYLE) {
-      printf("readDepthPixels %d x %d @ (%d, %d) in %d x %d [%d x %d] -- %d x %d @ %d%%\n", w, h, x, y,
-             xsch, ysch, xmax - xmin, ymax - ymin, rectx, recty, (int)(xfac * 100.0f));
+      printf("readDepthPixels %d x %d @ (%d, %d) in %d x %d [%d x %d] -- %d x %d @ %d%%\n",
+             w,
+             h,
+             x,
+             y,
+             xsch,
+             ysch,
+             xmax - xmin,
+             ymax - ymin,
+             rectx,
+             recty,
+             (int)(xfac * 100.0f));
     }
 #endif
     int ii, jj;
index e606612..d516b86 100644 (file)
@@ -76,8 +76,8 @@ Controller::Controller()
 {
   const string sep(Config::DIR_SEP.c_str());
 #if 0
-  const string filename = Config::Path::getInstance()->getHomeDir() + sep + Config::OPTIONS_DIR + sep +
-                          Config::OPTIONS_CURRENT_DIRS_FILE;
+  const string filename = Config::Path::getInstance()->getHomeDir() + sep + Config::OPTIONS_DIR +
+                          sep + Config::OPTIONS_CURRENT_DIRS_FILE;
   _current_dirs = new ConfigIO(filename, Config::APPLICATION_NAME + "CurrentDirs", true);
 #endif
 
@@ -337,7 +337,7 @@ int Controller::LoadMesh(Render *re, ViewLayer *view_layer, Depsgraph *depsgraph
   }
 
   soc QFileInfo qfi(iFileName);
-  soc string basename((const char*)qfi.fileName().toAscii().data());
+  soc string basename((const char *)qfi.fileName().toAscii().data());
   char cleaned[FILE_MAX];
   BLI_strncpy(cleaned, iFileName, FILE_MAX);
   BLI_cleanup_file(NULL, cleaned);
@@ -633,31 +633,31 @@ void Controller::ComputeSteerableViewMap()
   // Build 4 nodes containing the edges in the 4 directions
   NodeGroup *ng[Canvas::NB_STEERABLE_VIEWMAP];
   unsigned i;
-  real c = 32.0f/255.0f; // see SteerableViewMap::readSteerableViewMapPixel() for information about this 32.
+  real c =
+      32.0f /
+      255.0f;  // see SteerableViewMap::readSteerableViewMapPixel() for information about this 32.
   for (i = 0; i < Canvas::NB_STEERABLE_VIEWMAP; ++i) {
     ng[i] = new NodeGroup;
   }
   NodeShape *completeNS = new NodeShape;
-  completeNS->material().setDiffuse(c,c,c,1);
-  ng[Canvas::NB_STEERABLE_VIEWMAP-1]->AddChild(completeNS);
+  completeNS->material().setDiffuse(c, c, c, 1);
+  ng[Canvas::NB_STEERABLE_VIEWMAP - 1]->AddChild(completeNS);
   SteerableViewMap *svm = _Canvas->getSteerableViewMap();
   svm->Reset();
 
-  ViewMap::fedges_containerfedges = _ViewMap->FEdges();
+  ViewMap::fedges_container &fedges = _ViewMap->FEdges();
   LineRep *fRep;
   NodeShape *ns;
-  for (ViewMap::fedges_container::iterator f = fedges.begin(), fend = fedges.end();
-       f != fend;
-       ++f)
-  {
+  for (ViewMap::fedges_container::iterator f = fedges.begin(), fend = fedges.end(); f != fend;
+       ++f) {
     if ((*f)->viewedge()->qi() != 0)
       continue;
     fRep = new LineRep((*f)->vertexA()->point2d(), (*f)->vertexB()->point2d());
-    completeNS->AddRep(fRep); // add to the complete map anyway
+    completeNS->AddRep(fRep);  // add to the complete map anyway
     double *oweights = svm->AddFEdge(*f);
     for (i = 0; i < (Canvas::NB_STEERABLE_VIEWMAP - 1); ++i) {
       ns = new NodeShape;
-      double wc = oweights[i]*c;
+      double wc = oweights[i] * c;
       if (oweights[i] == 0)
         continue;
       ns->material().setDiffuse(wc, wc, wc, 1);
@@ -713,7 +713,6 @@ void Controller::ComputeSteerableViewMap()
 #  endif
   }
 
-
   svm->buildImagesPyramids(img, false, 0, 1.0f);
 #endif
 }
@@ -1085,10 +1084,11 @@ void Controller::displayDensityCurves(int x, int y)
   // display the curves
 #if 0
   for (i = 0; i < nbCurves; ++i)
-    _pDensityCurvesWindow->setOrientationCurve(i, Vec2d(0, 0), Vec2d(nbPoints, 1), curves[i], "scale", "density");
+    _pDensityCurvesWindow->setOrientationCurve(
+        i, Vec2d(0, 0), Vec2d(nbPoints, 1), curves[i], "scale", "density");
   for (i = 1; i <= 8; ++i)
-    _pDensityCurvesWindow->setLevelCurve(i, Vec2d(0, 0), Vec2d(nbCurves, 1), curvesDirection[i],
-                                         "orientation", "density");
+    _pDensityCurvesWindow->setLevelCurve(
+        i, Vec2d(0, 0), Vec2d(nbCurves, 1), curvesDirection[i], "orientation", "density");
   _pDensityCurvesWindow->show();
 #endif
 }
index be8553c..b287a51 100644 (file)
@@ -94,10 +94,22 @@ class Controller {
                       vector<ViewEdge *>::iterator vedges_end);
 
 #if 0
-  NodeGroup *debugNode() {return _DebugNode;}
-  AppView *view() {return _pView;}
-  NodeGroup *debugScene() {return _DebugNode;}
-  Grid& grid() {return _Grid;}
+  NodeGroup *debugNode()
+  {
+    return _DebugNode;
+  }
+  AppView *view()
+  {
+    return _pView;
+  }
+  NodeGroup *debugScene()
+  {
+    return _DebugNode;
+  }
+  Grid &grid()
+  {
+    return _Grid;
+  }
 #endif
 
   void toggleVisibilityAlgo();
@@ -192,7 +204,7 @@ class Controller {
 
 #if 0
   // Silhouette structure:
-  std::vector<SShape*> _SShapes;
+  std::vector<SShape *> _SShapes;
   NodeGroup *_SRoot;
 
   // Silhouette
index 6b14c9e..06a356d 100644 (file)
@@ -77,9 +77,9 @@ NodeGroup *BlenderFileLoader::Load()
 
 #if 0
   if (G.debug & G_DEBUG_FREESTYLE) {
-    cout << "Frustum: l " << _viewplane_left << " r " << _viewplane_right
-         << " b " << _viewplane_bottom << " t " << _viewplane_top
-         << " n " << _z_near << " f " << _z_far << endl;
+    cout << "Frustum: l " << _viewplane_left << " r " << _viewplane_right << " b "
+         << _viewplane_bottom << " t " << _viewplane_top << " n " << _z_near << " f " << _z_far
+         << endl;
   }
 #endif
 
@@ -143,7 +143,9 @@ int BlenderFileLoader::countClippedFaces(float v1[3], float v2[3], float v3[3],
     }
 #if 0
     if (G.debug & G_DEBUG_FREESTYLE) {
-      printf("%d %s\n", i, (clip[i] == NOT_CLIPPED) ? "not" : (clip[i] == CLIPPED_BY_NEAR) ? "near" : "far");
+      printf("%d %s\n",
+             i,
+             (clip[i] == NOT_CLIPPED) ? "not" : (clip[i] == CLIPPED_BY_NEAR) ? "near" : "far");
     }
 #endif
     sum += clip[i];
index 5fe98fb..dc6677b 100644 (file)
@@ -98,7 +98,10 @@ class BlenderFileLoader {
 
 #if 0
   /*! Gets the smallest edge size read */
-  inline real minEdgeSize() {return _minEdgeSize;}
+  inline real minEdgeSize()
+  {
+    return _minEdgeSize;
+  }
 #endif
 
   /*! Modifiers */
index 47e2fef..082ed34 100644 (file)
@@ -190,7 +190,7 @@ BlenderStrokeRenderer::~BlenderStrokeRenderer()
     char *name = ob->id.name;
 #if 0
     if (G.debug & G_DEBUG_FREESTYLE) {
-      cout << "removing " << name[0] << name[1] << ":" << (name+2) << endl;
+      cout << "removing " << name[0] << name[1] << ":" << (name + 2) << endl;
     }
 #endif
     switch (ob->type) {
@@ -598,7 +598,8 @@ int BlenderStrokeRenderer::get_stroke_count() const
 void BlenderStrokeRenderer::GenerateStrokeMesh(StrokeGroup *group, bool hasTex)
 {
 #if 0
-  Object *object_mesh = BKE_object_add(freestyle_bmain, freestyle_scene, (ViewLayer *)freestyle_scene->view_layers.first, OB_MESH);
+  Object *object_mesh = BKE_object_add(
+      freestyle_bmain, freestyle_scene, (ViewLayer *)freestyle_scene->view_layers.first, OB_MESH);
   DEG_relations_tag_update(freestyle_bmain);
 #else
   Object *object_mesh = NewMesh();
index b34828f..5fedf94 100644 (file)
@@ -240,7 +240,7 @@ class IndexedVertex {
 };
 
 #if 0
-bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2)
+bool operator<(const IndexedVertex &iv1, const IndexedVertex &iv2)
 {
   return iv1.operator<(iv2);
 }
index 6a95e54..51afb5c 100644 (file)
@@ -63,7 +63,8 @@ void firstIntersectionGridVisitor::examineOccluder(Polygon3r *occ)
                 current_cell_->getOrigin() + cell_size_)) {
 #if 0
         Vec3d bboxdiag(_scene3d->bbox().getMax() - _scene3d->bbox().getMin());
-        if ((t > 1.0e-06 * (min(min(bboxdiag.x(), bboxdiag.y()), bboxdiag.z()))) && (t < raylength)) {
+        if ((t > 1.0e-06 * (min(min(bboxdiag.x(), bboxdiag.y()), bboxdiag.z()))) &&
+            (t < raylength)) {
 #else
         if (tmp_t < t_) {
 #endif
index ad8a947..739f880 100644 (file)
@@ -211,8 +211,8 @@ class Polygon3r : public Polygon<Vec3r> {
                            real epsilon = M_EPSILON) const
   {
 #if 0
-  if (_vertices.size() < 3)
-    return false;
+    if (_vertices.size() < 3)
+      return false;
 #endif
     return GeomUtils::intersectRayTriangle(
         orig, dir, _vertices[0], _vertices[1], _vertices[2], t, u, v, epsilon);
index 04797bc..81b0fd9 100644 (file)
@@ -226,8 +226,8 @@ template<class T, class Point> class SweepLine {
   inline void process(Point &p,
                       vector<Segment<T, Point> *> &segments,
 #if 0
-                      binary_rule<Segment<T, Point>,Segment<T, Point> >& binrule = \
-                              binary_rule<Segment<T, Point>, Segment<T, Point> >(),
+                      binary_rule<Segment<T, Point>, Segment<T, Point>> &binrule =
+                          binary_rule<Segment<T, Point>, Segment<T, Point>>(),
 #else
                       binary_rule<Segment<T, Point>, Segment<T, Point>> &binrule,
 #endif
@@ -249,8 +249,8 @@ template<class T, class Point> class SweepLine {
 
   inline void add(Segment<T, Point> *S,
 #if 0
-                  binary_rule<Segment<T, Point>, Segment<T, Point> >& binrule = \
-                          binary_rule<Segment<T, Point>, Segment<T, Point> >(),
+                  binary_rule<Segment<T, Point>, Segment<T, Point>> &binrule =
+                      binary_rule<Segment<T, Point>, Segment<T, Point>>(),
 #else
                   binary_rule<Segment<T, Point>, Segment<T, Point>> &binrule,
 #endif
index 22fcd3a..b9cf604 100644 (file)
@@ -796,24 +796,22 @@ template<class T, unsigned N> class SquareMatrix : public Matrix<T, N, N> {
 /////////////////////////////////////////////////////////////////////////////
 
 #if 0
-template <class T, unsigned N>
-inline Vec<T, N> operator+(const Vec<T, N>& v1, const Vec<T, N>& v2)
+template<class T, unsigned N> inline Vec<T, N> operator+(const Vec<T, N> &v1, const Vec<T, N> &v2)
 {
   Vec<T, N> res(v1);
   res += v2;
   return res;
 }
 
-template <class T, unsigned N>
-inline Vec<T, N> operator-(const Vec<T, N>& v1, const Vec<T, N>& v2)
+template<class T, unsigned N> inline Vec<T, N> operator-(const Vec<T, N> &v1, const Vec<T, N> &v2)
 {
   Vec<T, N> res(v1);
   res -= v2;
   return res;
 }
 
-template <class T, unsigned N>
-inline Vec<T, N> operator*(const Vec<T, N>v, const typename Vec<T, N>::value_type r)
+template<class T, unsigned N>
+inline Vec<T, N> operator*(const Vec<T, N> &v, const typename Vec<T, N>::value_type r)
 {
   Vec<T, N> res(v);
   res *= r;
@@ -830,8 +828,8 @@ inline Vec<T, N> operator*(const typename Vec<T, N>::value_type r, const Vec<T,
 }
 
 #if 0
-template <class T, unsigned N>
-inline Vec<T, N> operator/(const Vec<T, N>v, const typename Vec<T, N>::value_type r)
+template<class T, unsigned N>
+inline Vec<T, N> operator/(const Vec<T, N> &v, const typename Vec<T, N>::value_type r)
 {
   Vec<T, N> res(v);
   if (r)
@@ -840,8 +838,8 @@ inline Vec<T, N> operator/(const Vec<T, N>& v, const typename Vec<T, N>::value_t
 }
 
 // dot product
-template <class T, unsigned N>
-inline typename Vec<T, N>::value_type operator*(const Vec<T, N>& v1, const Vec<T, N>& v2)
+template<class T, unsigned N>
+inline typename Vec<T, N>::value_type operator*(const Vec<T, N> &v1, const Vec<T, N> &v2)
 {
   typename Vec<T, N>::value_type sum = 0;
   for (unsigned int i = 0; i < N; i++)
@@ -850,10 +848,10 @@ inline typename Vec<T, N>::value_type operator*(const Vec<T, N>& v1, const Vec<T
 }
 
 // cross product for 3D Vectors
-template <typename T>
-inline Vec3<T> operator^(const Vec<T, 3>& v1, const Vec<T, 3>& v2)
+template<typename T> inline Vec3<T> operator^(const Vec<T, 3> &v1, const Vec<T, 3> &v2)
 {
-  Vec3<T> res(v1[1] * v2[2] - v1[2] * v2[1], v1[2] * v2[0] - v1[0] * v2[2], v1[0] * v2[1] - v1[1] * v2[0]);
+  Vec3<T> res(
+      v1[1] * v2[2] - v1[2] * v2[1], v1[2] * v2[0] - v1[0] * v2[2], v1[0] * v2[1] - v1[1] * v2[0]);
   return res;
 }
 #endif
index caf4693..12d322d 100644 (file)
@@ -30,9 +30,9 @@ using namespace std;
 namespace Freestyle {
 
 #if 0
-ImagePyramid::ImagePyramid(const GrayImagelevel0, unsigned nbLevels)
+ImagePyramid::ImagePyramid(const GrayImage &level0, unsigned nbLevels)
 {
-  BuildPyramid(level0,nbLevels);
+  BuildPyramid(level0, nbLevels);
 }
 #endif
 
index 30d05ee..ae87b77 100644 (file)
@@ -48,7 +48,7 @@ NodeCamera::NodeCamera(CameraType camera_type) : camera_type_(camera_type)
 }
 
 #if 0 /* UNUSED, gives warning in gcc */
-NodeCamera::NodeCamera(const NodeCameraiBrother) : camera_type_(iBrother.camera_type_)
+NodeCamera::NodeCamera(const NodeCamera &iBrother) : camera_type_(iBrother.camera_type_)
 {
   memcpy(modelview_matrix_, iBrother.modelview_matrix_, 16 * sizeof(double));
   memcpy(projection_matrix_, iBrother.projection_matrix_, 16 * sizeof(double));
index c3c93fa..2878e7a 100644 (file)
@@ -47,7 +47,7 @@ class NodeCamera : public Node {
   /*! Default matrices: Identity for both projection and modelview. */
   NodeCamera(CameraType camera_type = GENERIC);
 #if 0 /* UNUSED, gives warning in gcc */
-  NodeCamera(const NodeCameraiBrother);
+  NodeCamera(const NodeCamera &iBrother);
 #endif
 
   virtual ~NodeCamera()
index f730925..a0709b0 100644 (file)
@@ -253,12 +253,18 @@ FEdge *CurvePoint::getFEdge(Interface0D &inter)
   if (G.debug & G_DEBUG_FREESTYLE) {
     printf("__A           0x%p p (%f, %f)\n", __A, __A->getPoint2D().x(), __A->getPoint2D().y());
     printf("__B           0x%p p (%f, %f)\n", __B, __B->getPoint2D().x(), __B->getPoint2D().y());
-    printf("iVertexB->A() 0x%p p (%f, %f)\n", iVertexB->A(), iVertexB->A()->getPoint2D().x(),
-                                              iVertexB->A()->getPoint2D().y());
-    printf("iVertexB->B() 0x%p p (%f, %f)\n", iVertexB->B(), iVertexB->B()->getPoint2D().x(),
-                                              iVertexB->B()->getPoint2D().y());
+    printf("iVertexB->A() 0x%p p (%f, %f)\n",
+           iVertexB->A(),
+           iVertexB->A()->getPoint2D().x(),
+           iVertexB->A()->getPoint2D().y());
+    printf("iVertexB->B() 0x%p p (%f, %f)\n",
+           iVertexB->B(),
+           iVertexB->B()->getPoint2D().x(),
+           iVertexB->B()->getPoint2D().y());
     printf("_t2d            %f p (%f, %f)\n", _t2d, getPoint2D().x(), getPoint2D().y());
-    printf("iVertexB->t2d() %f p (%f, %f)\n", iVertexB->t2d(), iVertexB->getPoint2D().x(),
+    printf("iVertexB->t2d() %f p (%f, %f)\n",
+           iVertexB->t2d(),
+           iVertexB->getPoint2D().x(),
            iVertexB->getPoint2D().y());
   }
 #endif
@@ -315,7 +321,6 @@ float CurvePoint::shape_importance() const
   return __A->shape_importance();
 }
 
-
 const unsigned CurvePoint::qi() const
 {
   if (__A == 0)
@@ -404,18 +409,18 @@ real CurvePoint::z_discontinuity() const
 #if 0
 float CurvePoint::local_average_depth() const
 {
-  return local_average_depth_function<CurvePoint >(this);
+  return local_average_depth_function<CurvePoint>(this);
 }
 
 float CurvePoint::local_depth_variance() const
 {
-  return local_depth_variance_function<CurvePoint >(this);
+  return local_depth_variance_function<CurvePoint>(this);
 }
 
 real CurvePoint::local_average_density(float sigma) const
 {
   //return local_average_density<CurvePoint >(this);
-  return density_function<CurvePoint >(this);
+  return density_function<CurvePoint>(this);
 }
 
 Vec3r shaded_color() const;
@@ -484,7 +489,7 @@ real CurvePoint::curvatureFredo() const
   return ((1 - _t2d) * __A->curvatureFredo() + _t2d * __B->curvatureFredo());
 }
 
-Vec2d CurvePoint::directionFredo () const
+Vec2d CurvePoint::directionFredo() const
 {
   if (__A == 0)
     return __B->directionFredo();
@@ -676,10 +681,9 @@ Vec3r Curve::orientation2d(point_iterator it) const
   return (*it)->orientation2d();
 }
 
-template <class BaseVertex>
-Vec3r Curve::orientation2d(int iCombination) const
+template<class BaseVertex> Vec3r Curve::orientation2d(int iCombination) const
 {
-  return edge_orientation2d_function<Curve >(this, iCombination);
+  return edge_orientation2d_function<Curve>(this, iCombination);
 }
 
 Vec3r Curve::orientation3d(point_iterator it) const
@@ -689,7 +693,7 @@ Vec3r Curve::orientation3d(point_iterator it) const
 
 Vec3r Curve::orientation3d(int iCombination) const
 {
-  return edge_orientation3d_function<Curve >(this, iCombination);
+  return edge_orientation3d_function<Curve>(this, iCombination);
 }
 
 real curvature2d(point_iterator it) const
@@ -702,7 +706,7 @@ real curvature2d(int iCombination = 0) const;
 Material Curve::material() const
 {
   const_vertex_iterator v = vertices_begin(), vend = vertices_end();
-  const Materialmat = (*v)->material();
+  const Material &mat = (*v)->material();
   for (; v != vend; ++v) {
     if ((*v)->material() != mat)
       Exception::raiseException();
@@ -747,7 +751,7 @@ bool Curve::occluders_empty() const
   return empty;
 }
 
-const Polygon3roccludee() const
+const Polygon3r &occludee() const
 {
   return *(_FEdgeA->aFace());
 }
@@ -789,7 +793,6 @@ int Curve::shape_id() const
   return id.first;
 }
 
-
 const SShape *Curve::shape() const
 {
   const_vertex_iterator v = vertices_begin(), vend = vertices_end();
@@ -801,14 +804,12 @@ const SShape *Curve::shape() const
   return sshape;
 }
 
-
 occluder_container::const_iterator Curve::occluders_begin() const
 {
   const_vertex_iterator v = vertices_begin();
   return (*v)->occluders_begin();
 }
 
-
 occluder_container::const_iterator Curve::occluders_end() const
 {
   const_vertex_iterator v = vertices_end();
@@ -835,7 +836,7 @@ float Curve::local_average_depth(int iCombination) const
   return local_average_depth_edge_function<Curve>(this, iCombination);
 }
 
-float Curve::local_depth_variance(int iCombination ) const
+float Curve::local_depth_variance(int iCombination) const
 {
   return local_depth_variance_edge_function<Curve>(this, iCombination);
 #  if 0
@@ -846,7 +847,7 @@ float Curve::local_depth_variance(int iCombination ) const
 #  endif
 }
 
-real Curve::local_average_density(float sigma, int iCombination ) const
+real Curve::local_average_density(float sigma, int iCombination) const
 {
   return density_edge_function<Curve>(this, iCombination);
 #  if 0
@@ -860,7 +861,7 @@ real Curve::local_average_density(float sigma, int iCombination ) const
 /* UNUSED */
 // #define EPS_CURVA_DIR 0.01
 
-void Curve::computeCurvatureAndOrientation ()
+void Curve::computeCurvatureAndOrientation()
 {
   const_vertex_iterator v = vertices_begin(), vend = vertices_end(), v2, prevV, v0;
   Vec2d p0, p1, p2;
@@ -874,7 +875,7 @@ void Curve::computeCurvatureAndOrientation ()
   p1 = Vec2d(p[0], p[1]);
   Vec2d prevDir(p1 - p0);
 
-  for (; v! = vend; ++v) {
+  for (; v ! = vend; ++v) {
     v2 = v;
     ++v2;
     if (v2 == vend)
index 234f9df..2a1d80f 100644 (file)
@@ -525,7 +525,7 @@ class Curve : public Interface1D {
   int occluders_size() const;
   bool occluders_empty() const;
 
-  const Polygon3roccludee() const
+  const Polygon3r &occludee() const
   {
     return *(_FEdgeA->aFace());
   }
index 3cd55fa..f993c21 100644 (file)
@@ -66,7 +66,7 @@ class __point_iterator : public IteratorBase<Traits, BidirectionalIteratorTag_Tr
   typedef __point_iterator<CurvePoint_const_traits> const_iterator;
 
 #if 0
-  typedef Vertex vertex_type ;
+  typedef Vertex vertex_type;
   typedef vertex_container_iterator vertex_iterator_type;
   typedef CurvePoint<Vertex> Point;
   typedef Point point_type;
@@ -76,7 +76,8 @@ class __point_iterator : public IteratorBase<Traits, BidirectionalIteratorTag_Tr
 #  if defined(__GNUC__) && (__GNUC__ < 3)
   typedef bidirectional_iterator<CurvePoint<Vertex>, ptrdiff_t> bidirectional_point_iterator;
 #  else
-  typedef iterator<bidirectional_iterator_tag, CurvePoint<Vertex>, ptrdiff_t> bidirectional_point_iterator;
+  typedef iterator<bidirectional_iterator_tag, CurvePoint<Vertex>, ptrdiff_t>
+      bidirectional_point_iterator;
 #  endif
 #endif
   friend class Curve;
index 2c8a83e..fc4d099 100644 (file)
@@ -206,7 +206,9 @@ error:
 }
 
 #if 0
-void Operators::bidirectionalChain(ViewEdgeIterator& it, UnaryPredicate1D& pred, UnaryFunction1D_void& modifier)
+void Operators::bidirectionalChain(ViewEdgeIterator &it,
+                                   UnaryPredicate1D &pred,
+                                   UnaryFunction1D_void &modifier)
 {
   if (_current_view_edges_set.empty())
     return;
@@ -217,12 +219,11 @@ void Operators::bidirectionalChain(ViewEdgeIterator& it, UnaryPredicate1D& pred,
 
   for (I1DContainer::iterator it_edge = _current_view_edges_set.begin();
        it_edge != _current_view_edges_set.end();
-       ++it_edge)
-  {
+       ++it_edge) {
     if (pred(**it_edge))
       continue;
 
-    edge = dynamic_cast<ViewEdge*>(*it_edge);
+    edge = dynamic_cast<ViewEdge *>(*it_edge);
     it.setBegin(edge);
     it.setCurrentEdge(edge);
 
@@ -253,7 +254,7 @@ void Operators::bidirectionalChain(ViewEdgeIterator& it, UnaryPredicate1D& pred,
     _current_set = &_current_chains_set;
 }
 
-void Operators::bidirectionalChain(ViewEdgeIterator& it, UnaryPredicate1D& pred)
+void Operators::bidirectionalChain(ViewEdgeIterator &it, UnaryPredicate1D &pred)
 {
   if (_current_view_edges_set.empty())
     return;
@@ -267,12 +268,11 @@ void Operators::bidirectionalChain(ViewEdgeIterator& it, UnaryPredicate1D& pred)
 
   for (I1DContainer::iterator it_edge = _current_view_edges_set.begin();
        it_edge != _current_view_edges_set.end();
-       ++it_edge)
-  {
+       ++it_edge) {
     if (pred(**it_edge) || pred_ts(**it_edge))
       continue;
 
-    edge = dynamic_cast<ViewEdge*>(*it_edge);
+    edge = dynamic_cast<ViewEdge *>(*it_edge);
     it.setBegin(edge);
     it.setCurrentEdge(edge);
 
@@ -835,7 +835,7 @@ static int __recursiveSplit(Chain *_curve,
   CurveInternal::CurvePointIterator split = second;
   Interface0DIterator it0d = it.castToInterface0DIterator();
 #if 0
-  real _min                                  = func(it0d);
+  real _min = func(it0d);
   ++it;
 #endif
   real _min = FLT_MAX;
index 7b6e531..ef40865 100644 (file)
@@ -834,7 +834,6 @@ Stroke::vertex_container::reverse_iterator Stroke::vertices_last(float sampling)
   return _Vertices.rbegin();
 }
 
-
 inline Vec3r shaded_color(int iCombination = 0) const;
 
 inline Vec<3, real> Stroke::orientation2d(const_vertex_iterator it) const
@@ -871,7 +870,7 @@ Material Stroke::material() const
 int Stroke::qi() const
 {
   const_vertex_iterator v = vertices_begin(), vend = vertices_end();
-  int qi_= (*v)->qi();
+  int qi_ = (*v)->qi();
   for (; v != vend; ++v) {
     if ((*v)->qi() != qi_)
       Exception::raiseException();
@@ -965,10 +964,9 @@ float Stroke::shape_importance(int iCombination) const
   return shape_importance_edge_function<Stroke>(*this, iCombination);
 }
 
-
-float Stroke::local_average_depth(int iCombination ) const
+float Stroke::local_average_depth(int iCombination) const
 {
-  return local_average_depth_edge_function<Stroke >(*this, iCombination);
+  return local_average_depth_edge_function<Stroke>(*this, iCombination);
 }
 
 float Stroke::local_depth_variance(int iCombination) const
@@ -976,7 +974,7 @@ float Stroke::local_depth_variance(int iCombination) const
   return local_depth_variance_edge_function<Stroke>(*this, iCombination);
 }
 
-real Stroke::local_average_density(float sigma , int iCombination ) const
+real Stroke::local_average_density(float sigma, int iCombination) const
 {
   return density_edge_function<Stroke>(*this, iCombination);
 }
index 026a7b2..f1483e8 100644 (file)
@@ -105,7 +105,7 @@ static bool notValid(Vec2r p)
 }
 
 #if 0
-static real crossP(const Vec2r& A, const Vec2r& B)
+static real crossP(const Vec2r &A, const Vec2r &B)
 {
   return A[0] * B[1] - A[1] * B[0];
 }
@@ -498,8 +498,8 @@ void Strip::setVertexColor(const vector<StrokeVertex *> &iStrokeVertices)
     _vertices[i]->setAlpha(sv->attribute().getAlpha());
     i++;
 #if 0
-    cerr << "col=("<<sv->attribute().getColor()[0] << ", "
-         << sv->attribute().getColor()[1] << ", " << sv->attribute().getColor()[2] << ")" << endl;
+    cerr << "col=(" << sv->attribute().getColor()[0] << ", " << sv->attribute().getColor()[1]
+         << ", " << sv->attribute().getColor()[2] << ")" << endl;
 #endif
   }
 }
@@ -545,8 +545,8 @@ void Strip::computeTexCoordWithTips(const vector<StrokeVertex *> &iStrokeVertice
   fact = (float(tiles) + 0.5) / l;
 
 #if 0
-  cerr << "l=" << l << "  tiles=" << tiles << "    _averageThicnkess="
-       << _averageThickness << "    strokeLength=" << (*v)->strokeLength() << endl;
+  cerr << "l=" << l << "  tiles=" << tiles << "    _averageThicnkess=" << _averageThickness
+       << "    strokeLength=" << (*v)->strokeLength() << endl;
 #endif
 
   vector<StrokeVertexRep *>::iterator currentSV = _vertices.begin();
@@ -690,7 +690,7 @@ void Strip::computeTexCoordWithTips(const vector<StrokeVertex *> &iStrokeVertice
 
   for (i = 0; i < _sizeStrip; i++)
     cerr << "(" << _texCoord[i][0] << ", " << _texCoord[i][1] << ") ";
-    cerr << endl;
+  cerr << endl;
 
   Vec2r vec_tmp;
   for (i = 0; i < _sizeStrip / 2; i++)
@@ -718,7 +718,7 @@ StrokeRep::StrokeRep()
   if (ptm)
     _textureId = ptm->getDefaultTextureId();
 #if 0
-  _averageTextureAlpha = 0.5; //default value
+  _averageTextureAlpha = 0.5;  //default value
   if (_strokeType == OIL_STROKE)
     _averageTextureAlpha = 0.75;
   if (_strokeType >= NO_BLEND_STROKE)
@@ -749,7 +749,7 @@ StrokeRep::StrokeRep(Stroke *iStroke)
   }
 
 #if 0
-  _averageTextureAlpha = 0.5; //default value
+  _averageTextureAlpha = 0.5;  //default value
   if (_strokeType == OIL_STROKE)
     _averageTextureAlpha = 0.75;
   if (_strokeType >= NO_BLEND_STROKE)
index bb2b95b..1de4a87 100644 (file)
@@ -425,8 +425,7 @@ void FEdgeXDetector::ProcessRidgeFace(WXFace *iFace)
 
   if (flayer->nPosDotP() != numVertices) {
     if ((fabs(flayer->dotP(0)) < threshold) && (fabs(flayer->dotP(1)) < threshold) &&
-        (fabs(flayer->dotP(2)) < threshold))
-    {
+        (fabs(flayer->dotP(2)) < threshold)) {
       flayer->ReplaceDotP(0, 0);
       flayer->ReplaceDotP(1, 0);
       flayer->ReplaceDotP(2, 0);
@@ -443,7 +442,7 @@ void FEdgeXDetector::ProcessRidgeFace(WXFace *iFace)
   WVertex *v;
   Vec3r v1v2;
   real t;
-  vector<WXFaceLayer*> SmoothLayers;
+  vector<WXFaceLayer *> SmoothLayers;
   WXFaceLayer *faceLayer;
   Face_Curvature_Info *layer_info;
   real K1_a(0), K1_b(0);
@@ -451,7 +450,7 @@ void FEdgeXDetector::ProcessRidgeFace(WXFace *iFace)
 
   // find the ridge layer of the face
   iFace->retrieveSmoothLayers(Nature::RIDGE, SmoothLayers);
-  if ( SmoothLayers.size()!=1 )
+  if (SmoothLayers.size() != 1)
     return;
   faceLayer = SmoothLayers[0];
   // retrieve the curvature info of this layer
@@ -461,27 +460,28 @@ void FEdgeXDetector::ProcessRidgeFace(WXFace *iFace)
   for (int i = 0; i < numVertices; i++) {
     v = iFace->GetVertex(i);
     // vec_curvature_info[i] contains the curvature info of this vertex
-    Vec3r e2 = layer_info->vec_curvature_info[i]->K2*layer_info->vec_curvature_info[i]->e2;
-    Vec3r e1 = layer_info->vec_curvature_info[i]->K1*layer_info->vec_curvature_info[i]->e1;
+    Vec3r e2 = layer_info->vec_curvature_info[i]->K2 * layer_info->vec_curvature_info[i]->e2;
+    Vec3r e1 = layer_info->vec_curvature_info[i]->K1 * layer_info->vec_curvature_info[i]->e1;
     e2.normalize();
 
     WVertex::face_iterator fit = v->faces_begin();
     WVertex::face_iterator fitend = v->faces_end();
     for (; fit != fitend; ++fit) {
-      WXFace *wxf = dynamic_cast<WXFace*>(*fit);
+      WXFace *wxf = dynamic_cast<WXFace *>(*fit);
       WOEdge *oppositeEdge;
       if (!(wxf->getOppositeEdge(v, oppositeEdge)))
         continue;
       v1v2 = oppositeEdge->GetbVertex()->GetVertex() - oppositeEdge->GetaVertex()->GetVertex();
       GeomUtils::intersection_test res;
-      res = GeomUtils::intersectRayPlane(oppositeEdge->GetaVertex()->GetVertex(), v1v2, e2, -(v->GetVertex()*e2),
-                                         t, 1.0e-06);
+      res = GeomUtils::intersectRayPlane(
+          oppositeEdge->GetaVertex()->GetVertex(), v1v2, e2, -(v->GetVertex() * e2), t, 1.0e-06);
       if ((res == GeomUtils::DO_INTERSECT) && (t >= 0.0) && (t <= 1.0)) {
-        vector<WXFaceLayer*> second_