spaces -> tabs, (4 spaces == 1 tab, only for white space preceding text)
authorCampbell Barton <ideasman42@gmail.com>
Mon, 22 Mar 2010 09:30:00 +0000 (09:30 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 22 Mar 2010 09:30:00 +0000 (09:30 +0000)
326 files changed:
source/blender/avi/AVI_avi.h
source/blender/avi/intern/avi.c
source/blender/avi/intern/codecs.c
source/blender/avi/intern/mjpeg.c
source/blender/avi/intern/options.c
source/blender/blenkernel/BKE_DerivedMesh.h
source/blender/blenkernel/BKE_bmesh.h
source/blender/blenkernel/BKE_booleanops.h
source/blender/blenkernel/BKE_cdderivedmesh.h
source/blender/blenkernel/BKE_context.h
source/blender/blenkernel/BKE_customdata.h
source/blender/blenkernel/BKE_displist.h
source/blender/blenkernel/BKE_idprop.h
source/blender/blenkernel/BKE_lattice.h
source/blender/blenkernel/BKE_modifier.h
source/blender/blenkernel/BKE_paint.h
source/blender/blenkernel/BKE_softbody.h
source/blender/blenkernel/BKE_subsurf.h
source/blender/blenkernel/intern/BME_Customdata.c
source/blender/blenkernel/intern/BME_eulers.c
source/blender/blenkernel/intern/BME_mesh.c
source/blender/blenkernel/intern/CCGSubSurf.c
source/blender/blenkernel/intern/DerivedMesh.c
source/blender/blenkernel/intern/action.c
source/blender/blenkernel/intern/anim.c
source/blender/blenkernel/intern/anim_sys.c
source/blender/blenkernel/intern/armature.c
source/blender/blenkernel/intern/bmfont.c
source/blender/blenkernel/intern/booleanops.c
source/blender/blenkernel/intern/brush.c
source/blender/blenkernel/intern/bvhutils.c
source/blender/blenkernel/intern/cdderivedmesh.c
source/blender/blenkernel/intern/cloth.c
source/blender/blenkernel/intern/colortools.c
source/blender/blenkernel/intern/constraint.c
source/blender/blenkernel/intern/curve.c
source/blender/blenkernel/intern/customdata.c
source/blender/blenkernel/intern/depsgraph.c
source/blender/blenkernel/intern/displist.c
source/blender/blenkernel/intern/effect.c
source/blender/blenkernel/intern/exotic.c
source/blender/blenkernel/intern/fluidsim.c
source/blender/blenkernel/intern/fmodifier.c
source/blender/blenkernel/intern/font.c
source/blender/blenkernel/intern/idprop.c
source/blender/blenkernel/intern/image.c
source/blender/blenkernel/intern/image_gen.c
source/blender/blenkernel/intern/ipo.c
source/blender/blenkernel/intern/key.c
source/blender/blenkernel/intern/lattice.c
source/blender/blenkernel/intern/library.c
source/blender/blenkernel/intern/material.c
source/blender/blenkernel/intern/mball.c
source/blender/blenkernel/intern/mesh.c
source/blender/blenkernel/intern/modifier.c
source/blender/blenkernel/intern/multires.c
source/blender/blenkernel/intern/node.c
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/particle.c
source/blender/blenkernel/intern/particle_system.c
source/blender/blenkernel/intern/pointcache.c
source/blender/blenkernel/intern/sca.c
source/blender/blenkernel/intern/scene.c
source/blender/blenkernel/intern/seqeffects.c
source/blender/blenkernel/intern/sequencer.c
source/blender/blenkernel/intern/smoke.c
source/blender/blenkernel/intern/softbody.c
source/blender/blenkernel/intern/subsurf_ccg.c
source/blender/blenkernel/intern/text.c
source/blender/blenkernel/intern/texture.c
source/blender/blenkernel/intern/world.c
source/blender/blenkernel/intern/writeffmpeg.c
source/blender/blenkernel/intern/writeframeserver.c
source/blender/blenlib/BLI_pbvh.h
source/blender/blenlib/BLI_vfontdata.h
source/blender/blenlib/intern/BLI_bfile.c
source/blender/blenlib/intern/BLI_ghash.c
source/blender/blenlib/intern/BLI_kdopbvh.c
source/blender/blenlib/intern/BLI_linklist.c
source/blender/blenlib/intern/boxpack2d.c
source/blender/blenlib/intern/bpath.c
source/blender/blenlib/intern/dynamiclist.c
source/blender/blenlib/intern/edgehash.c
source/blender/blenlib/intern/fnmatch.c
source/blender/blenlib/intern/freetypefont.c
source/blender/blenlib/intern/math_base.c
source/blender/blenlib/intern/math_color.c
source/blender/blenlib/intern/math_geom.c
source/blender/blenlib/intern/math_matrix.c
source/blender/blenlib/intern/math_rotation.c
source/blender/blenlib/intern/math_vector_inline.c
source/blender/blenlib/intern/noise.c
source/blender/blenlib/intern/path_util.c
source/blender/blenlib/intern/pbvh.c
source/blender/blenlib/intern/scanfill.c
source/blender/blenlib/intern/storage.c
source/blender/blenlib/intern/string.c
source/blender/blenlib/intern/voxel.c
source/blender/blenlib/intern/winstuff.c
source/blender/blenloader/intern/readfile.c
source/blender/editors/animation/anim_filter.c
source/blender/editors/animation/anim_markers.c
source/blender/editors/animation/keyframes_edit.c
source/blender/editors/animation/keyframes_general.c
source/blender/editors/armature/editarmature.c
source/blender/editors/armature/meshlaplacian.c
source/blender/editors/armature/poseobject.c
source/blender/editors/curve/curve_intern.h
source/blender/editors/curve/editcurve.c
source/blender/editors/curve/editfont.c
source/blender/editors/include/ED_anim_api.h
source/blender/editors/include/ED_numinput.h
source/blender/editors/include/ED_sculpt.h
source/blender/editors/include/UI_interface.h
source/blender/editors/include/UI_resources.h
source/blender/editors/interface/interface.c
source/blender/editors/interface/interface_draw.c
source/blender/editors/interface/interface_layout.c
source/blender/editors/interface/interface_panel.c
source/blender/editors/interface/interface_templates.c
source/blender/editors/interface/interface_widgets.c
source/blender/editors/mesh/editface.c
source/blender/editors/mesh/editmesh_lib.c
source/blender/editors/mesh/editmesh_loop.c
source/blender/editors/mesh/editmesh_mods.c
source/blender/editors/mesh/editmesh_tools.c
source/blender/editors/mesh/mesh_data.c
source/blender/editors/mesh/meshtools.c
source/blender/editors/metaball/mball_edit.c
source/blender/editors/object/object_add.c
source/blender/editors/object/object_constraint.c
source/blender/editors/object/object_edit.c
source/blender/editors/object/object_lattice.c
source/blender/editors/object/object_modifier.c
source/blender/editors/object/object_relations.c
source/blender/editors/object/object_vgroup.c
source/blender/editors/physics/physics_fluid.c
source/blender/editors/render/render_shading.c
source/blender/editors/screen/glutil.c
source/blender/editors/screen/screen_edit.c
source/blender/editors/screen/screendump.c
source/blender/editors/sculpt_paint/paint_image.c
source/blender/editors/sculpt_paint/paint_intern.h
source/blender/editors/sculpt_paint/paint_ops.c
source/blender/editors/sculpt_paint/paint_stroke.c
source/blender/editors/sculpt_paint/paint_utils.c
source/blender/editors/sculpt_paint/paint_vertex.c
source/blender/editors/sculpt_paint/sculpt.c
source/blender/editors/space_action/space_action.c
source/blender/editors/space_buttons/space_buttons.c
source/blender/editors/space_console/console_ops.c
source/blender/editors/space_console/console_report.c
source/blender/editors/space_file/file_draw.c
source/blender/editors/space_file/filelist.c
source/blender/editors/space_file/fsmenu.h
source/blender/editors/space_file/space_file.c
source/blender/editors/space_image/image_buttons.c
source/blender/editors/space_image/space_image.c
source/blender/editors/space_logic/logic_window.c
source/blender/editors/space_nla/space_nla.c
source/blender/editors/space_node/drawnode.c
source/blender/editors/space_node/node_select.c
source/blender/editors/space_node/space_node.c
source/blender/editors/space_sequencer/sequencer_draw.c
source/blender/editors/space_sequencer/sequencer_edit.c
source/blender/editors/space_sequencer/sequencer_intern.h
source/blender/editors/space_sequencer/sequencer_scopes.c
source/blender/editors/space_sequencer/space_sequencer.c
source/blender/editors/space_text/text_draw.c
source/blender/editors/space_text/text_header.c
source/blender/editors/space_text/text_intern.h
source/blender/editors/space_text/text_ops.c
source/blender/editors/space_view3d/drawarmature.c
source/blender/editors/space_view3d/drawobject.c
source/blender/editors/space_view3d/view3d_draw.c
source/blender/editors/space_view3d/view3d_edit.c
source/blender/editors/space_view3d/view3d_header.c
source/blender/editors/space_view3d/view3d_ops.c
source/blender/editors/space_view3d/view3d_select.c
source/blender/editors/space_view3d/view3d_snap.c
source/blender/editors/space_view3d/view3d_view.c
source/blender/editors/transform/transform.c
source/blender/editors/transform/transform.h
source/blender/editors/transform/transform_constraints.c
source/blender/editors/transform/transform_conversions.c
source/blender/editors/transform/transform_ndofinput.c
source/blender/editors/transform/transform_ops.c
source/blender/editors/transform/transform_orientations.c
source/blender/editors/util/numinput.c
source/blender/editors/util/undo.c
source/blender/editors/uvedit/uvedit_draw.c
source/blender/editors/uvedit/uvedit_ops.c
source/blender/editors/uvedit/uvedit_parametrizer.c
source/blender/editors/uvedit/uvedit_parametrizer.h
source/blender/gpu/GPU_extensions.h
source/blender/gpu/intern/gpu_codegen.c
source/blender/gpu/intern/gpu_codegen.h
source/blender/gpu/intern/gpu_draw.c
source/blender/gpu/intern/gpu_extensions.c
source/blender/gpu/intern/gpu_material.c
source/blender/imbuf/intern/IMB_anim.h
source/blender/imbuf/intern/IMB_imginfo.h
source/blender/imbuf/intern/allocimbuf.c
source/blender/imbuf/intern/anim.c
source/blender/imbuf/intern/anim5.c
source/blender/imbuf/intern/bmp.c
source/blender/imbuf/intern/data.c
source/blender/imbuf/intern/dds/DirectDrawSurface.h
source/blender/imbuf/intern/divers.c
source/blender/imbuf/intern/jp2.c
source/blender/imbuf/intern/jpeg.c
source/blender/imbuf/intern/md5.c
source/blender/imbuf/intern/md5.h
source/blender/imbuf/intern/png.c
source/blender/imbuf/intern/radiance_hdr.c
source/blender/imbuf/intern/readimage.c
source/blender/imbuf/intern/scaling.c
source/blender/imbuf/intern/targa.c
source/blender/imbuf/intern/tiff.c
source/blender/imbuf/intern/util.c
source/blender/makesdna/DNA_ID.h
source/blender/makesdna/DNA_action_types.h
source/blender/makesdna/DNA_camera_types.h
source/blender/makesdna/DNA_cloth_types.h
source/blender/makesdna/DNA_constraint_types.h
source/blender/makesdna/DNA_lamp_types.h
source/blender/makesdna/DNA_modifier_types.h
source/blender/makesdna/DNA_object_force.h
source/blender/makesdna/DNA_object_types.h
source/blender/makesdna/DNA_scene_types.h
source/blender/makesdna/DNA_sdna_types.h
source/blender/makesdna/DNA_sensor_types.h
source/blender/makesdna/DNA_sequence_types.h
source/blender/makesdna/DNA_space_types.h
source/blender/makesdna/DNA_texture_types.h
source/blender/makesdna/DNA_vec_types.h
source/blender/makesdna/DNA_view3d_types.h
source/blender/makesdna/intern/makesdna.c
source/blender/makesrna/RNA_access.h
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_access.c
source/blender/makesrna/intern/rna_brush.c
source/blender/makesrna/intern/rna_color.c
source/blender/makesrna/intern/rna_controller.c
source/blender/makesrna/intern/rna_curve.c
source/blender/makesrna/intern/rna_fluidsim.c
source/blender/makesrna/intern/rna_image.c
source/blender/makesrna/intern/rna_key.c
source/blender/makesrna/intern/rna_lamp.c
source/blender/makesrna/intern/rna_main.c
source/blender/makesrna/intern/rna_material.c
source/blender/makesrna/intern/rna_mesh.c
source/blender/makesrna/intern/rna_modifier.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/intern/rna_object_api.c
source/blender/makesrna/intern/rna_scene.c
source/blender/makesrna/intern/rna_smoke.c
source/blender/makesrna/intern/rna_texture.c
source/blender/makesrna/intern/rna_userdef.c
source/blender/makesrna/intern/rna_wm.c
source/blender/makesrna/intern/rna_wm_api.c
source/blender/nodes/intern/CMP_nodes/CMP_channelMatte.c
source/blender/nodes/intern/CMP_nodes/CMP_colorMatte.c
source/blender/nodes/intern/CMP_nodes/CMP_colorSpill.c
source/blender/nodes/intern/CMP_nodes/CMP_crop.c
source/blender/nodes/intern/CMP_nodes/CMP_diffMatte.c
source/blender/nodes/intern/CMP_nodes/CMP_distanceMatte.c
source/blender/nodes/intern/CMP_nodes/CMP_gamma.c
source/blender/nodes/intern/CMP_nodes/CMP_image.c
source/blender/nodes/intern/CMP_nodes/CMP_math.c
source/blender/nodes/intern/CMP_nodes/CMP_rotate.c
source/blender/nodes/intern/CMP_nodes/CMP_sepcombHSVA.c
source/blender/nodes/intern/CMP_nodes/CMP_zcombine.c
source/blender/nodes/intern/CMP_util.c
source/blender/nodes/intern/CMP_util.h
source/blender/nodes/intern/SHD_nodes/SHD_squeeze.c
source/blender/nodes/intern/TEX_nodes/TEX_proc.c
source/blender/nodes/intern/TEX_util.c
source/blender/python/BPY_extern.h
source/blender/python/generic/Geometry.c
source/blender/python/generic/Mathutils.c
source/blender/python/generic/bgl.c
source/blender/python/generic/bpy_internal_import.c
source/blender/python/generic/euler.c
source/blender/python/generic/matrix.c
source/blender/python/generic/quat.c
source/blender/python/generic/vector.c
source/blender/python/intern/bpy.c
source/blender/python/intern/bpy_array.c
source/blender/python/intern/bpy_driver.c
source/blender/python/intern/bpy_props.c
source/blender/python/intern/bpy_rna.c
source/blender/python/intern/bpy_util.h
source/blender/quicktime/apple/quicktime_export.c
source/blender/quicktime/apple/quicktime_import.c
source/blender/readblenfile/test/test.c
source/blender/render/intern/include/rayobject.h
source/blender/render/intern/include/render_types.h
source/blender/render/intern/include/sunsky.h
source/blender/render/intern/include/zbuf.h
source/blender/render/intern/source/convertblender.c
source/blender/render/intern/source/gammaCorrectionTables.c
source/blender/render/intern/source/imagetexture.c
source/blender/render/intern/source/initrender.c
source/blender/render/intern/source/occlusion.c
source/blender/render/intern/source/pipeline.c
source/blender/render/intern/source/pixelblending.c
source/blender/render/intern/source/pixelshading.c
source/blender/render/intern/source/pointdensity.c
source/blender/render/intern/source/rendercore.c
source/blender/render/intern/source/shadbuf.c
source/blender/render/intern/source/sss.c
source/blender/render/intern/source/strand.c
source/blender/render/intern/source/sunsky.c
source/blender/render/intern/source/texture.c
source/blender/render/intern/source/volumetric.c
source/blender/render/intern/source/voxeldata.c
source/blender/render/intern/source/zbuf.c
source/blender/verify/intern/BLO_verify.c
source/blender/windowmanager/intern/wm_apple.c
source/blender/windowmanager/intern/wm_cursors.c
source/blender/windowmanager/intern/wm_draw.c
source/blender/windowmanager/intern/wm_gesture.c
source/blender/windowmanager/intern/wm_jobs.c
source/blender/windowmanager/intern/wm_operators.c
source/blender/windowmanager/intern/wm_subwindow.c

index 4249368..a3115e0 100644 (file)
@@ -175,7 +175,7 @@ typedef struct _AviStreamRec {
 } AviStreamRec;
 
 typedef struct _AviMovie {
-    FILE *fp; 
+       FILE *fp; 
        
        int type;
 #define AVI_MOVIE_READ  0
index 5be3955..a73dec5 100644 (file)
@@ -197,8 +197,8 @@ int AVI_is_avi (char *name) {
                return 0;
 
        if (GET_FCC (fp) != FCC("RIFF") ||
-           !GET_FCC (fp) ||
-           GET_FCC (fp) != FCC("AVI ")) {
+               !GET_FCC (fp) ||
+               GET_FCC (fp) != FCC("AVI ")) {
                ret = 0;
        } else {
                ret = 1;
@@ -228,19 +228,19 @@ int AVI_is_avi (char *name) {
                return 0;
 
        if (GET_FCC (movie.fp) != FCC("RIFF") ||
-           !(movie.size = GET_FCC (movie.fp))) {
-           fclose(movie.fp);
+               !(movie.size = GET_FCC (movie.fp))) {
+               fclose(movie.fp);
                return 0;
        }
 
        movie.header = &header;
 
        if (GET_FCC (movie.fp) != FCC("AVI ") ||
-           GET_FCC (movie.fp) != FCC("LIST") ||
-           !GET_FCC (movie.fp) ||
-           GET_FCC (movie.fp) != FCC("hdrl") ||
-           (movie.header->fcc = GET_FCC (movie.fp)) != FCC("avih") ||
-           !(movie.header->size = GET_FCC (movie.fp))) {
+               GET_FCC (movie.fp) != FCC("LIST") ||
+               !GET_FCC (movie.fp) ||
+               GET_FCC (movie.fp) != FCC("hdrl") ||
+               (movie.header->fcc = GET_FCC (movie.fp)) != FCC("avih") ||
+               !(movie.header->size = GET_FCC (movie.fp))) {
                DEBUG("bad initial header info\n");
                fclose(movie.fp);
                return 0;
@@ -274,10 +274,10 @@ int AVI_is_avi (char *name) {
        for (temp=0; temp < movie.header->Streams; temp++) {
 
                if (GET_FCC(movie.fp) != FCC("LIST") ||
-                   !GET_FCC (movie.fp) ||
-                   GET_FCC (movie.fp) != FCC ("strl") ||
-                   (movie.streams[temp].sh.fcc = GET_FCC (movie.fp)) != FCC ("strh") ||
-                   !(movie.streams[temp].sh.size = GET_FCC (movie.fp))) {
+                       !GET_FCC (movie.fp) ||
+                       GET_FCC (movie.fp) != FCC ("strl") ||
+                       (movie.streams[temp].sh.fcc = GET_FCC (movie.fp)) != FCC ("strh") ||
+                       !(movie.streams[temp].sh.size = GET_FCC (movie.fp))) {
                        DEBUG("bad stream header information\n");
                        
                        MEM_freeN(movie.streams);
@@ -357,7 +357,7 @@ int AVI_is_avi (char *name) {
                                
                                fcca = bi->Compression;
 
-                if ( movie.streams[temp].format ==
+                               if ( movie.streams[temp].format ==
                                         AVI_FORMAT_AVI_RGB) {
                                        if (fcca == FCC ("DIB ") ||
                                                fcca == FCC ("RGB ") ||
@@ -386,7 +386,7 @@ int AVI_is_avi (char *name) {
                                
                                MEM_freeN(movie.streams);
                                fclose(movie.fp);
-                           return 0;                           
+                               return 0;                               
                        }
                        fseek(movie.fp, temp, SEEK_CUR);                        
                }
@@ -417,17 +417,17 @@ AviError AVI_open_movie (char *name, AviMovie *movie) {
                return AVI_ERROR_OPEN;
 
        if (GET_FCC (movie->fp) != FCC("RIFF") ||
-           !(movie->size = GET_FCC (movie->fp)))
+               !(movie->size = GET_FCC (movie->fp)))
                return AVI_ERROR_FORMAT;
 
        movie->header = (AviMainHeader *) MEM_mallocN (sizeof (AviMainHeader), "movieheader");
 
        if (GET_FCC (movie->fp) != FCC("AVI ") ||
-           GET_FCC (movie->fp) != FCC("LIST") ||
-           !GET_FCC (movie->fp) ||
-           GET_FCC (movie->fp) != FCC("hdrl") ||
-           (movie->header->fcc = GET_FCC (movie->fp)) != FCC("avih") ||
-           !(movie->header->size = GET_FCC (movie->fp))) {
+               GET_FCC (movie->fp) != FCC("LIST") ||
+               !GET_FCC (movie->fp) ||
+               GET_FCC (movie->fp) != FCC("hdrl") ||
+               (movie->header->fcc = GET_FCC (movie->fp)) != FCC("avih") ||
+               !(movie->header->size = GET_FCC (movie->fp))) {
                DEBUG("bad initial header info\n");
                return AVI_ERROR_FORMAT;
        }
@@ -459,10 +459,10 @@ AviError AVI_open_movie (char *name, AviMovie *movie) {
        for (temp=0; temp < movie->header->Streams; temp++) {
 
                if (GET_FCC(movie->fp) != FCC("LIST") ||
-                   !GET_FCC (movie->fp) ||
-                   GET_FCC (movie->fp) != FCC ("strl") ||
-                   (movie->streams[temp].sh.fcc = GET_FCC (movie->fp)) != FCC ("strh") ||
-                   !(movie->streams[temp].sh.size = GET_FCC (movie->fp))) {
+                       !GET_FCC (movie->fp) ||
+                       GET_FCC (movie->fp) != FCC ("strl") ||
+                       (movie->streams[temp].sh.fcc = GET_FCC (movie->fp)) != FCC ("strh") ||
+                       !(movie->streams[temp].sh.size = GET_FCC (movie->fp))) {
                        DEBUG("bad stream header information\n");
                        return AVI_ERROR_FORMAT;                                
                }
@@ -535,7 +535,7 @@ AviError AVI_open_movie (char *name, AviMovie *movie) {
                                
                                fcca = bi->Compression;
 
-                                if ( movie->streams[temp].format ==
+                                                               if ( movie->streams[temp].format ==
                                         AVI_FORMAT_AVI_RGB) {
                                        if (fcca == FCC ("DIB ") ||
                                                fcca == FCC ("RGB ") ||
@@ -559,7 +559,7 @@ AviError AVI_open_movie (char *name, AviMovie *movie) {
                        temp= GET_FCC (movie->fp);
                        if (temp<0 || ftell(movie->fp) > movie->size) {
                                DEBUG("incorrect size in header or error in AVI\n");
-                           return AVI_ERROR_FORMAT;                            
+                               return AVI_ERROR_FORMAT;                                
                        }
                        fseek(movie->fp, temp, SEEK_CUR);                       
                }
@@ -584,7 +584,7 @@ AviError AVI_open_movie (char *name, AviMovie *movie) {
                }
                if (ftell(movie->fp) > movie->size) {
                        DEBUG("incorrect size in header or error in AVI\n");
-                   return AVI_ERROR_FORMAT;
+                       return AVI_ERROR_FORMAT;
                }
        }
 
@@ -727,9 +727,9 @@ AviError AVI_open_compress (char *name, AviMovie *movie, int streams, ...) {
        movie->header->fcc = FCC("avih");
        movie->header->size = 56;
        movie->header->MicroSecPerFrame = 66667;
-       movie->header->MaxBytesPerSec = 0; 
-       movie->header->PaddingGranularity = 0; 
-       movie->header->Flags = AVIF_HASINDEX | AVIF_MUSTUSEINDEX;
+        movie->header->MaxBytesPerSec = 0; 
+        movie->header->PaddingGranularity = 0; 
+        movie->header->Flags = AVIF_HASINDEX | AVIF_MUSTUSEINDEX;
        movie->header->TotalFrames = 0;
        movie->header->InitialFrames = 0;
        movie->header->Streams = streams;
@@ -906,10 +906,10 @@ AviError AVI_write_frame (AviMovie *movie, int frame_num, ...) {
 
        if (frame_num+1 > movie->index_entries) {
                temp = (AviIndexEntry *) MEM_mallocN ((frame_num+1) * 
-                   (movie->header->Streams+1) * sizeof(AviIndexEntry),"newidxentry");
+                       (movie->header->Streams+1) * sizeof(AviIndexEntry),"newidxentry");
                if (movie->entries != NULL) {
                        memcpy (temp, movie->entries, movie->index_entries * (movie->header->Streams+1)
-                           * sizeof(AviIndexEntry));
+                               * sizeof(AviIndexEntry));
                        MEM_freeN (movie->entries);
                }
 
index 9691c90..4ebcb21 100644 (file)
 
 void *avi_format_convert (AviMovie *movie, int stream, void *buffer, AviFormat from, AviFormat to, int *size) {
   if (from == to)
-    return buffer;
+       return buffer;
     
   if (from != AVI_FORMAT_RGB24 &&
-      to != AVI_FORMAT_RGB24)
-    return avi_format_convert(movie, stream, 
-                             avi_format_convert (movie, stream, buffer, from, AVI_FORMAT_RGB24, size), 
-                             AVI_FORMAT_RGB24, to, size);
+         to != AVI_FORMAT_RGB24)
+       return avi_format_convert(movie, stream, 
+                                 avi_format_convert (movie, stream, buffer, from, AVI_FORMAT_RGB24, size), 
+                                 AVI_FORMAT_RGB24, to, size);
   
   switch (to) {
   case AVI_FORMAT_RGB24:
-    switch (from) {
-    case AVI_FORMAT_AVI_RGB:
-      buffer = avi_converter_from_avi_rgb (movie, stream, buffer, size);
-      break;
-    case AVI_FORMAT_MJPEG:
-      buffer = avi_converter_from_mjpeg (movie, stream, buffer, size);
-      break;
-    case AVI_FORMAT_RGB32:
-      buffer = avi_converter_from_rgb32 (movie, stream, buffer, size);
-      break;
-    default:
-      break;
-    }
-    break;
+       switch (from) {
+       case AVI_FORMAT_AVI_RGB:
+         buffer = avi_converter_from_avi_rgb (movie, stream, buffer, size);
+         break;
+       case AVI_FORMAT_MJPEG:
+         buffer = avi_converter_from_mjpeg (movie, stream, buffer, size);
+         break;
+       case AVI_FORMAT_RGB32:
+         buffer = avi_converter_from_rgb32 (movie, stream, buffer, size);
+         break;
+       default:
+         break;
+       }
+       break;
   case AVI_FORMAT_AVI_RGB:
-    buffer = avi_converter_to_avi_rgb (movie, stream, buffer, size);
-    break;
+       buffer = avi_converter_to_avi_rgb (movie, stream, buffer, size);
+       break;
   case AVI_FORMAT_MJPEG:
-    buffer = avi_converter_to_mjpeg (movie, stream, buffer, size);
-    break;
+       buffer = avi_converter_to_mjpeg (movie, stream, buffer, size);
+       break;
   case AVI_FORMAT_RGB32:
-    buffer = avi_converter_to_rgb32 (movie, stream, buffer, size);
-    break;
+       buffer = avi_converter_to_rgb32 (movie, stream, buffer, size);
+       break;
   default:
-    break;
+       break;
   }
 
   return buffer;
@@ -88,11 +88,11 @@ int avi_get_data_id (AviFormat format, int stream) {
   char fcc[5];
 
   if (avi_get_format_type (format) == FCC("vids"))
-    sprintf (fcc,"%2.2ddc",stream);
+       sprintf (fcc,"%2.2ddc",stream);
   else if (avi_get_format_type (format) == FCC("auds"))
-    sprintf (fcc,"%2.2ddc",stream);
+       sprintf (fcc,"%2.2ddc",stream);
   else
-    return 0;
+       return 0;
 
   return FCC(fcc);
 }
@@ -103,11 +103,11 @@ int avi_get_format_type (AviFormat format) {
   case AVI_FORMAT_RGB32:
   case AVI_FORMAT_AVI_RGB:
   case AVI_FORMAT_MJPEG:
-    return FCC("vids");
-    break;
+       return FCC("vids");
+       break;
   default:
-    return 0;
-    break;
+       return 0;
+       break;
   }
 }
 
@@ -116,14 +116,14 @@ int avi_get_format_fcc (AviFormat format) {
   case AVI_FORMAT_RGB24:
   case AVI_FORMAT_RGB32:
   case AVI_FORMAT_AVI_RGB:
-    return FCC("DIB ");
-    break;
+       return FCC("DIB ");
+       break;
   case AVI_FORMAT_MJPEG:
-    return FCC("MJPG");
-    break;
+       return FCC("MJPG");
+       break;
   default:
-    return 0;
-    break;
+       return 0;
+       break;
   }
 }
 
@@ -132,13 +132,13 @@ int avi_get_format_compression (AviFormat format) {
   case AVI_FORMAT_RGB24:
   case AVI_FORMAT_RGB32:
   case AVI_FORMAT_AVI_RGB:
-    return 0;
-    break;
+       return 0;
+       break;
   case AVI_FORMAT_MJPEG:
-    return FCC("MJPG");
-    break;
+       return FCC("MJPG");
+       break;
   default:
-    return 0;
-    break;
+       return 0;
+       break;
   }
 }
index 6608e6c..d7212e7 100644 (file)
@@ -134,13 +134,13 @@ static void std_huff_tables (j_decompress_ptr dinfo) {
                0xf9, 0xfa      };
 
        add_huff_table(dinfo, &dinfo->dc_huff_tbl_ptrs[0],
-           bits_dc_luminance, val_dc_luminance);
+               bits_dc_luminance, val_dc_luminance);
        add_huff_table(dinfo, &dinfo->ac_huff_tbl_ptrs[0],
-           bits_ac_luminance, val_ac_luminance);
+               bits_ac_luminance, val_ac_luminance);
        add_huff_table(dinfo, &dinfo->dc_huff_tbl_ptrs[1],
-           bits_dc_chrominance, val_dc_chrominance);
+               bits_dc_chrominance, val_dc_chrominance);
        add_huff_table(dinfo, &dinfo->ac_huff_tbl_ptrs[1],
-           bits_ac_chrominance, val_ac_chrominance);
+               bits_ac_chrominance, val_ac_chrominance);
 }
 
 static int Decode_JPEG(unsigned char *inBuffer, unsigned char *outBuffer, unsigned int width, unsigned int height, int bufsize) {
index bab02ec..7b194b8 100644 (file)
@@ -109,17 +109,17 @@ AviError AVI_set_compress_option (AviMovie *movie, int option_type, int stream,
                                
                }
 
-    fseek (movie->fp, movie->offset_table[0], SEEK_SET);
-    awrite (movie, movie->header, 1, sizeof(AviMainHeader), movie->fp, AVI_MAINH);
+       fseek (movie->fp, movie->offset_table[0], SEEK_SET);
+       awrite (movie, movie->header, 1, sizeof(AviMainHeader), movie->fp, AVI_MAINH);
 
-    break;
+       break;
   case AVI_OPTION_TYPE_STRH:
-    break;
+       break;
   case AVI_OPTION_TYPE_STRF:
-    break;
+       break;
   default:
-    return AVI_ERROR_OPTION;
-    break;
+       return AVI_ERROR_OPTION;
+       break;
   }
 
   return AVI_ERROR_NONE;
index 154c634..cb87638 100644 (file)
@@ -165,28 +165,28 @@ struct DerivedMesh {
         * passed as a float or short array, only one should be non-NULL.
         */
        void (*foreachMappedVert)(
-                             DerivedMesh *dm,
-                             void (*func)(void *userData, int index, float *co,
-                                          float *no_f, short *no_s),
-                             void *userData);
+                                                 DerivedMesh *dm,
+                                                 void (*func)(void *userData, int index, float *co,
+                                                                          float *no_f, short *no_s),
+                                                 void *userData);
 
        /* Iterate over each mapped edge in the derived mesh, calling the
         * given function with the original edge and the mapped edge's new
         * coordinates.
         */
        void (*foreachMappedEdge)(DerivedMesh *dm,
-                                 void (*func)(void *userData, int index,
-                                              float *v0co, float *v1co),
-                                 void *userData);
+                                                         void (*func)(void *userData, int index,
+                                                                                  float *v0co, float *v1co),
+                                                         void *userData);
 
        /* Iterate over each mapped face in the derived mesh, calling the
         * given function with the original face and the mapped face's (or
         * faces') center and normal.
         */
        void (*foreachMappedFaceCenter)(DerivedMesh *dm,
-                                       void (*func)(void *userData, int index,
-                                                    float *cent, float *no),
-                                       void *userData);
+                                                                       void (*func)(void *userData, int index,
+                                                                                                float *cent, float *no),
+                                                                       void *userData);
 
        /* Iterate over all vertex points, calling DO_MINMAX with given args.
         *
@@ -240,7 +240,7 @@ struct DerivedMesh {
         * Also called for *final* editmode DerivedMeshes
         */
        void (*drawFacesSolid)(DerivedMesh *dm, float (*partial_redraw_planes)[4],
-                              int fast, int (*setMaterial)(int, void *attribs));
+                                                  int fast, int (*setMaterial)(int, void *attribs));
 
        /* Draw all faces
         *  o If useTwoSided, draw front and back using col arrays
@@ -248,14 +248,14 @@ struct DerivedMesh {
         *    in ABGR format, and should be passed as per-face vertex color.
         */
        void (*drawFacesColored)(DerivedMesh *dm, int useTwoSided,
-                                unsigned char *col1, unsigned char *col2);
+                                                        unsigned char *col1, unsigned char *col2);
 
        /* Draw all faces using MTFace 
         *  o Drawing options too complicated to enumerate, look at code.
         */
        void (*drawFacesTex)(DerivedMesh *dm,
-                            int (*setDrawOptions)(struct MTFace *tface,
-                            struct MCol *mcol, int matnr));
+                                                int (*setDrawOptions)(struct MTFace *tface,
+                                                struct MCol *mcol, int matnr));
 
        /* Draw all faces with GLSL materials
         *  o setMaterial is called for every different material nr
@@ -278,17 +278,17 @@ struct DerivedMesh {
         * smooth shaded.
         */
        void (*drawMappedFaces)(DerivedMesh *dm,
-                               int (*setDrawOptions)(void *userData, int index,
-                                                     int *drawSmooth_r),
-                               void *userData, int useColors);
+                                                       int (*setDrawOptions)(void *userData, int index,
+                                                                                                 int *drawSmooth_r),
+                                                       void *userData, int useColors);
 
        /* Draw mapped faces using MTFace 
         *  o Drawing options too complicated to enumerate, look at code.
         */
        void (*drawMappedFacesTex)(DerivedMesh *dm,
-                                  int (*setDrawOptions)(void *userData,
-                                                        int index),
-                                  void *userData);
+                                                          int (*setDrawOptions)(void *userData,
+                                                                                                        int index),
+                                                          void *userData);
 
        /* Draw mapped faces with GLSL materials
         *  o setMaterial is called for every different material nr
@@ -304,8 +304,8 @@ struct DerivedMesh {
         *    returns true
         */
        void (*drawMappedEdges)(DerivedMesh *dm,
-                               int (*setDrawOptions)(void *userData, int index),
-                               void *userData);
+                                                       int (*setDrawOptions)(void *userData, int index),
+                                                       void *userData);
 
        /* Draw mapped edges as lines with interpolation values
         *  o Only if !setDrawOptions or
@@ -315,12 +315,12 @@ struct DerivedMesh {
         * NOTE: This routine is optional!
         */
        void (*drawMappedEdgesInterp)(DerivedMesh *dm, 
-                                     int (*setDrawOptions)(void *userData,
-                                                           int index), 
-                                     void (*setDrawInterpOptions)(void *userData,
-                                                                  int index,
-                                                                  float t),
-                                     void *userData);
+                                                                 int (*setDrawOptions)(void *userData,
+                                                                                                               int index), 
+                                                                 void (*setDrawInterpOptions)(void *userData,
+                                                                                                                          int index,
+                                                                                                                          float t),
+                                                                 void *userData);
 
        /* Release reference to the DerivedMesh. This function decides internally
         * if the DerivedMesh will be freed, or cached for later use. */
@@ -337,14 +337,14 @@ void DM_init_funcs(DerivedMesh *dm);
  * sets up the custom data layers)
  */
 void DM_init(DerivedMesh *dm, DerivedMeshType type,
-             int numVerts, int numEdges, int numFaces);
+                        int numVerts, int numEdges, int numFaces);
 
 /* utility function to initialise a DerivedMesh for the desired number
  * of vertices, edges and faces, with a layer setup copied from source
  */
 void DM_from_template(DerivedMesh *dm, DerivedMesh *source,
-                      DerivedMeshType type,
-                      int numVerts, int numEdges, int numFaces);
+                                         DerivedMeshType type,
+                                         int numVerts, int numEdges, int numFaces);
 
 /* utility function to release a DerivedMesh's layers
  * returns 1 if DerivedMesh has to be released by the backend, 0 otherwise
@@ -371,11 +371,11 @@ void DM_set_only_copy(DerivedMesh *dm, CustomDataMask mask);
  * freed, see BKE_customdata.h for the different options
  */
 void DM_add_vert_layer(struct DerivedMesh *dm, int type, int alloctype,
-                       void *layer);
+                                          void *layer);
 void DM_add_edge_layer(struct DerivedMesh *dm, int type, int alloctype,
-                       void *layer);
+                                          void *layer);
 void DM_add_face_layer(struct DerivedMesh *dm, int type, int alloctype,
-                       void *layer);
+                                          void *layer);
 
 /* custom data access functions
  * return pointer to data from first layer which matches type
@@ -408,11 +408,11 @@ void DM_set_face_data(struct DerivedMesh *dm, int index, int type, void *data);
  * these copy all layers for which the CD_FLAG_NOCOPY flag is not set
  */
 void DM_copy_vert_data(struct DerivedMesh *source, struct DerivedMesh *dest,
-                       int source_index, int dest_index, int count);
+                                          int source_index, int dest_index, int count);
 void DM_copy_edge_data(struct DerivedMesh *source, struct DerivedMesh *dest,
-                       int source_index, int dest_index, int count);
+                                          int source_index, int dest_index, int count);
 void DM_copy_face_data(struct DerivedMesh *source, struct DerivedMesh *dest,
-                       int source_index, int dest_index, int count);
+                                          int source_index, int dest_index, int count);
 
 /* custom data free functions
  * free count elements, starting at index
@@ -427,8 +427,8 @@ void DM_free_face_data(struct DerivedMesh *dm, int index, int count);
  * indexed by dest_index in the dest mesh
  */
 void DM_interp_vert_data(struct DerivedMesh *source, struct DerivedMesh *dest,
-                         int *src_indices, float *weights,
-                         int count, int dest_index);
+                                                int *src_indices, float *weights,
+                                                int count, int dest_index);
 
 /* interpolates edge data from the edges indexed by src_indices in the
  * source mesh using the given weights and stores the result in the edge indexed
@@ -439,9 +439,9 @@ void DM_interp_vert_data(struct DerivedMesh *source, struct DerivedMesh *dest,
  */
 typedef float EdgeVertWeight[SUB_ELEMS_EDGE][SUB_ELEMS_EDGE];
 void DM_interp_edge_data(struct DerivedMesh *source, struct DerivedMesh *dest,
-                         int *src_indices,
-                         float *weights, EdgeVertWeight *vert_weights,
-                         int count, int dest_index);
+                                                int *src_indices,
+                                                float *weights, EdgeVertWeight *vert_weights,
+                                                int count, int dest_index);
 
 /* interpolates face data from the faces indexed by src_indices in the
  * source mesh using the given weights and stores the result in the face indexed
@@ -452,9 +452,9 @@ void DM_interp_edge_data(struct DerivedMesh *source, struct DerivedMesh *dest,
  */
 typedef float FaceVertWeight[SUB_ELEMS_FACE][SUB_ELEMS_FACE];
 void DM_interp_face_data(struct DerivedMesh *source, struct DerivedMesh *dest,
-                         int *src_indices,
-                         float *weights, FaceVertWeight *vert_weights,
-                         int count, int dest_index);
+                                                int *src_indices,
+                                                float *weights, FaceVertWeight *vert_weights,
+                                                int count, int dest_index);
 
 void DM_swap_face_data(struct DerivedMesh *dm, int index, int *corner_indices);
 
@@ -468,42 +468,42 @@ float *mesh_get_mapped_verts_nors(struct Scene *scene, struct Object *ob);
 
        /* */
 DerivedMesh *mesh_get_derived_final(struct Scene *scene, struct Object *ob,
-                                    CustomDataMask dataMask);
+                                                                       CustomDataMask dataMask);
 DerivedMesh *mesh_get_derived_deform(struct Scene *scene, struct Object *ob,
-                                     CustomDataMask dataMask);
+                                                                        CustomDataMask dataMask);
 
 DerivedMesh *mesh_create_derived_for_modifier(struct Scene *scene, struct Object *ob, struct ModifierData *md);
 
 DerivedMesh *mesh_create_derived_render(struct Scene *scene, struct Object *ob,
-                                        CustomDataMask dataMask);
+                                                                               CustomDataMask dataMask);
 
 DerivedMesh *mesh_create_derived_index_render(struct Scene *scene, struct Object *ob, CustomDataMask dataMask, int index);
 
                /* same as above but wont use render settings */
 DerivedMesh *mesh_create_derived_view(struct Scene *scene, struct Object *ob,
-                                      CustomDataMask dataMask);
+                                                                         CustomDataMask dataMask);
 DerivedMesh *mesh_create_derived_no_deform(struct Scene *scene, struct Object *ob,
-                                           float (*vertCos)[3],
-                                           CustomDataMask dataMask);
+                                                                                  float (*vertCos)[3],
+                                                                                  CustomDataMask dataMask);
 DerivedMesh *mesh_create_derived_no_deform_render(struct Scene *scene, struct Object *ob,
-                                                  float (*vertCos)[3],
-                                                  CustomDataMask dataMask);
+                                                                                                 float (*vertCos)[3],
+                                                                                                 CustomDataMask dataMask);
 /* for gameengine */
 DerivedMesh *mesh_create_derived_no_virtual(struct Scene *scene, struct Object *ob, float (*vertCos)[3],
-                                            CustomDataMask dataMask);
+                                                                                       CustomDataMask dataMask);
 
 DerivedMesh *editmesh_get_derived_base(struct Object *, struct EditMesh *em);
 DerivedMesh *editmesh_get_derived_cage(struct Scene *scene, struct Object *, 
                                                                           struct EditMesh *em, CustomDataMask dataMask);
 DerivedMesh *editmesh_get_derived_cage_and_final(struct Scene *scene, struct Object *, 
                                                                                                 struct EditMesh *em, DerivedMesh **final_r,
-                                                 CustomDataMask dataMask);
+                                                                                                CustomDataMask dataMask);
 void makeDerivedMesh(struct Scene *scene, struct Object *ob, struct EditMesh *em, CustomDataMask dataMask);
 
 /* returns an array of deform matrices for crazyspace correction, and the
    number of modifiers left */
 int editmesh_get_first_deform_matrices(struct Scene *, struct Object *, struct EditMesh *em,
-                                       float (**deformmats)[3][3], float (**deformcos)[3]);
+                                                                          float (**deformmats)[3][3], float (**deformcos)[3]);
 
 void weight_to_rgb(float input, float *fr, float *fg, float *fb);
 
index 470db28..aff102f 100644 (file)
@@ -218,11 +218,11 @@ typedef struct BME_TransData {
        void *loc;    /* a pointer to the data to transform (likely the vert's cos) */
        float factor; /* primary scaling factor; also accumulates number of weighted edges for beveling tool */
        float weight; /* another scaling factor; used primarily for propogating vertex weights to transforms; */
-                     /* weight is also used across recursive bevels to help with the math */
+                                 /* weight is also used across recursive bevels to help with the math */
        float maxfactor; /* the unscaled, original factor (used only by "edge verts" in recursive beveling) */
        float *max;   /* the maximum distance this vert can be transformed; negative is infinite
-                      * it points to the "parent" maxfactor (where maxfactor makes little sense)
-                      * where the max limit is stored (limits are stored per-corner) */
+                                  * it points to the "parent" maxfactor (where maxfactor makes little sense)
+                                  * where the max limit is stored (limits are stored per-corner) */
 } BME_TransData;
 
 typedef struct BME_TransData_Head {
index d323725..dcf7164 100644 (file)
@@ -44,6 +44,6 @@ int NewBooleanMesh(struct Scene *scene, struct Base *base, struct Base *base_sel
    are in fact mesh object. On success returns a DerivedMesh. On failure
    returns NULL and reports an error. */
 struct DerivedMesh *NewBooleanDerivedMesh(struct DerivedMesh *dm, struct Object *ob, struct DerivedMesh *dm_select, struct Object *ob_select,
-                                   int int_op_type);
+                                                                  int int_op_type);
 #endif
 
index 33e8f93..bff9f16 100644 (file)
@@ -71,7 +71,7 @@ struct DerivedMesh *CDDM_copy(struct DerivedMesh *dm);
  * elements are initialised to all zeros
  */
 struct DerivedMesh *CDDM_from_template(struct DerivedMesh *source,
-                                  int numVerts, int numEdges, int numFaces);
+                                                                 int numVerts, int numEdges, int numFaces);
 
 /* applies vertex coordinates or normals to a CDDerivedMesh. if the MVert
  * layer is a referenced layer, it will be duplicate to not overwrite the
index ae3fdb9..48e2dbf 100644 (file)
@@ -167,7 +167,7 @@ void CTX_wm_menu_set(bContext *C, struct ARegion *menu);
 /* Data Context
 
    - listbases consist of CollectionPointerLink items and must be
-     freed with BLI_freelistN!
+        freed with BLI_freelistN!
    - the dir listbase consits of LinkData items */
 
 PointerRNA CTX_data_pointer_get(const bContext *C, const char *member);
index 2f65dab..c07b26f 100644 (file)
@@ -57,18 +57,18 @@ extern const CustomDataMask CD_MASK_FACECORNERS;
 #define CD_DEFAULT   2  /* allocate and set to default */
 #define CD_REFERENCE 3  /* use data pointers, set layer flag NOFREE */
 #define CD_DUPLICATE 4  /* do a full copy of all layers, only allowed if source
-                           has same number of elements */
+                                                  has same number of elements */
 
 /* initialises a CustomData object with the same layer setup as source.
  * mask is a bitfield where (mask & (1 << (layer type))) indicates
  * if a layer should be copied or not. alloctype must be one of the above. */
 void CustomData_copy(const struct CustomData *source, struct CustomData *dest,
-                     CustomDataMask mask, int alloctype, int totelem);
+                                        CustomDataMask mask, int alloctype, int totelem);
 
 /* same as the above, except that this will preserve existing layers, and only
  * add the layers that were not there yet */
 void CustomData_merge(const struct CustomData *source, struct CustomData *dest,
-                      CustomDataMask mask, int alloctype, int totelem);
+                                         CustomDataMask mask, int alloctype, int totelem);
 
 /* frees data associated with a CustomData object (doesn't free the object
  * itself, though)
@@ -85,10 +85,10 @@ void CustomData_free_temporary(struct CustomData *data, int totelem);
  * in editmode, use EM_add_data_layer instead of this function
  */
 void *CustomData_add_layer(struct CustomData *data, int type, int alloctype,
-                           void *layer, int totelem);
+                                                  void *layer, int totelem);
 /*same as above but accepts a name */
 void *CustomData_add_layer_named(struct CustomData *data, int type, int alloctype,
-                           void *layer, int totelem, char *name);
+                                                  void *layer, int totelem, char *name);
 
 /* frees the active or first data layer with the give type.
  * returns 1 on succes, 0 if no layer with the given type is found
@@ -117,14 +117,14 @@ int CustomData_number_of_layers(const struct CustomData *data, int type);
  * returns the layer data */
 void *CustomData_duplicate_referenced_layer(struct CustomData *data, int type);
 void *CustomData_duplicate_referenced_layer_named(struct CustomData *data,
-                                                  int type, char *name);
+                                                                                                 int type, char *name);
 
 /* set the CD_FLAG_NOCOPY flag in custom data layers where the mask is
  * zero for the layer type, so only layer types specified by the mask
  * will be copied
  */
 void CustomData_set_only_copy(const struct CustomData *data,
-                              CustomDataMask mask);
+                                                         CustomDataMask mask);
 
 /* copies data from one CustomData object to another
  * objects need not be compatible, each source layer is copied to the
@@ -132,11 +132,11 @@ void CustomData_set_only_copy(const struct CustomData *data,
  * return 1 on success, 0 on failure
  */
 void CustomData_copy_data(const struct CustomData *source,
-                          struct CustomData *dest, int source_index,
-                          int dest_index, int count);
+                                                 struct CustomData *dest, int source_index,
+                                                 int dest_index, int count);
 void CustomData_em_copy_data(const struct CustomData *source,
-                            struct CustomData *dest, void *src_block,
-                            void **dest_block);
+                                                       struct CustomData *dest, void *src_block,
+                                                       void **dest_block);
 void CustomData_bmesh_copy_data(const struct CustomData *source, 
                                                        struct CustomData *dest,void *src_block, 
                                                        void **dest_block);
@@ -161,11 +161,11 @@ void CustomData_free_elem(struct CustomData *data, int index, int count);
  * returns 1 on success, 0 on failure
  */
 void CustomData_interp(const struct CustomData *source, struct CustomData *dest,
-                       int *src_indices, float *weights, float *sub_weights,
-                       int count, int dest_index);
+                                          int *src_indices, float *weights, float *sub_weights,
+                                          int count, int dest_index);
 void CustomData_em_interp(struct CustomData *data,  void **src_blocks,
-                          float *weights, float *sub_weights, int count,
-                          void *dest_block);
+                                                 float *weights, float *sub_weights, int count,
+                                                 void *dest_block);
 void CustomData_bmesh_interp(struct CustomData *data, void **src_blocks, 
                                                         float *weights, float *sub_weights, int count, 
                                                         void *dest_block);
@@ -191,7 +191,7 @@ void *CustomData_bmesh_get_n(const struct CustomData *data, void *block, int typ
 void *CustomData_get_layer(const struct CustomData *data, int type);
 void *CustomData_get_layer_n(const struct CustomData *data, int type, int n);
 void *CustomData_get_layer_named(const struct CustomData *data, int type,
-                                 char *name);
+                                                                char *name);
 
 int CustomData_get_layer_index(const struct CustomData *data, int type);
 int CustomData_get_named_layer_index(const struct CustomData *data, int type, char *name);
@@ -209,11 +209,11 @@ int CustomData_get_stencil_layer(const struct CustomData *data, int type);
  * no effect if there is no layer of type
  */
 void CustomData_set(const struct CustomData *data, int index, int type,
-                    void *source);
+                                       void *source);
 void CustomData_em_set(struct CustomData *data, void *block, int type,
-                       void *source);
+                                          void *source);
 void CustomData_em_set_n(struct CustomData *data, void *block, int type, int n,
-                         void *source);
+                                                void *source);
 
 void CustomData_bmesh_set(const struct CustomData *data, void *block, int type, 
                                                  void *source);
@@ -252,9 +252,9 @@ void CustomData_bmesh_free_block(struct CustomData *data, void **block);
 /* copy custom data to/from layers as in mesh/derivedmesh, to editmesh
    blocks of data. the CustomData's must not be compatible  */
 void CustomData_to_em_block(const struct CustomData *source,
-                            struct CustomData *dest, int index, void **block);
+                                                       struct CustomData *dest, int index, void **block);
 void CustomData_from_em_block(const struct CustomData *source,
-                              struct CustomData *dest, void *block, int index);
+                                                         struct CustomData *dest, void *block, int index);
 void CustomData_to_bmesh_block(const struct CustomData *source, 
                                                        struct CustomData *dest, int src_index, void **dest_block);
 void CustomData_from_bmesh_block(const struct CustomData *source, 
index 01a1126..febe0a1 100644 (file)
@@ -66,10 +66,10 @@ struct DerivedMesh;
 
 /* used for curves, nurbs, mball, importing */
 typedef struct DispList {
-    struct DispList *next, *prev;
-    short type, flag;
-    int parts, nr;
-    short col, rt;              /* rt used by initrenderNurbs */
+       struct DispList *next, *prev;
+       short type, flag;
+       int parts, nr;
+       short col, rt;              /* rt used by initrenderNurbs */
        float *verts, *nors;
        int *index;
        unsigned int *col1, *col2;
index 6e364ef..e332392 100644 (file)
@@ -114,7 +114,7 @@ int IDP_AddToGroup(struct IDProperty *group, struct IDProperty *prop);
 /*this is the same as IDP_AddToGroup, only you pass an item
   in the group list to be inserted after.*/
 int IDP_InsertToGroup(struct IDProperty *group, struct IDProperty *previous, 
-                      struct IDProperty *pnew);
+                                         struct IDProperty *pnew);
 
 /*NOTE: this does not free the property!!
 
index d992960..f35dff5 100644 (file)
@@ -59,11 +59,11 @@ void curve_deform_vector(struct Scene *scene, struct Object *cuOb, struct Object
                                                 float *orco, float *vec, float mat[][3], int no_rot_axis);
 
 void lattice_deform_verts(struct Object *laOb, struct Object *target,
-                          struct DerivedMesh *dm, float (*vertexCos)[3],
-                          int numVerts, char *vgroup);
+                                                 struct DerivedMesh *dm, float (*vertexCos)[3],
+                                                 int numVerts, char *vgroup);
 void armature_deform_verts(struct Object *armOb, struct Object *target,
-                           struct DerivedMesh *dm, float (*vertexCos)[3],
-                           float (*defMats)[3][3], int numVerts, int deformflag, 
+                                                  struct DerivedMesh *dm, float (*vertexCos)[3],
+                                                  float (*defMats)[3][3], int numVerts, int deformflag, 
                                                   float (*prevCos)[3], const char *defgrp_name);
 
 float (*lattice_getVertexCos(struct Object *ob, int *numVerts_r))[3];
index c9f56ef..6db610f 100644 (file)
@@ -130,22 +130,22 @@ typedef struct ModifierTypeInfo {
         * and otherwise the ob argument.
         */
        void (*deformVerts)(struct ModifierData *md, struct Object *ob,
-                           struct DerivedMesh *derivedData,
-                           float (*vertexCos)[3], int numVerts,
-                           int useRenderParams, int isFinalCalc);
+                                               struct DerivedMesh *derivedData,
+                                               float (*vertexCos)[3], int numVerts,
+                                               int useRenderParams, int isFinalCalc);
 
        /* Like deformVerts but called during editmode (for supporting modifiers)
         */
        void (*deformVertsEM)(
-                   struct ModifierData *md, struct Object *ob,
-                   struct EditMesh *editData, struct DerivedMesh *derivedData,
-                   float (*vertexCos)[3], int numVerts);
+                               struct ModifierData *md, struct Object *ob,
+                               struct EditMesh *editData, struct DerivedMesh *derivedData,
+                               float (*vertexCos)[3], int numVerts);
 
        /* Set deform matrix per vertex for crazyspace correction */
        void (*deformMatricesEM)(
-                   struct ModifierData *md, struct Object *ob,
-                   struct EditMesh *editData, struct DerivedMesh *derivedData,
-                   float (*vertexCos)[3], float (*defMats)[3][3], int numVerts);
+                               struct ModifierData *md, struct Object *ob,
+                               struct EditMesh *editData, struct DerivedMesh *derivedData,
+                               float (*vertexCos)[3], float (*defMats)[3][3], int numVerts);
 
        /********************* Non-deform modifier functions *********************/
 
@@ -169,9 +169,9 @@ typedef struct ModifierTypeInfo {
         * modified form), but must not release it.
         */
        struct DerivedMesh *(*applyModifier)(
-                                   struct ModifierData *md, struct Object *ob,
-                                   struct DerivedMesh *derivedData,
-                                   int useRenderParams, int isFinalCalc);
+                                                               struct ModifierData *md, struct Object *ob,
+                                                               struct DerivedMesh *derivedData,
+                                                               int useRenderParams, int isFinalCalc);
 
        /* Like applyModifier but called during editmode (for supporting
         * modifiers).
@@ -181,9 +181,9 @@ typedef struct ModifierTypeInfo {
         * derivedData apply as for applyModifier.
         */
        struct DerivedMesh *(*applyModifierEM)(
-                                   struct ModifierData *md, struct Object *ob,
-                                   struct EditMesh *editData,
-                                   struct DerivedMesh *derivedData);
+                                                               struct ModifierData *md, struct Object *ob,
+                                                               struct EditMesh *editData,
+                                                               struct DerivedMesh *derivedData);
 
 
        /********************* Optional functions *********************/
@@ -236,7 +236,7 @@ typedef struct ModifierTypeInfo {
         * This function is optional.
         */
        void (*updateDepgraph)(struct ModifierData *md, struct DagForest *forest, struct Scene *scene,
-                              struct Object *ob, struct DagNode *obNode);
+                                                  struct Object *ob, struct DagNode *obNode);
 
        /* Should return true if the modifier needs to be recalculated on time
         * changes.
@@ -252,7 +252,7 @@ typedef struct ModifierTypeInfo {
         * This function is optional.
         */
        void (*foreachObjectLink)(struct ModifierData *md, struct Object *ob,
-                                 ObjectWalkFunc walk, void *userData);
+                                                         ObjectWalkFunc walk, void *userData);
 
        /* Should call the given walk function with a pointer to each ID
         * pointer (i.e. each datablock pointer) that the modifier data
@@ -263,7 +263,7 @@ typedef struct ModifierTypeInfo {
         * will be used.
         */
        void (*foreachIDLink)(struct ModifierData *md, struct Object *ob,
-                             IDWalkFunc walk, void *userData);
+                                                 IDWalkFunc walk, void *userData);
 } ModifierTypeInfo;
 
 ModifierTypeInfo *modifierType_getInfo (ModifierType type);
@@ -286,15 +286,15 @@ int           modifier_isEnabled(struct Scene *scene, struct ModifierData *md, i
 void          modifier_setError(struct ModifierData *md, char *format, ...);
 
 void          modifiers_foreachObjectLink(struct Object *ob,
-                                          ObjectWalkFunc walk,
-                                          void *userData);
+                                                                                 ObjectWalkFunc walk,
+                                                                                 void *userData);
 void          modifiers_foreachIDLink(struct Object *ob,
-                                      IDWalkFunc walk,
-                                      void *userData);
+                                                                         IDWalkFunc walk,
+                                                                         void *userData);
 struct ModifierData  *modifiers_findByType(struct Object *ob, ModifierType type);
 void          modifiers_clearErrors(struct Object *ob);
 int           modifiers_getCageIndex(struct Scene *scene, struct Object *ob,
-                                     int *lastPossibleCageIndex_r, int virtual_);
+                                                                        int *lastPossibleCageIndex_r, int virtual_);
 
 int           modifiers_isSoftbodyEnabled(struct Object *ob);
 int           modifiers_isClothEnabled(struct Object *ob);
@@ -314,10 +314,10 @@ int           modifiers_indexInObject(struct Object *ob, struct ModifierData *md
  * end of the stack.
  */
 struct LinkNode *modifiers_calcDataMasks(struct Scene *scene, 
-                                         struct Object *ob,
-                                         struct ModifierData *md,
-                                         CustomDataMask dataMask,
-                                         int required_mode);
+                                                                                struct Object *ob,
+                                                                                struct ModifierData *md,
+                                                                                CustomDataMask dataMask,
+                                                                                int required_mode);
 struct ModifierData  *modifiers_getVirtualModifierList(struct Object *ob);
 
 #endif
index e1c08e2..8fd4f07 100644 (file)
@@ -86,7 +86,7 @@ typedef struct SculptSession {
        unsigned int texcache_side, *texcache, texcache_actual;
 
        /* Layer brush persistence between strokes */
-       float (*layer_co)[3]; /* Copy of the mesh vertices' locations */
+        float (*layer_co)[3]; /* Copy of the mesh vertices' locations */
        float *layer_disps; /* Displacements for each vertex */
 
        struct SculptStroke *stroke;
index 30b7e8c..ef7fa47 100644 (file)
@@ -39,8 +39,8 @@ typedef struct BodyPoint {
        float origS[3], origE[3], origT[3], pos[3], vec[3], force[3];
        float goal;
        float prevpos[3], prevvec[3], prevdx[3], prevdv[3]; /* used for Heun integration */
-    float impdv[3],impdx[3];
-    int nofsprings; int *springs;
+       float impdv[3],impdx[3];
+       int nofsprings; int *springs;
        float choke,choke2,frozen;
        float colball;
        short flag;
index 62ad866..fca7c79 100644 (file)
@@ -45,10 +45,10 @@ struct DMGridAdjacency;
 /**************************** External *****************************/
 
 struct DerivedMesh *subsurf_make_derived_from_derived(
-                        struct DerivedMesh *dm,
-                        struct SubsurfModifierData *smd,
-                        int useRenderParams, float (*vertCos)[3],
-                        int isFinalCalc, int editMode);
+                                               struct DerivedMesh *dm,
+                                               struct SubsurfModifierData *smd,
+                                               int useRenderParams, float (*vertCos)[3],
+                                               int isFinalCalc, int editMode);
 
 void subsurf_calculate_limit_positions(Mesh *me, float (*positions_r)[3]);
 
@@ -64,7 +64,7 @@ typedef struct CCGDerivedMesh {
        struct {int startVert; struct _CCGVert *vert;} *vertMap;
        struct {int startVert; int startEdge; struct _CCGEdge *edge;} *edgeMap;
        struct {int startVert; int startEdge;
-               int startFace; struct _CCGFace *face;} *faceMap;
+                       int startFace; struct _CCGFace *face;} *faceMap;
 
        short *edgeFlags;
        char *faceFlags;
index 736b5e0..d8a6b66 100644 (file)
@@ -135,7 +135,7 @@ static void BME_CD_alloc_block(BME_CustomData *data, void **block)
 }
 
 void BME_CD_copy_data(const BME_CustomData *source, BME_CustomData *dest,
-                            void *src_block, void **dest_block)
+                                                       void *src_block, void **dest_block)
 {
        const BME_LayerTypeInfo *typeInfo;
        int dest_i, src_i;
@@ -151,7 +151,7 @@ void BME_CD_copy_data(const BME_CustomData *source, BME_CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while(dest_i < dest->totlayer
-                     && dest->layers[dest_i].type < source->layers[src_i].type)
+                         && dest->layers[dest_i].type < source->layers[src_i].type)
                        ++dest_i;
 
                /* if there are no more dest layers, we're done */
index 9c9c712..036cd4a 100644 (file)
@@ -71,7 +71,7 @@
        code. 
 
    *The term "Euler Operator" is actually a misnomer when referring to a non-manifold 
-    data structure. Its use is in keeping with the convention established by others.
+       data structure. Its use is in keeping with the convention established by others.
 
        TODO:
        -Finish inserting 'strict' validation in all Eulers
index f616d21..1bb4199 100644 (file)
@@ -87,7 +87,7 @@ void BME_free_mesh(BME_Mesh *bm)
        if(bm->ldata.totlayer) BLI_mempool_destroy(bm->ldata.pool);
        if(bm->pdata.totlayer) BLI_mempool_destroy(bm->pdata.pool);
 
-       /*free custom data*/
+        /*free custom data*/
        CustomData_free(&bm->vdata,0);
        CustomData_free(&bm->edata,0);
        CustomData_free(&bm->ldata,0);
index eb316c6..6778c9e 100644 (file)
@@ -170,7 +170,7 @@ static void *_ehashIterator_getCurrent(EHashIterator *ehi) {
 
 static void _ehashIterator_next(EHashIterator *ehi) {
        if (ehi->curEntry) {
-        ehi->curEntry = ehi->curEntry->next;
+               ehi->curEntry = ehi->curEntry->next;
                while (!ehi->curEntry) {
                        ehi->curBucket++;
                        if (ehi->curBucket==ehi->eh->curSize)
index e69686e..6908d98 100644 (file)
@@ -113,7 +113,7 @@ static MFace *dm_getFaceArray(DerivedMesh *dm)
 static MVert *dm_dupVertArray(DerivedMesh *dm)
 {
        MVert *tmp = MEM_callocN(sizeof(*tmp) * dm->getNumVerts(dm),
-                                "dm_dupVertArray tmp");
+                                                        "dm_dupVertArray tmp");
 
        if(tmp) dm->copyVertArray(dm, tmp);
 
@@ -123,7 +123,7 @@ static MVert *dm_dupVertArray(DerivedMesh *dm)
 static MEdge *dm_dupEdgeArray(DerivedMesh *dm)
 {
        MEdge *tmp = MEM_callocN(sizeof(*tmp) * dm->getNumEdges(dm),
-                                "dm_dupEdgeArray tmp");
+                                                        "dm_dupEdgeArray tmp");
 
        if(tmp) dm->copyEdgeArray(dm, tmp);
 
@@ -133,7 +133,7 @@ static MEdge *dm_dupEdgeArray(DerivedMesh *dm)
 static MFace *dm_dupFaceArray(DerivedMesh *dm)
 {
        MFace *tmp = MEM_callocN(sizeof(*tmp) * dm->getNumFaces(dm),
-                                "dm_dupFaceArray tmp");
+                                                        "dm_dupFaceArray tmp");
 
        if(tmp) dm->copyFaceArray(dm, tmp);
 
@@ -161,7 +161,7 @@ void DM_init_funcs(DerivedMesh *dm)
 }
 
 void DM_init(DerivedMesh *dm, DerivedMeshType type,
-             int numVerts, int numEdges, int numFaces)
+                        int numVerts, int numEdges, int numFaces)
 {
        dm->type = type;
        dm->numVertData = numVerts;
@@ -174,14 +174,14 @@ void DM_init(DerivedMesh *dm, DerivedMeshType type,
 }
 
 void DM_from_template(DerivedMesh *dm, DerivedMesh *source, DerivedMeshType type,
-                      int numVerts, int numEdges, int numFaces)
+                                         int numVerts, int numEdges, int numFaces)
 {
        CustomData_copy(&source->vertData, &dm->vertData, CD_MASK_DERIVEDMESH,
-                       CD_CALLOC, numVerts);
+                                       CD_CALLOC, numVerts);
        CustomData_copy(&source->edgeData, &dm->edgeData, CD_MASK_DERIVEDMESH,
-                       CD_CALLOC, numEdges);
+                                       CD_CALLOC, numEdges);
        CustomData_copy(&source->faceData, &dm->faceData, CD_MASK_DERIVEDMESH,
-                       CD_CALLOC, numFaces);
+                                       CD_CALLOC, numFaces);
 
        dm->type = type;
        dm->numVertData = numVerts;
@@ -352,24 +352,24 @@ void DM_set_face_data(DerivedMesh *dm, int index, int type, void *data)
 }
 
 void DM_copy_vert_data(DerivedMesh *source, DerivedMesh *dest,
-                       int source_index, int dest_index, int count)
+                                          int source_index, int dest_index, int count)
 {
        CustomData_copy_data(&source->vertData, &dest->vertData,
-                            source_index, dest_index, count);
+                                                source_index, dest_index, count);
 }
 
 void DM_copy_edge_data(DerivedMesh *source, DerivedMesh *dest,
-                       int source_index, int dest_index, int count)
+                                          int source_index, int dest_index, int count)
 {
        CustomData_copy_data(&source->edgeData, &dest->edgeData,
-                            source_index, dest_index, count);
+                                                source_index, dest_index, count);
 }
 
 void DM_copy_face_data(DerivedMesh *source, DerivedMesh *dest,
-                       int source_index, int dest_index, int count)
+                                          int source_index, int dest_index, int count)
 {
        CustomData_copy_data(&source->faceData, &dest->faceData,
-                            source_index, dest_index, count);
+                                                source_index, dest_index, count);
 }
 
 void DM_free_vert_data(struct DerivedMesh *dm, int index, int count)
@@ -388,29 +388,29 @@ void DM_free_face_data(struct DerivedMesh *dm, int index, int count)
 }
 
 void DM_interp_vert_data(DerivedMesh *source, DerivedMesh *dest,
-                         int *src_indices, float *weights,
-                         int count, int dest_index)
+                                                int *src_indices, float *weights,
+                                                int count, int dest_index)
 {
        CustomData_interp(&source->vertData, &dest->vertData, src_indices,
-                         weights, NULL, count, dest_index);
+                                         weights, NULL, count, dest_index);
 }
 
 void DM_interp_edge_data(DerivedMesh *source, DerivedMesh *dest,
-                         int *src_indices,
-                         float *weights, EdgeVertWeight *vert_weights,
-                         int count, int dest_index)
+                                                int *src_indices,
+                                                float *weights, EdgeVertWeight *vert_weights,
+                                                int count, int dest_index)
 {
        CustomData_interp(&source->edgeData, &dest->edgeData, src_indices,
-                         weights, (float*)vert_weights, count, dest_index);
+                                         weights, (float*)vert_weights, count, dest_index);
 }
 
 void DM_interp_face_data(DerivedMesh *source, DerivedMesh *dest,
-                         int *src_indices,
-                         float *weights, FaceVertWeight *vert_weights,
-                         int count, int dest_index)
+                                                int *src_indices,
+                                                float *weights, FaceVertWeight *vert_weights,
+                                                int count, int dest_index)
 {
        CustomData_interp(&source->faceData, &dest->faceData, src_indices,
-                         weights, (float*)vert_weights, count, dest_index);
+                                         weights, (float*)vert_weights, count, dest_index);
 }
 
 void DM_swap_face_data(DerivedMesh *dm, int index, int *corner_indices)
@@ -635,8 +635,8 @@ static void emDM_drawMappedFaces(DerivedMesh *dm, int (*setDrawOptions)(void *us
                        draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, i, &drawSmooth);
                        if(draw) {
                                if (draw==2) { /* enabled with stipple */
-                                       glEnable(GL_POLYGON_STIPPLE);
-                                       glPolygonStipple(stipple_quarttone);
+                                         glEnable(GL_POLYGON_STIPPLE);
+                                         glPolygonStipple(stipple_quarttone);
                                }
                                
                                glShadeModel(drawSmooth?GL_SMOOTH:GL_FLAT);
@@ -706,9 +706,9 @@ static void emDM_drawMappedFaces(DerivedMesh *dm, int (*setDrawOptions)(void *us
 }
 
 static void emDM_drawFacesTex_common(DerivedMesh *dm,
-               int (*drawParams)(MTFace *tface, MCol *mcol, int matnr),
-               int (*drawParamsMapped)(void *userData, int index),
-               void *userData) 
+                          int (*drawParams)(MTFace *tface, MCol *mcol, int matnr),
+                          int (*drawParamsMapped)(void *userData, int index),
+                          void *userData) 
 {
        EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
        EditMesh *em= emdm->em;
@@ -884,8 +884,8 @@ static void emDM_drawMappedFacesTex(DerivedMesh *dm, int (*setDrawOptions)(void
 }
 
 static void emDM_drawMappedFacesGLSL(DerivedMesh *dm,
-               int (*setMaterial)(int, void *attribs),
-               int (*setDrawOptions)(void *userData, int index), void *userData) 
+                          int (*setMaterial)(int, void *attribs),
+                          int (*setDrawOptions)(void *userData, int index), void *userData) 
 {
        EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
        EditMesh *em= emdm->em;
@@ -1034,7 +1034,7 @@ static void emDM_drawMappedFacesGLSL(DerivedMesh *dm,
 }
 
 static void emDM_drawFacesGLSL(DerivedMesh *dm,
-               int (*setMaterial)(int, void *attribs))
+                          int (*setMaterial)(int, void *attribs))
 {
        dm->drawMappedFacesGLSL(dm, setMaterial, NULL, NULL);
 }
@@ -1151,7 +1151,7 @@ static void emDM_getFace(DerivedMesh *dm, int index, MFace *face_r)
        if(!v4) face_r->v4 = 0;
 
        for(i = 0, ev = em->verts.first; v1 || v2 || v3 || v4;
-           i++, ev = ev->next) {
+               i++, ev = ev->next) {
                if(ev == v1) {
                        face_r->v1 = i;
                        v1 = NULL;
@@ -1297,12 +1297,12 @@ static void emDM_release(DerivedMesh *dm)
 }
 
 static DerivedMesh *getEditMeshDerivedMesh(EditMesh *em, Object *ob,
-                                           float (*vertexCos)[3])
+                                                                                  float (*vertexCos)[3])
 {
        EditMeshDerivedMesh *emdm = MEM_callocN(sizeof(*emdm), "emdm");
 
        DM_init(&emdm->dm, DM_TYPE_EDITMESH, BLI_countlist(&em->verts),
-                        BLI_countlist(&em->edges), BLI_countlist(&em->faces));
+                                        BLI_countlist(&em->edges), BLI_countlist(&em->faces));
 
        emdm->dm.getMinMax = emDM_getMinMax;
 
@@ -1345,7 +1345,7 @@ static DerivedMesh *getEditMeshDerivedMesh(EditMesh *em, Object *ob,
 
                for(eve = em->verts.first, i = 0; eve; eve = eve->next, ++i)
                        DM_set_vert_data(&emdm->dm, i, CD_MDEFORMVERT,
-                                        CustomData_em_get(&em->vdata, eve->data, CD_MDEFORMVERT));
+                                                        CustomData_em_get(&em->vdata, eve->data, CD_MDEFORMVERT));
        }
 
        if(vertexCos) {
@@ -1596,9 +1596,9 @@ static void add_weight_mcol_dm(Object *ob, DerivedMesh *dm)
  * - apply deform modifiers and input vertexco
  */
 static void mesh_calc_modifiers(Scene *scene, Object *ob, float (*inputVertexCos)[3],
-                                DerivedMesh **deform_r, DerivedMesh **final_r,
-                                int useRenderParams, int useDeform,
-                                int needMapping, CustomDataMask dataMask, int index, int useCache)
+                                                               DerivedMesh **deform_r, DerivedMesh **final_r,
+                                                               int useRenderParams, int useDeform,
+                                                               int needMapping, CustomDataMask dataMask, int index, int useCache)
 {
        Mesh *me = ob->data;
        ModifierData *firstmd, *md;
@@ -1716,7 +1716,7 @@ static void mesh_calc_modifiers(Scene *scene, Object *ob, float (*inputVertexCos
                                         */
                                        numVerts = dm->getNumVerts(dm);
                                        deformedVerts =
-                                           MEM_mallocN(sizeof(*deformedVerts) * numVerts, "dfmv");
+                                               MEM_mallocN(sizeof(*deformedVerts) * numVerts, "dfmv");
                                        dm->getVertCos(dm, deformedVerts);
                                } else {
                                        deformedVerts = mesh_getVertexCos(me, &numVerts);
@@ -1891,8 +1891,8 @@ static int editmesh_modifier_is_enabled(Scene *scene, ModifierData *md, DerivedM
 }
 
 static void editmesh_calc_modifiers(Scene *scene, Object *ob, EditMesh *em, DerivedMesh **cage_r,
-                                    DerivedMesh **final_r,
-                                    CustomDataMask dataMask)
+                                                                       DerivedMesh **final_r,
+                                                                       CustomDataMask dataMask)
 {
        ModifierData *md;
        float (*deformedVerts)[3] = NULL;
@@ -1947,7 +1947,7 @@ static void editmesh_calc_modifiers(Scene *scene, Object *ob, EditMesh *em, Deri
                                         */
                                        numVerts = dm->getNumVerts(dm);
                                        deformedVerts =
-                                           MEM_mallocN(sizeof(*deformedVerts) * numVerts, "dfmv");
+                                               MEM_mallocN(sizeof(*deformedVerts) * numVerts, "dfmv");
                                        dm->getVertCos(dm, deformedVerts);
                                } else {
                                        deformedVerts = editmesh_getVertexCos(em, &numVerts);
@@ -2029,8 +2029,8 @@ static void editmesh_calc_modifiers(Scene *scene, Object *ob, EditMesh *em, Deri
                                *cage_r = dm;
                        } else {
                                *cage_r =
-                                   getEditMeshDerivedMesh(em, ob,
-                                       deformedVerts ? MEM_dupallocN(deformedVerts) : NULL);
+                                       getEditMeshDerivedMesh(em, ob,
+                                               deformedVerts ? MEM_dupallocN(deformedVerts) : NULL);
                        }
                }
        }
@@ -2202,7 +2202,7 @@ DerivedMesh *mesh_create_derived_view(Scene *scene, Object *ob, CustomDataMask d
 }
 
 DerivedMesh *mesh_create_derived_no_deform(Scene *scene, Object *ob, float (*vertCos)[3],
-                                           CustomDataMask dataMask)
+                                                                                  CustomDataMask dataMask)
 {
        DerivedMesh *final;
        
@@ -2212,7 +2212,7 @@ DerivedMesh *mesh_create_derived_no_deform(Scene *scene, Object *ob, float (*ver
 }
 
 DerivedMesh *mesh_create_derived_no_virtual(Scene *scene, Object *ob, float (*vertCos)[3],
-                                            CustomDataMask dataMask)
+                                                                                       CustomDataMask dataMask)
 {
        DerivedMesh *final;
        
@@ -2222,8 +2222,8 @@ DerivedMesh *mesh_create_derived_no_virtual(Scene *scene, Object *ob, float (*ve
 }
 
 DerivedMesh *mesh_create_derived_no_deform_render(Scene *scene, Object *ob,
-                                                  float (*vertCos)[3],
-                                                  CustomDataMask dataMask)
+                                                                                                 float (*vertCos)[3],
+                                                                                                 CustomDataMask dataMask)
 {
        DerivedMesh *final;
 
@@ -2235,7 +2235,7 @@ DerivedMesh *mesh_create_derived_no_deform_render(Scene *scene, Object *ob,
 /***/
 
 DerivedMesh *editmesh_get_derived_cage_and_final(Scene *scene, Object *obedit, EditMesh *em, DerivedMesh **final_r,
-                                                 CustomDataMask dataMask)
+                                                                                                CustomDataMask dataMask)
 {
        /* if there's no derived mesh or the last data mask used doesn't include
         * the data we need, rebuild the derived mesh
index cf61de1..afd0b3a 100644 (file)
 /* *********************** NOTE ON POSE AND ACTION **********************
 
   - Pose is the local (object level) component of armature. The current
-    object pose is saved in files, and (will be) is presorted for dependency
+       object pose is saved in files, and (will be) is presorted for dependency
   - Actions have fewer (or other) channels, and write data to a Pose
   - Currently ob->pose data is controlled in where_is_pose only. The (recalc)
-    event system takes care of calling that
+       event system takes care of calling that
   - The NLA system (here too) uses Poses as interpolation format for Actions
   - Therefore we assume poses to be static, and duplicates of poses have channels in
-    same order, for quick interpolation reasons
+       same order, for quick interpolation reasons
 
   ****************************** (ton) ************************************ */
 
@@ -1138,17 +1138,17 @@ static void blend_pose_strides(bPose *dst, bPose *src, float srcweight, short mo
 
 bone matching diagram, strips A and B
 
-                 .------------------------.
-                 |         A              |
-                 '------------------------'
+                                .------------------------.
+                                |         A              |
+                                '------------------------'
                                 .          .             b2
-                 .          .-------------v----------.
-                 .             |         B   .          |
-                 .          '------------------------'
-                 .          .             .
-                 .          .             .
+                                .          .-------------v----------.
+                                .              |         B   .          |
+                                .          '------------------------'
+                                .          .             .
+                                .          .             .
 offset:          .    0     .    A-B      .  A-b2+B     
-                 .          .             .
+                                .          .             .
 
 */
 
index 9eb6c3a..b2ac32d 100644 (file)
@@ -439,7 +439,7 @@ void calc_curvepath(Object *ob)
        fp= dist+1;
        maxdist= dist+tot;
        fac= 1.0f/((float)path->len-1.0f);
-        fac = fac * path->totdist;
+               fac = fac * path->totdist;
        
        for(a=0; a<path->len; a++) {
                
index 584f317..a2749a5 100644 (file)
@@ -769,7 +769,7 @@ static short animsys_remap_path (AnimMapper *remap, char *path, char **dst)
 /* Write the given value to a setting using RNA, and return success */
 static short animsys_write_rna_setting (PointerRNA *ptr, char *path, int array_index, float value)
 {
-    // printf("%p %s %i %f\n", ptr, path, array_index, value);
+       // printf("%p %s %i %f\n", ptr, path, array_index, value);
 
        PropertyRNA *prop;
        PointerRNA new_ptr;
@@ -1740,7 +1740,7 @@ void BKE_animsys_evaluate_animdata (ID *id, AnimData *adt, float ctime, short re
         */
        // TODO: need to double check that this all works correctly
        if ((recalc & ADT_RECALC_ANIM) || (adt->recalc & ADT_RECALC_ANIM))
-       {
+        {
                /* evaluate NLA data */
                if ((adt->nla_tracks.first) && !(adt->flag & ADT_NLA_EVAL_OFF))
                {
index 387b8a1..668ce9a 100644 (file)
@@ -708,7 +708,7 @@ static void pchan_b_bone_defmats(bPoseChannel *pchan, int use_quaternion, int re
        invert_m4_m4(b_bone_mats[0].mat, bone->arm_mat);
 
        /* then we make the b_bone_mats:
-           - first transform to local bone space
+               - first transform to local bone space
                - translate over the curve to the bbone mat space
                - transform with b_bone matrix
                - transform back into global space */
@@ -905,7 +905,7 @@ static void pchan_bone_deform(bPoseChannel *pchan, float weight, float *vec, Dua
 }
 
 void armature_deform_verts(Object *armOb, Object *target, DerivedMesh *dm,
-                           float (*vertexCos)[3], float (*defMats)[3][3],
+                                                  float (*vertexCos)[3], float (*defMats)[3][3],
                                                   int numVerts, int deformflag, 
                                                   float (*prevCos)[3], const char *defgrp_name)
 {
@@ -983,9 +983,9 @@ void armature_deform_verts(Object *armOb, Object *target, DerivedMesh *dm,
 
                        if(use_dverts) {
                                defnrToPC = MEM_callocN(sizeof(*defnrToPC) * numGroups,
-                                                       "defnrToBone");
+                                                                               "defnrToBone");
                                for(i = 0, dg = target->defbase.first; dg;
-                                   i++, dg = dg->next) {
+                                       i++, dg = dg->next) {
                                        defnrToPC[i] = get_pose_channel(armOb->pose, dg->name);
                                        /* exclude non-deforming bones */
                                        if(defnrToPC[i]) {
@@ -1070,10 +1070,10 @@ void armature_deform_verts(Object *armOb, Object *target, DerivedMesh *dm,
                                        
                                        if(bone && bone->flag & BONE_MULT_VG_ENV) {
                                                weight *= distfactor_to_bone(co, bone->arm_head,
-                                                                            bone->arm_tail,
-                                                                            bone->rad_head,
-                                                                            bone->rad_tail,
-                                                                            bone->dist);
+                                                                                                        bone->arm_tail,
+                                                                                                        bone->rad_head,
+                                                                                                        bone->rad_tail,
+                                                                                                        bone->dist);
                                        }
                                        pchan_bone_deform(pchan, weight, vec, dq, smat, co, &contrib);
                                }
@@ -1083,7 +1083,7 @@ void armature_deform_verts(Object *armOb, Object *target, DerivedMesh *dm,
                         */
                        if(deformed == 0 && use_envelope) {
                                for(pchan = armOb->pose->chanbase.first; pchan;
-                                   pchan = pchan->next) {
+                                       pchan = pchan->next) {
                                        if(!(pchan->bone->flag & BONE_NO_DEFORM))
                                                contrib += dist_bone_deform(pchan, vec, dq, smat, co);
                                }
@@ -1091,7 +1091,7 @@ void armature_deform_verts(Object *armOb, Object *target, DerivedMesh *dm,
                }
                else if(use_envelope) {
                        for(pchan = armOb->pose->chanbase.first; pchan;
-                           pchan = pchan->next) {
+                               pchan = pchan->next) {
                                if(!(pchan->bone->flag & BONE_NO_DEFORM))
                                        contrib += dist_bone_deform(pchan, vec, dq, smat, co);
                        }
@@ -1293,10 +1293,10 @@ void pchan_apply_mat4(bPoseChannel *pchan, float mat[][4])
  */
 void armature_mat_pose_to_delta(float delta_mat[][4], float pose_mat[][4], float arm_mat[][4])
 {
-       float imat[4][4];
+        float imat[4][4];
  
-       invert_m4_m4(imat, arm_mat);
-       mul_m4_m4m4(delta_mat, pose_mat, imat);
+        invert_m4_m4(imat, arm_mat);
+        mul_m4_m4m4(delta_mat, pose_mat, imat);
 }
 
 /* **************** Rotation Mode Conversions ****************************** */
@@ -1369,21 +1369,21 @@ void BKE_rotMode_change_values (float quat[4], float eul[3], float axis[3], floa
   
   *************************************************************************** */
 /*  Computes vector and roll based on a rotation. "mat" must
-     contain only a rotation, and no scaling. */ 
+        contain only a rotation, and no scaling. */ 
 void mat3_to_vec_roll(float mat[][3], float *vec, float *roll) 
 {
-    if (vec)
-        copy_v3_v3(vec, mat[1]);
+       if (vec)
+               copy_v3_v3(vec, mat[1]);
 
-    if (roll) {
-        float vecmat[3][3], vecmatinv[3][3], rollmat[3][3];
+       if (roll) {
+               float vecmat[3][3], vecmatinv[3][3], rollmat[3][3];
 
-        vec_roll_to_mat3(mat[1], 0.0f, vecmat);
-        invert_m3_m3(vecmatinv, vecmat);
-        mul_m3_m3m3(rollmat, vecmatinv, mat);
+               vec_roll_to_mat3(mat[1], 0.0f, vecmat);
+               invert_m3_m3(vecmatinv, vecmat);
+               mul_m3_m3m3(rollmat, vecmatinv, mat);
 
-        *roll= (float)atan2(rollmat[2][0], rollmat[2][2]);
-    }
+               *roll= (float)atan2(rollmat[2][0], rollmat[2][2]);
+       }
 }
 
 /*     Calculates the rest matrix of a bone based
index 5f9b4f1..5f6a427 100644 (file)
@@ -179,7 +179,7 @@ void detectBitmapFont(ImBuf *ibuf)
        int i;
        
        if (ibuf != NULL) {
-               // bitmap must have an x size that is a power of two
+                       // bitmap must have an x size that is a power of two
                if (is_power_of_two(ibuf->x)) {
                        rect = (unsigned char *) (ibuf->rect + (ibuf->x * (ibuf->y - 1)));
                        // printf ("starts with: %s %c %c %c %c\n", rect, rect[0], rect[1], rect[2], rect[3]);
index 710bbfa..3e43dfb 100644 (file)
@@ -137,7 +137,7 @@ static void VertexIt_Construct(CSG_VertexIteratorDescriptor *output, DerivedMesh
        
        it->pos = 0;
 
-       // assign iterator function pointers.
+        // assign iterator function pointers.
        output->Step = VertexIt_Step;
        output->Fill = VertexIt_Fill;
        output->Done = VertexIt_Done;
@@ -353,9 +353,9 @@ static DerivedMesh *ConvertCSGDescriptorsToDerivedMesh(
        // create a new DerivedMesh
        result = CDDM_new(vertex_it->num_elements, 0, face_it->num_elements);
        CustomData_merge(&dm1->faceData, &result->faceData, CD_MASK_DERIVEDMESH,
-                         CD_DEFAULT, face_it->num_elements); 
+                                         CD_DEFAULT, face_it->num_elements); 
        CustomData_merge(&dm2->faceData, &result->faceData, CD_MASK_DERIVEDMESH,
-                         CD_DEFAULT, face_it->num_elements); 
+                                         CD_DEFAULT, face_it->num_elements); 
 
        // step through the vertex iterators:
        for (i = 0; !vertex_it->Done(vertex_it->it); i++) {
@@ -422,7 +422,7 @@ static DerivedMesh *ConvertCSGDescriptorsToDerivedMesh(
                        mface->mat_nr = 0;
 
                InterpCSGFace(result, orig_dm, i, orig_index, csgface.vertex_number,
-                             (orig_me == me2)? mapmat: NULL);
+                                         (orig_me == me2)? mapmat: NULL);
 
                test_index_face(mface, &result->faceData, i, csgface.vertex_number);
        }
@@ -588,7 +588,7 @@ int NewBooleanMesh(Scene *scene, Base *base, Base *base_select, int int_op_type)
 }
 
 DerivedMesh *NewBooleanDerivedMesh(DerivedMesh *dm, struct Object *ob, DerivedMesh *dm_select, struct Object *ob_select,
-                                   int int_op_type)
+                                                                  int int_op_type)
 {
        return NewBooleanDerivedMesh_intern(dm, ob, dm_select, ob_select, int_op_type, NULL, NULL);
 }
index 4aaf95e..4b8c3a2 100644 (file)
@@ -678,7 +678,7 @@ static void brush_painter_refresh_cache(BrushPainter *painter, float *pos)
        short flt;
 
        if ((brush->size != cache->lastsize) || (brush->alpha != cache->lastalpha)
-           || (brush->jitter != cache->lastjitter)) {
+               || (brush->jitter != cache->lastjitter)) {
                if (cache->ibuf) {
                        IMB_freeImBuf(cache->ibuf);
                        cache->ibuf= NULL;
@@ -938,7 +938,7 @@ unsigned int *brush_gen_texture_cache(Brush *br, int half_side)
                                 */
                                if(hasrgb & TEX_RGB)
                                        texres.tin = (0.35 * texres.tr + 0.45 *
-                                                     texres.tg + 0.2 * texres.tb);
+                                                                 texres.tg + 0.2 * texres.tb);
 
                                texres.tin = texres.tin * 255.0;
                                ((char*)texcache)[(iy*side+ix)*4] = (char)texres.tin;
index 65fda67..1b72575 100644 (file)
@@ -210,7 +210,7 @@ static float nearest_point_in_tri_surface(const float *v0,const float *v1,const
                }
                else  // Region 0
                {
-            // Minimum at interior lv
+                       // Minimum at interior lv
                        float invDet;
                        if(fabs(Det) > FLT_EPSILON)
                                invDet = 1.0f / Det;
index 3a415d6..cca554b 100644 (file)
@@ -178,7 +178,7 @@ static ListBase *cdDM_getFaceMap(Object *ob, DerivedMesh *dm)
                Mesh *me= ob->data;
 
                create_vert_face_map(&cddm->fmap, &cddm->fmap_mem, me->mface,
-                                    me->totvert, me->totface);
+                                        me->totvert, me->totface);
        }
 
        return cddm->fmap;
@@ -193,7 +193,7 @@ static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
 
                cddm->pbvh = BLI_pbvh_new();
                BLI_pbvh_build_mesh(cddm->pbvh, me->mface, me->mvert,
-                              me->totface, me->totvert);
+                                  me->totface, me->totvert);
        }
 
        return cddm->pbvh;
@@ -573,9 +573,9 @@ static void cdDM_drawFacesColored(DerivedMesh *dm, int useTwoSided, unsigned cha
 }
 
 static void cdDM_drawFacesTex_common(DerivedMesh *dm,
-               int (*drawParams)(MTFace *tface, MCol *mcol, int matnr),
-               int (*drawParamsMapped)(void *userData, int index),
-               void *userData) 
+                          int (*drawParams)(MTFace *tface, MCol *mcol, int matnr),
+                          int (*drawParamsMapped)(void *userData, int index),
+                          void *userData) 
 {
        CDDerivedMesh *cddm = (CDDerivedMesh*) dm;
        MVert *mv = cddm->mvert;
@@ -1272,10 +1272,10 @@ static void cdDM_drawMappedEdges(DerivedMesh *dm, int (*setDrawOptions)(void *us
 }
 
 static void cdDM_foreachMappedVert(
-                           DerivedMesh *dm,
-                           void (*func)(void *userData, int index, float *co,
-                                        float *no_f, short *no_s),
-                           void *userData)
+                                                  DerivedMesh *dm,
+                                                  void (*func)(void *userData, int index, float *co,
+                                                                               float *no_f, short *no_s),
+                                                  void *userData)
 {
        MVert *mv = CDDM_get_verts(dm);
        int i, orig, *index = DM_get_vert_data_layer(dm, CD_ORIGINDEX);
@@ -1292,10 +1292,10 @@ static void cdDM_foreachMappedVert(
 }
 
 static void cdDM_foreachMappedEdge(
-                           DerivedMesh *dm,
-                           void (*func)(void *userData, int index,
-                                        float *v0co, float *v1co),
-                           void *userData)
+                                                  DerivedMesh *dm,
+                                                  void (*func)(void *userData, int index,
+                                                                               float *v0co, float *v1co),
+                                                  void *userData)
 {
        CDDerivedMesh *cddm = (CDDerivedMesh*) dm;
        MVert *mv = cddm->mvert;
@@ -1314,10 +1314,10 @@ static void cdDM_foreachMappedEdge(
 }
 
 static void cdDM_foreachMappedFaceCenter(
-                           DerivedMesh *dm,
-                           void (*func)(void *userData, int index,
-                                        float *cent, float *no),
-                           void *userData)
+                                                  DerivedMesh *dm,
+                                                  void (*func)(void *userData, int index,
+                                                                               float *cent, float *no),
+                                                  void *userData)
 {
        CDDerivedMesh *cddm = (CDDerivedMesh*)dm;
        MVert *mv = cddm->mvert;
@@ -1466,11 +1466,11 @@ DerivedMesh *CDDM_from_mesh(Mesh *mesh, Object *ob)
        alloctype= CD_REFERENCE;
 
        CustomData_merge(&mesh->vdata, &dm->vertData, mask, alloctype,
-                        mesh->totvert);
+                                        mesh->totvert);
        CustomData_merge(&mesh->edata, &dm->edgeData, mask, alloctype,
-                        mesh->totedge);
+                                        mesh->totedge);
        CustomData_merge(&mesh->fdata, &dm->faceData, mask, alloctype,
-                        mesh->totface);
+                                        mesh->totface);
 
        cddm->mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
        cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
@@ -1482,8 +1482,8 @@ DerivedMesh *CDDM_from_mesh(Mesh *mesh, Object *ob)
 DerivedMesh *CDDM_from_editmesh(EditMesh *em, Mesh *me)
 {
        DerivedMesh *dm = CDDM_new(BLI_countlist(&em->verts),
-                                  BLI_countlist(&em->edges),
-                                  BLI_countlist(&em->faces));
+                                                          BLI_countlist(&em->edges),
+                                                          BLI_countlist(&em->faces));
        CDDerivedMesh *cddm = (CDDerivedMesh*)dm;
        EditVert *eve;
        EditEdge *eed;
@@ -1496,11 +1496,11 @@ DerivedMesh *CDDM_from_editmesh(EditMesh *em, Mesh *me)
        dm->deformedOnly = 1;
 
        CustomData_merge(&em->vdata, &dm->vertData, CD_MASK_DERIVEDMESH,
-                        CD_CALLOC, dm->numVertData);
+                                        CD_CALLOC, dm->numVertData);
        /* CustomData_merge(&em->edata, &dm->edgeData, CD_MASK_DERIVEDMESH,
-                        CD_CALLOC, dm->numEdgeData); */
+                                        CD_CALLOC, dm->numEdgeData); */
        CustomData_merge(&em->fdata, &dm->faceData, CD_MASK_DERIVEDMESH,
-                        CD_CALLOC, dm->numFaceData);
+                                        CD_CALLOC, dm->numFaceData);
 
        /* set eve->hash to vert index */
        for(i = 0, eve = em->verts.first; eve; eve = eve->next, ++i)
@@ -1519,7 +1519,7 @@ DerivedMesh *CDDM_from_editmesh(EditMesh *em, Mesh *me)
 
        index = dm->getVertDataArray(dm, CD_ORIGINDEX);
        for(i = 0, eve = em->verts.first; i < dm->numVertData;
-           i++, eve = eve->next, index++) {
+               i++, eve = eve->next, index++) {
                MVert *mv = &mvert[i];
 
                VECCOPY(mv->co, eve->co);
@@ -1539,7 +1539,7 @@ DerivedMesh *CDDM_from_editmesh(EditMesh *em, Mesh *me)
 
        index = dm->getEdgeDataArray(dm, CD_ORIGINDEX);
        for(i = 0, eed = em->edges.first; i < dm->numEdgeData;
-           i++, eed = eed->next, index++) {
+               i++, eed = eed->next, index++) {
                MEdge *med = &medge[i];
 
                med->v1 = eed->v1->tmp.l;
@@ -1559,7 +1559,7 @@ DerivedMesh *CDDM_from_editmesh(EditMesh *em, Mesh *me)
 
        index = dm->getFaceDataArray(dm, CD_ORIGINDEX);
        for(i = 0, efa = em->faces.first; i < dm->numFaceData;
-           i++, efa = efa->next, index++) {
+               i++, efa = efa->next, index++) {
                MFace *mf = &mface[i];
 
                mf->v1 = efa->v1->tmp.l;
@@ -1648,7 +1648,7 @@ DerivedMesh *CDDM_copy(DerivedMesh *source)
 }
 
 DerivedMesh *CDDM_from_template(DerivedMesh *source,
-                                int numVerts, int numEdges, int numFaces)
+                                                               int numVerts, int numEdges, int numFaces)
 {
        CDDerivedMesh *cddm = cdDM_create("CDDM_from_template dest");
        DerivedMesh *dm = &cddm->dm;
@@ -1718,7 +1718,7 @@ void CDDM_calc_normals(DerivedMesh *dm)
        if(numVerts == 0) return;
 
        temp_nors = MEM_callocN(numVerts * sizeof(*temp_nors),
-                               "CDDM_calc_normals temp_nors");
+                                                       "CDDM_calc_normals temp_nors");
 
        /* we don't want to overwrite any referenced layers */
        mv = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MVERT);
@@ -1728,7 +1728,7 @@ void CDDM_calc_normals(DerivedMesh *dm)
        face_nors = CustomData_get_layer(&dm->faceData, CD_NORMAL);
        if(!face_nors)
                face_nors = CustomData_add_layer(&dm->faceData, CD_NORMAL, CD_CALLOC,
-                                                NULL, dm->numFaceData);
+                                                                                NULL, dm->numFaceData);
 
        /* calculate face normals and add to vertex normals */
        mf = CDDM_get_faces(dm);
@@ -1802,7 +1802,7 @@ void CDDM_calc_edges(DerivedMesh *dm)
        med = CustomData_get_layer(&edgeData, CD_MEDGE);
        index = CustomData_get_layer(&edgeData, CD_ORIGINDEX);
        for(i = 0; !BLI_edgehashIterator_isDone(ehi);
-           BLI_edgehashIterator_step(ehi), ++i, ++med, ++index) {
+               BLI_edgehashIterator_step(ehi), ++i, ++med, ++index) {
                BLI_edgehashIterator_getKey(ehi, (int*)&med->v1, (int*)&med->v2);
 
                med->flag = ME_EDGEDRAW|ME_EDGERENDER;
index cf41392..33fe621 100644 (file)
@@ -75,7 +75,7 @@ double tval()
 static CM_SOLVER_DEF   solvers [] =
 {
        { "Implicit", CM_IMPLICIT, implicit_init, implicit_solver, implicit_free },
-        // { "Implicit C++", CM_IMPLICITCPP, implicitcpp_init, implicitcpp_solver, implicitcpp_free },
+               // { "Implicit C++", CM_IMPLICITCPP, implicitcpp_init, implicitcpp_solver, implicitcpp_free },
 };
 
 /* ********** cloth engine ******* */
@@ -745,10 +745,10 @@ static void cloth_apply_vgroup ( ClothModifierData *clmd, DerivedMesh *dm )
        verts = clothObj->verts;
        
        if (((clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_SCALING ) || 
-                    (clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_GOAL )) && 
-                    ((clmd->sim_parms->vgroup_mass>0) || 
-                    (clmd->sim_parms->vgroup_struct>0)||
-                    (clmd->sim_parms->vgroup_bend>0)))
+                        (clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_GOAL )) && 
+                        ((clmd->sim_parms->vgroup_mass>0) || 
+                        (clmd->sim_parms->vgroup_struct>0)||
+                        (clmd->sim_parms->vgroup_bend>0)))
        {
                for ( i = 0; i < numverts; i++, verts++ )
                {       
@@ -770,7 +770,7 @@ static void cloth_apply_vgroup ( ClothModifierData *clmd, DerivedMesh *dm )
                                                verts->goal  = ( float ) pow ( verts->goal , 4.0f );
                                                if ( verts->goal >=SOFTGOALSNAP )
                                                {
-                                                       verts->flags |= CLOTH_VERT_FLAG_PINNED;
+                                                        verts->flags |= CLOTH_VERT_FLAG_PINNED;
                                                }
                                        }
                                        
index 6410d02..4c0c10c 100644 (file)
@@ -754,10 +754,10 @@ void colorcorrection_do_ibuf(ImBuf *ibuf, const char *profile)
                cmsErrorAction(LCMS_ERROR_SHOW);
        
                hTransform = cmsCreateProofingTransform(imageProfile, TYPE_RGBA_8, imageProfile, TYPE_RGBA_8, 
-                                                 proofingProfile,
-                                                 INTENT_ABSOLUTE_COLORIMETRIC,
-                                                 INTENT_ABSOLUTE_COLORIMETRIC,
-                                                 cmsFLAGS_SOFTPROOFING);
+                                                                                         proofingProfile,
+                                                                                         INTENT_ABSOLUTE_COLORIMETRIC,
+                                                                                         INTENT_ABSOLUTE_COLORIMETRIC,
+                                                                                         cmsFLAGS_SOFTPROOFING);
        
                cmsDoTransform(hTransform, ibuf->rect, ibuf->crect, ibuf->x * ibuf->y);
        
index 78f1bb4..3ab5e94 100644 (file)
@@ -3054,7 +3054,7 @@ static void rbj_new_data (void *cdata)
        bRigidBodyJointConstraint *data= (bRigidBodyJointConstraint *)cdata;
        
        // removed code which set target of this constraint  
-    data->type=1;
+       data->type=1;
 }
 
 static void rbj_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata)
index 06921a0..4fed662 100644 (file)
@@ -569,7 +569,7 @@ static void calcknots(float *knots, short aantal, short order, short type)
        float k;
        int a, t;
 
-        t = aantal+order;
+               t = aantal+order;
        if(type==0) {
 
                for(a=0;a<t;a++) {
@@ -624,7 +624,7 @@ static void makecyclicknots(float *knots, short pnts, short order)
        }
 
        b= order;
-        c=pnts + order + order2;
+               c=pnts + order + order2;
        for(a=pnts+order2; a<c; a++) {
                knots[a]= knots[a-1]+ (knots[b]-knots[b-1]);
                b--;
@@ -671,14 +671,14 @@ static void basisNurb(float t, short order, short pnts, float *knots, float *bas
        int i, i1 = 0, i2 = 0 ,j, orderpluspnts, opp2, o2;
 
        orderpluspnts= order+pnts;
-        opp2 = orderpluspnts-1;
+               opp2 = orderpluspnts-1;
 
        /* this is for float inaccuracy */
        if(t < knots[0]) t= knots[0];
        else if(t > knots[opp2]) t= knots[opp2];
 
        /* this part is order '1' */
-        o2 = order + 1;
+               o2 = order + 1;
        for(i=0;i<opp2;i++) {
                if(knots[i]!=knots[i+1] && t>= knots[i] && t<=knots[i+1]) {
                        basis[i]= 1.0;
@@ -1002,18 +1002,18 @@ void forward_diff_bezier(float q0, float q1, float q2, float q3, float *p, int i
        f*= it;
        rt3= (q3-q0+3.0f*(q1-q2))/f;
        
-       q0= rt0;
+         q0= rt0;
        q1= rt1+rt2+rt3;
        q2= 2*rt2+6*rt3;
        q3= 6*rt3;
   
-       for(a=0; a<=it; a++) {
+         for(a=0; a<=it; a++) {
                *p= q0;
                p = (float *)(((char *)p)+stride);
                q0+= q1;
-               q1+= q2;
-               q2+= q3;
-       }
+                q1+= q2;
+                q2+= q3;
+        }
 }
 
 static void forward_diff_bezier_cotangent(float *p0, float *p1, float *p2, float *p3, float *p, int it, int stride)
@@ -1023,7 +1023,7 @@ static void forward_diff_bezier_cotangent(float *p0, float *p1, float *p2, float
         *
         * This could also be optimized like forward_diff_bezier */
        int a;
-       for(a=0; a<=it; a++) {
+         for(a=0; a<=it; a++) {
                float t = (float)a / (float)it;
 
                int i;
@@ -1032,7 +1032,7 @@ static void forward_diff_bezier_cotangent(float *p0, float *p1, float *p2, float
                }
                normalize_v3(p);
                p = (float *)(((char *)p)+stride);
-       }
+        }
 }
 
 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
@@ -1061,7 +1061,7 @@ float *make_orco_surf(Object *ob)
                sizev = nu->pntsv*nu->resolv;
                if (nu->flagu & CU_NURB_CYCLIC) sizeu++;
                if (nu->flagv & CU_NURB_CYCLIC) sizev++;
-               if(nu->pntsv>1) tot+= sizeu * sizev;
+                if(nu->pntsv>1) tot+= sizeu * sizev;
                
                nu= nu->next;
        }
@@ -1464,7 +1464,7 @@ static short bevelinside(BevList *bl1,BevList *bl2)
                                /* there's a transition, calc intersection point */
                                mode= cu_isectLL(prevbevp->vec, bevp->vec, hvec1, hvec2, 0, 1, &lab, &mu, vec);
                                /* if lab==0.0 or lab==1.0 then the edge intersects exactly a transition
-                                  only allow for one situation: we choose lab= 1.0
+                                          only allow for one situation: we choose lab= 1.0
                                 */
                                if(mode>=0 && lab!=0.0) {
                                        if(vec[0]<hvec1[0]) links++;
@@ -2578,13 +2578,13 @@ void calchandlesNurb(Nurb *nu) /* first, if needed, set handle flags */
 
 void testhandlesNurb(Nurb *nu)
 {
-    /* use when something has changed with handles.
-    it treats all BezTriples with the following rules:
-    PHASE 1: do types have to be altered?
-       Auto handles: become aligned when selection status is NOT(000 || 111)
-       Vector handles: become 'nothing' when (one half selected AND other not)
-    PHASE 2: recalculate handles
-    */
+       /* use when something has changed with handles.
+       it treats all BezTriples with the following rules:
+       PHASE 1: do types have to be altered?
+          Auto handles: become aligned when selection status is NOT(000 || 111)
+          Vector handles: become 'nothing' when (one half selected AND other not)
+       PHASE 2: recalculate handles
+       */
        BezTriple *bezt;
        short flag, a;
 
index a0eef4d..a755170 100644 (file)
@@ -82,27 +82,27 @@ typedef struct LayerTypeInfo {
         * count gives the number of elements in sources
         */
        void (*interp)(void **sources, float *weights, float *sub_weights,
-                      int count, void *dest);
+                                  int count, void *dest);
 
-    /* a function to swap the data in corners of the element */
+       /* a function to swap the data in corners of the element */
        void (*swap)(void *data, int *corner_indices);
 
-    /* a function to set a layer's data to default values. if NULL, the
+       /* a function to set a layer's data to default values. if NULL, the
           default is assumed to be all zeros */
        void (*set_default)(void *data, int count);
 
-    /* a function to read data from a cdf file */
+       /* a function to read data from a cdf file */
        int (*read)(CDataFile *cdf, void *data, int count);
 
-    /* a function to write data to a cdf file */
+       /* a function to write data to a cdf file */
        int (*write)(CDataFile *cdf, void *data, int count);
 
-    /* a function to determine file size */
+       /* a function to determine file size */
        size_t (*filesize)(CDataFile *cdf, void *data, int count);
 } LayerTypeInfo;
 
 static void layerCopy_mdeformvert(const void *source, void *dest,
-                                  int count)
+                                                                 int count)
 {
        int i, size = sizeof(MDeformVert);
 
@@ -144,7 +144,7 @@ static void linklist_free_simple(void *link)
 }
 
 static void layerInterp_mdeformvert(void **sources, float *weights,
-                                    float *sub_weights, int count, void *dest)
+                                                                       float *sub_weights, int count, void *dest)
 {
        MDeformVert *dvert = dest;
        LinkNode *dest_dw = NULL; /* a list of lists of MDeformWeight pointers */
@@ -174,7 +174,7 @@ static void layerInterp_mdeformvert(void **sources, float *weights,
                        /* if this def_nr is not in the list, add it */
                        if(!node) {
                                MDeformWeight *tmp_dw = MEM_callocN(sizeof(*tmp_dw),
-                                                           "layerInterp_mdeformvert tmp_dw");
+                                                                                       "layerInterp_mdeformvert tmp_dw");
                                tmp_dw->def_nr = dw->def_nr;
                                tmp_dw->weight = dw->weight * interp_weight;
                                BLI_linklist_prepend(&dest_dw, tmp_dw);
@@ -188,7 +188,7 @@ static void layerInterp_mdeformvert(void **sources, float *weights,
 
        if(totweight) {
                dvert->dw = MEM_callocN(sizeof(*dvert->dw) * totweight,
-                                       "layerInterp_mdeformvert dvert->dw");
+                                                               "layerInterp_mdeformvert dvert->dw");
                dvert->totweight = totweight;
 
                for(i = 0, node = dest_dw; node; node = node->next, ++i)
@@ -202,7 +202,7 @@ static void layerInterp_mdeformvert(void **sources, float *weights,
 
 
 static void layerInterp_msticky(void **sources, float *weights,
-                                float *sub_weights, int count, void *dest)
+                                                               float *sub_weights, int count, void *dest)
 {
        float co[2], w;
        MSticky *mst;
@@ -234,7 +234,7 @@ static void layerCopy_tface(const void *source, void *dest, int count)
 }
 
 static void layerInterp_tface(void **sources, float *weights,
-                              float *sub_weights, int count, void *dest)
+                                                         float *sub_weights, int count, void *dest)
 {
        MTFace *tf = dest;
        int i, j, k;
@@ -278,9 +278,9 @@ static void layerSwap_tface(void *data, int *corner_indices)
        MTFace *tf = data;
        float uv[4][2];
        static const short pin_flags[4] =
-           { TF_PIN1, TF_PIN2, TF_PIN3, TF_PIN4 };
+               { TF_PIN1, TF_PIN2, TF_PIN3, TF_PIN4 };
        static const char sel_flags[4] =
-           { TF_SEL1, TF_SEL2, TF_SEL3, TF_SEL4 };
+               { TF_SEL1, TF_SEL2, TF_SEL3, TF_SEL4 };
        short unwrap = tf->unwrap & ~(TF_PIN1 | TF_PIN2 | TF_PIN3 | TF_PIN4);
        char flag = tf->flag & ~(TF_SEL1 | TF_SEL2 | TF_SEL3 | TF_SEL4);
        int j;
@@ -310,7 +310,7 @@ static void layerSwap_tface(void *data, int *corner_indices)
 static void layerDefault_tface(void *data, int count)
 {
        static MTFace default_tf = {{{0, 0}, {1, 0}, {1, 1}, {0, 1}}, NULL,
-                                  0, 0, TF_DYNAMIC, 0, 0};
+                                                          0, 0, TF_DYNAMIC, 0, 0};
        MTFace *tf = (MTFace*)data;
        int i;
 
@@ -466,7 +466,7 @@ static void layerSwap_mdisps(void *data, int *ci)
 }
 
 static void layerInterp_mdisps(void **sources, float *weights, float *sub_weights,
-                              int count, void *dest)
+                                  int count, void *dest)
 {
        // XXX
 #if 0
@@ -680,7 +680,7 @@ static void layerInterp_mloopuv(void **sources, float *weights,
 }
 
 static void layerInterp_mcol(void **sources, float *weights,
-                             float *sub_weights, int count, void *dest)
+                                                        float *sub_weights, int count, void *dest)
 {
        MCol *mc = dest;
        int i, j, k;
@@ -843,7 +843,7 @@ static CustomDataLayer *customData_add_layer__internal(CustomData *data,
        int type, int alloctype, void *layerdata, int totelem, const char *name);
 
 void CustomData_merge(const struct CustomData *source, struct CustomData *dest,
-                      CustomDataMask mask, int alloctype, int totelem)
+                                         CustomDataMask mask, int alloctype, int totelem)
 {
        const LayerTypeInfo *typeInfo;
        CustomDataLayer *layer, *newlayer;
@@ -887,7 +887,7 @@ void CustomData_merge(const struct CustomData *source, struct CustomData *dest,
 }
 
 void CustomData_copy(const struct CustomData *source, struct CustomData *dest,
-                     CustomDataMask mask, int alloctype, int totelem)
+                                        CustomDataMask mask, int alloctype, int totelem)
 {
        memset(dest, 0, sizeof(*dest));
 
@@ -1142,7 +1142,7 @@ void CustomData_set_layer_flag(struct CustomData *data, int type, int flag)
 static int customData_resize(CustomData *data, int amount)
 {
        CustomDataLayer *tmp = MEM_callocN(sizeof(*tmp)*(data->maxlayer + amount),
-                                       "CustomData->layers");
+                                                                          "CustomData->layers");
        if(!tmp) return 0;
 
        data->maxlayer += amount;
@@ -1230,13 +1230,13 @@ static CustomDataLayer *customData_add_layer__internal(CustomData *data,
 }
 
 void *CustomData_add_layer(CustomData *data, int type, int alloctype,
-                           void *layerdata, int totelem)
+                                                  void *layerdata, int totelem)
 {
        CustomDataLayer *layer;
        const LayerTypeInfo *typeInfo= layerType_getInfo(type);
        
        layer = customData_add_layer__internal(data, type, alloctype, layerdata,
-                                              totelem, typeInfo->defaultname);
+                                                                                  totelem, typeInfo->defaultname);
 
        if(layer)
                return layer->data;
@@ -1246,12 +1246,12 @@ void *CustomData_add_layer(CustomData *data, int type, int alloctype,
 
 /*same as above but accepts a name*/
 void *CustomData_add_layer_named(CustomData *data, int type, int alloctype,
-                           void *layerdata, int totelem, char *name)
+                                                  void *layerdata, int totelem, char *name)
 {
        CustomDataLayer *layer;
        
        layer = customData_add_layer__internal(data, type, alloctype, layerdata,
-                                              totelem, name);
+                                                                                  totelem, name);
 
        if(layer)
                return layer->data;
@@ -1345,7 +1345,7 @@ void *CustomData_duplicate_referenced_layer(struct CustomData *data, int type)
 }
 
 void *CustomData_duplicate_referenced_layer_named(struct CustomData *data,
-                                                  int type, char *name)
+                                                                                                 int type, char *name)
 {
        CustomDataLayer *layer;
        int layer_index;
@@ -1390,7 +1390,7 @@ void CustomData_free_temporary(CustomData *data, int totelem)
 }
 
 void CustomData_set_only_copy(const struct CustomData *data,
-                              CustomDataMask mask)
+                                                         CustomDataMask mask)
 {
        int i;
 
@@ -1400,7 +1400,7 @@ void CustomData_set_only_copy(const struct CustomData *data,
 }
 
 void CustomData_copy_data(const CustomData *source, CustomData *dest,
-                          int source_index, int dest_index, int count)
+                                                 int source_index, int dest_index, int count)
 {
        const LayerTypeInfo *typeInfo;
        int src_i, dest_i;
@@ -1415,7 +1415,7 @@ void CustomData_copy_data(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while(dest_i < dest->totlayer
-                     && dest->layers[dest_i].type < source->layers[src_i].type)
+                         && dest->layers[dest_i].type < source->layers[src_i].type)
                        ++dest_i;
 
                /* if there are no more dest layers, we're done */
@@ -1433,12 +1433,12 @@ void CustomData_copy_data(const CustomData *source, CustomData *dest,
 
                        if(typeInfo->copy)
                                typeInfo->copy(src_data + src_offset,
-                                               dest_data + dest_offset,
-                                               count);
+                                                               dest_data + dest_offset,
+                                                               count);
                        else
                                memcpy(dest_data + dest_offset,
-                                      src_data + src_offset,
-                                      count * typeInfo->size);
+                                          src_data + src_offset,
+                                          count * typeInfo->size);
 
                        /* if there are multiple source & dest layers of the same type,
                         * we don't want to copy all source layers to the same dest, so
@@ -1462,7 +1462,7 @@ void CustomData_free_elem(CustomData *data, int index, int count)
                                int offset = typeInfo->size * index;
 
                                typeInfo->free((char *)data->layers[i].data + offset,
-                                              count, typeInfo->size);
+                                                          count, typeInfo->size);
                        }
                }
        }
@@ -1471,8 +1471,8 @@ void CustomData_free_elem(CustomData *data, int index, int count)
 #define SOURCE_BUF_SIZE 100
 
 void CustomData_interp(const CustomData *source, CustomData *dest,
-                       int *src_indices, float *weights, float *sub_weights,
-                       int count, int dest_index)
+                                          int *src_indices, float *weights, float *sub_weights,
+                                          int count, int dest_index)
 {
        int src_i, dest_i;
        int dest_offset;
@@ -1485,7 +1485,7 @@ void CustomData_interp(const CustomData *source, CustomData *dest,
         */
        if(count > SOURCE_BUF_SIZE)
                sources = MEM_callocN(sizeof(*sources) * count,
-                                     "CustomData_interp sources");
+                                                         "CustomData_interp sources");
 
        /* interpolates a layer at a time */
        dest_i = 0;
@@ -1497,7 +1497,7 @@ void CustomData_interp(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while(dest_i < dest->totlayer
-                     && dest->layers[dest_i].type < source->layers[src_i].type)
+                         && dest->layers[dest_i].type < source->layers[src_i].type)
                        ++dest_i;
 
                /* if there are no more dest layers, we're done */
@@ -1577,7 +1577,7 @@ void *CustomData_get_layer_n(const CustomData *data, int type, int n)
 }
 
 void *CustomData_get_layer_named(const struct CustomData *data, int type,
-                                 char *name)
+                                                                char *name)
 {
        int layer_index = CustomData_get_named_layer_index(data, type, name);
        if(layer_index < 0) return NULL;
@@ -1625,21 +1625,21 @@ void CustomData_set(const CustomData *data, int index, int type, void *source)
 
 void CustomData_em_free_block(CustomData *data, void **block)
 {
-    const LayerTypeInfo *typeInfo;
-    int i;
+       const LayerTypeInfo *typeInfo;
+       int i;
 
        if(!*block) return;
 
-    for(i = 0; i < data->totlayer; ++i) {
-        if(!(data->layers[i].flag & CD_FLAG_NOFREE)) {
-            typeInfo = layerType_getInfo(data->layers[i].type);
+       for(i = 0; i < data->totlayer; ++i) {
+               if(!(data->layers[i].flag & CD_FLAG_NOFREE)) {
+                       typeInfo = layerType_getInfo(data->layers[i].type);
 
-            if(typeInfo->free) {
+                       if(typeInfo->free) {
                                int offset = data->layers[i].offset;
-                typeInfo->free((char*)*block + offset, 1, typeInfo->size);
+                               typeInfo->free((char*)*block + offset, 1, typeInfo->size);
                        }
-        }
-    }
+               }
+       }
 
        MEM_freeN(*block);
        *block = NULL;
@@ -1659,7 +1659,7 @@ static void CustomData_em_alloc_block(CustomData *data, void **block)
 }
 
 void CustomData_em_copy_data(const CustomData *source, CustomData *dest,
-                            void *src_block, void **dest_block)
+                                                       void *src_block, void **dest_block)
 {
        const LayerTypeInfo *typeInfo;
        int dest_i, src_i;
@@ -1675,7 +1675,7 @@ void CustomData_em_copy_data(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while(dest_i < dest->totlayer
-                     && dest->layers[dest_i].type < source->layers[src_i].type)
+                         && dest->layers[dest_i].type < source->layers[src_i].type)
                        ++dest_i;
 
                /* if there are no more dest layers, we're done */
@@ -1752,7 +1752,7 @@ void CustomData_em_set_n(CustomData *data, void *block, int type, int n, void *s
 }
 
 void CustomData_em_interp(CustomData *data, void **src_blocks, float *weights,
-                          float *sub_weights, int count, void *dest_block)
+                                                 float *sub_weights, int count, void *dest_block)
 {
        int i, j;
        void *source_buf[SOURCE_BUF_SIZE];
@@ -1763,7 +1763,7 @@ void CustomData_em_interp(CustomData *data, void **src_blocks, float *weights,
         */
        if(count > SOURCE_BUF_SIZE)
                sources = MEM_callocN(sizeof(*sources) * count,
-                                     "CustomData_interp sources");
+                                                         "CustomData_interp sources");
 
        /* interpolates a layer at a time */
        for(i = 0; i < data->totlayer; ++i) {
@@ -1775,7 +1775,7 @@ void CustomData_em_interp(CustomData *data, void **src_blocks, float *weights,
                                sources[j] = (char *)src_blocks[j] + layer->offset;
 
                        typeInfo->interp(sources, weights, sub_weights, count,
-                                         (char *)dest_block + layer->offset);
+                                                         (char *)dest_block + layer->offset);
                }
        }
 
@@ -1801,7 +1801,7 @@ void CustomData_em_set_default(CustomData *data, void **block)
 }
 
 void CustomData_to_em_block(const CustomData *source, CustomData *dest,
-                            int src_index, void **dest_block)
+                                                       int src_index, void **dest_block)
 {
        const LayerTypeInfo *typeInfo;
        int dest_i, src_i, src_offset;
@@ -1817,7 +1817,7 @@ void CustomData_to_em_block(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while(dest_i < dest->totlayer
-                     && dest->layers[dest_i].type < source->layers[src_i].type)
+                         && dest->layers[dest_i].type < source->layers[src_i].type)
                        ++dest_i;
 
                /* if there are no more dest layers, we're done */
@@ -1847,7 +1847,7 @@ void CustomData_to_em_block(const CustomData *source, CustomData *dest,
 }
 
 void CustomData_from_em_block(const CustomData *source, CustomData *dest,
-                              void *src_block, int dest_index)
+                                                         void *src_block, int dest_index)
 {
        const LayerTypeInfo *typeInfo;
        int dest_i, src_i, dest_offset;
@@ -1860,7 +1860,7 @@ void CustomData_from_em_block(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while(dest_i < dest->totlayer
-                     && dest->layers[dest_i].type < source->layers[src_i].type)
+                         && dest->layers[dest_i].type < source->layers[src_i].type)
                        ++dest_i;
 
                /* if there are no more dest layers, we're done */
@@ -1923,20 +1923,20 @@ void CustomData_bmesh_init_pool(CustomData *data, int allocsize){
 
 void CustomData_bmesh_free_block(CustomData *data, void **block)
 {
-    const LayerTypeInfo *typeInfo;
-    int i;
+       const LayerTypeInfo *typeInfo;
+       int i;
 
        if(!*block) return;
-    for(i = 0; i < data->totlayer; ++i) {
-        if(!(data->layers[i].flag & CD_FLAG_NOFREE)) {
-            typeInfo = layerType_getInfo(data->layers[i].type);
+       for(i = 0; i < data->totlayer; ++i) {
+               if(!(data->layers[i].flag & CD_FLAG_NOFREE)) {
+                       typeInfo = layerType_getInfo(data->layers[i].type);
 
-            if(typeInfo->free) {
+                       if(typeInfo->free) {
                                int offset = data->layers[i].offset;
                                typeInfo->free((char*)*block + offset, 1, typeInfo->size);
                        }
-        }
-    }
+               }
+       }
 
        BLI_mempool_free(data->pool, *block);
        *block = NULL;
@@ -1955,7 +1955,7 @@ static void CustomData_bmesh_alloc_block(CustomData *data, void **block)
 }
 
 void CustomData_bmesh_copy_data(const CustomData *source, CustomData *dest,
-                            void *src_block, void **dest_block)
+                                                       void *src_block, void **dest_block)
 {
        const LayerTypeInfo *typeInfo;
        int dest_i, src_i;
@@ -1971,7 +1971,7 @@ void CustomData_bmesh_copy_data(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while(dest_i < dest->totlayer
-                     && dest->layers[dest_i].type < source->layers[src_i].type)
+                         && dest->layers[dest_i].type < source->layers[src_i].type)
                        ++dest_i;
 
                /* if there are no more dest layers, we're done */
@@ -2049,7 +2049,7 @@ void CustomData_bmesh_set_n(CustomData *data, void *block, int type, int n, void
 }
 
 void CustomData_bmesh_interp(CustomData *data, void **src_blocks, float *weights,
-                          float *sub_weights, int count, void *dest_block)
+                                                 float *sub_weights, int count, void *dest_block)
 {
        int i, j;
        void *source_buf[SOURCE_BUF_SIZE];
@@ -2060,7 +2060,7 @@ void CustomData_bmesh_interp(CustomData *data, void **src_blocks, float *weights
         */
        if(count > SOURCE_BUF_SIZE)
                sources = MEM_callocN(sizeof(*sources) * count,
-                                     "CustomData_interp sources");
+                                                         "CustomData_interp sources");
 
        /* interpolates a layer at a time */
        for(i = 0; i < data->totlayer; ++i) {
@@ -2071,7 +2071,7 @@ void CustomData_bmesh_interp(CustomData *data, void **src_blocks, float *weights
                                sources[j] = (char *)src_blocks[j] + layer->offset;
 
                        typeInfo->interp(sources, weights, sub_weights, count,
-                                         (char *)dest_block + layer->offset);
+                                                         (char *)dest_block + layer->offset);
                }
        }
 
@@ -2097,7 +2097,7 @@ void CustomData_bmesh_set_default(CustomData *data, void **block)
 }
 
 void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
-                            int src_index, void **dest_block)
+                                                       int src_index, void **dest_block)
 {
        const LayerTypeInfo *typeInfo;
        int dest_i, src_i, src_offset;
@@ -2113,7 +2113,7 @@ void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while(dest_i < dest->totlayer
-                     && dest->layers[dest_i].type < source->layers[src_i].type)
+                         && dest->layers[dest_i].type < source->layers[src_i].type)
                        ++dest_i;
 
                /* if there are no more dest layers, we're done */
@@ -2143,7 +2143,7 @@ void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
 }
 
 void CustomData_from_bmesh_block(const CustomData *source, CustomData *dest,
-                              void *src_block, int dest_index)
+                                                         void *src_block, int dest_index)
 {
        const LayerTypeInfo *typeInfo;
        int dest_i, src_i, dest_offset;
@@ -2156,7 +2156,7 @@ void CustomData_from_bmesh_block(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while(dest_i < dest->totlayer
-                     && dest->layers[dest_i].type < source->layers[src_i].type)
+                         && dest->layers[dest_i].type < source->layers[src_i].type)
                        ++dest_i;
 
                /* if there are no more dest layers, we're done */
@@ -2296,8 +2296,8 @@ int CustomData_verify_versions(struct CustomData *data, int index)
        }
 
        if (!keeplayer) {
-           for (i=index+1; i < data->totlayer; ++i)
-           data->layers[i-1] = data->layers[i];
+               for (i=index+1; i < data->totlayer; ++i)
+                       data->layers[i-1] = data->layers[i];
                data->totlayer--;
        }
 
index 397a052..4e02703 100644 (file)
@@ -951,7 +951,7 @@ static void dag_node_print_dependency_cycle(DagForest *dag, DagNode *startnode,
 {
        DagNode *node;
 
-    for(node = dag->DagNode.first; node; node= node->next)
+       for(node = dag->DagNode.first; node; node= node->next)
                node->color= DAG_WHITE;
 
        printf("  %s depends on %s through %s.\n", dag_node_name(endnode), dag_node_name(startnode), name);
@@ -1533,7 +1533,7 @@ int       is_acyclic( DagForest   *dag) {
 
 void set_node_xy(DagNode *node, float x, float y)
 {
-       node->x = x;
+        node->x = x;
        node->y = y;
 }
 
index ed7d118..8619b6e 100644 (file)
@@ -490,7 +490,7 @@ static void mesh_create_shadedColors(Render *re, Object *ob, int onlyForMesh, un
        float *orco, *vnors, *nors, imat[3][3], mat[4][4], vec[3];
        int a, i, need_orco, totface, totvert;
        CustomDataMask dataMask = CD_MASK_BAREMESH | CD_MASK_MCOL
-                                 | CD_MASK_MTFACE | CD_MASK_NORMAL;
+                                                         | CD_MASK_MTFACE | CD_MASK_NORMAL;
 
 
        init_fastshade_for_ob(re, ob, &need_orco, mat, imat);
@@ -1784,9 +1784,9 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
 
                if(cu->flag & CU_PATH) calc_curvepath(ob);
 
-               if (!forRender) {
-                       tex_space_curve(cu);
-               }
+                if (!forRender) {
+                        tex_space_curve(cu);
+                }
 
                if(!forOrco) curve_calc_modifiers_post(scene, ob, dispbase, derivedFinal, forRender, originalVerts, deformedVerts);
 
index 14375c2..66e7f80 100644 (file)
@@ -955,15 +955,15 @@ void do_physical_effector(EffectorCache *eff, EffectorData *efd, EffectedPoint *
 }
 
 /*  -------- pdDoEffectors() --------
-    generic force/speed system, now used for particles and softbodies
-    scene       = scene where it runs in, for time and stuff
+       generic force/speed system, now used for particles and softbodies
+       scene       = scene where it runs in, for time and stuff
        lb                      = listbase with objects that take part in effecting
        opco            = global coord, as input
-    force              = force accumulator
-    speed              = actual current speed which can be altered
+       force           = force accumulator
+       speed           = actual current speed which can be altered
        cur_time        = "external" time in frames, is constant for static particles
        loc_time        = "local" time in frames, range <0-1> for the lifetime of particle
-    par_layer  = layer the caller is in
+       par_layer       = layer the caller is in
        flags           = only used for softbody wind now
        guide           = old speed of particle
 
index 772a589..91c5a63 100644 (file)
@@ -129,19 +129,19 @@ static int is_stl(char *str)
 
 #define READSTLVERT {                                   \
   if (fread(mvert->co, sizeof(float), 3, fpSTL) != 3) { \
-    char error_msg[255];                                \
-    MEM_freeN(vertdata);                                \
-    MEM_freeN(facedata);                                \
-    fclose(fpSTL);                                      \
-    sprintf(error_msg, "Problems reading face %d!", i); \
-    return;                                             \
+       char error_msg[255];                                \
+       MEM_freeN(vertdata);                                \
+       MEM_freeN(facedata);                                \
+       fclose(fpSTL);                                      \
+       sprintf(error_msg, "Problems reading face %d!", i); \
+       return;                                             \
   }                                                     \
   else {                                                \
-    if (ENDIAN_ORDER==B_ENDIAN) {                       \
-      SWITCH_INT(mvert->co[0]);                         \
-      SWITCH_INT(mvert->co[1]);                         \
-      SWITCH_INT(mvert->co[2]);                         \
-    }                                                   \
+       if (ENDIAN_ORDER==B_ENDIAN) {                       \
+         SWITCH_INT(mvert->co[0]);                         \
+         SWITCH_INT(mvert->co[1]);                         \
+         SWITCH_INT(mvert->co[2]);                         \
+       }                                                   \
   }                                                     \
 }
 
@@ -267,9 +267,9 @@ static void read_stl_mesh_binary(Scene *scene, char *str)
                        me->totvert = totvert;
                        me->totface = totface;
                        me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN,
-                                                        vertdata, totvert);
+                                                                                        vertdata, totvert);
                        me->mface = CustomData_add_layer(&me->fdata, CD_MFACE, CD_ASSIGN,
-                                                        facedata, totface);
+                                                                                        facedata, totface);
 
                        mesh_add_normals_flags(me);
                        make_edges(me, 0);
@@ -410,9 +410,9 @@ static void read_stl_mesh_ascii(Scene *scene, char *str)
        me->totface = totface;
        me->totvert = totvert;
        me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC,
-                                        NULL, totvert);
+                                                                        NULL, totvert);
        me->mface = CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC,
-                                        NULL, totface);
+                                                                        NULL, totface);
 
        /* Copy vert coords and create topology */
        mvert = me->mvert;
@@ -862,7 +862,7 @@ static void read_inventor(Scene *scene, char *str, struct ListBase *listb)
                                /* count the nr of lines */
                                tot= 0;
                                index= iv->data[0];
-                                lll = iv->datalen[0]-1;
+                                                               lll = iv->datalen[0]-1;
                                for(a=0; a<lll; a++) {
                                        if(index[0]!= -1 && index[1]!= -1) tot++;
                                        index++;
@@ -1009,7 +1009,7 @@ static void read_inventor(Scene *scene, char *str, struct ListBase *listb)
                                        }
                                                
                                        /* indices */
-                                        lll = index[0] - 2;
+                                                                               lll = index[0] - 2;
                                        for(b=0; b<lll; b++) {
                                                idata[0]= first;
                                                idata[1]= first+1;
@@ -1045,7 +1045,7 @@ static void read_inventor(Scene *scene, char *str, struct ListBase *listb)
                                /* count triangles */
                                face= 0;
                                index= iv->data[0];
-                lll = iv->datalen[0]-2;
+                               lll = iv->datalen[0]-2;
                                for(a=0; a<lll; a++) {
                                        if(index[0]!= -1 && index[1]!= -1 && index[2]!= -1) face++;
                                        index++;
@@ -1123,7 +1123,7 @@ static void read_inventor(Scene *scene, char *str, struct ListBase *listb)
                                /* count triangles */
                                face= 0;
                                index= iv->data[0];
-                                lll=iv->datalen[0]-2;
+                                                               lll=iv->datalen[0]-2;
                                for(a=0; a<lll; a++) {
                                        if(index[0]!= -1 && index[1]!= -1 && index[2]!= -1) face++;
                                        index++;
@@ -1155,7 +1155,7 @@ static void read_inventor(Scene *scene, char *str, struct ListBase *listb)
                                index= iv->data[0];
                                idata= dl->index;
                                
-                                lll=iv->datalen[0]-2;
+                                                               lll=iv->datalen[0]-2;
                                for(a=lll; a>0; a--) {
                                
                                        if(index[0]!= -1 && index[1]!= -1 && index[2]!= -1) {
@@ -1476,9 +1476,9 @@ static void displist_to_mesh(Scene *scene, DispList *dlfirst)
        me->totvert= totvert;
        me->totface= totface;
        me->mvert= CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC,
-                                       NULL, me->totvert);
+                                                                       NULL, me->totvert);
        me->mface= CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC,
-                                       NULL, me->totface);
+                                                                       NULL, me->totface);
        maxvertidx= totvert-1;
        
        mvert= me->mvert;
@@ -1956,8 +1956,8 @@ void write_stl(Scene *scene, char *str)
        fseek(fpSTL, 80, SEEK_SET);
 
        if (ENDIAN_ORDER==B_ENDIAN) {
-                SWITCH_INT(numfacets);
-        }
+                               SWITCH_INT(numfacets);
+               }
        fwrite(&numfacets, 4*sizeof(char), 1, fpSTL);
 
        fclose(fpSTL);
@@ -2574,13 +2574,13 @@ void write_dxf(struct Scene *scene, char *str)
        /* The header part of the DXF */
        
        write_group(0, "SECTION");
-    write_group(2, "HEADER");
+       write_group(2, "HEADER");
        write_group(0, "ENDSEC");
 
        /* The blocks part of the DXF */
        
        write_group(0, "SECTION");
-    write_group(2, "BLOCKS");
+       write_group(2, "BLOCKS");
 
     
        /* only write meshes we're using in this scene */
@@ -2604,7 +2604,7 @@ void write_dxf(struct Scene *scene, char *str)
        /* The entities part of the DXF */
        
        write_group(0, "SECTION");
-    write_group(2, "ENTITIES");
+       write_group(2, "ENTITIES");
 
        /* Write all the mesh objects */
        base= scene->base.first;
@@ -3056,7 +3056,7 @@ static void dxf_read_line(Scene *scene, int noob) {
        hasbumped=1;
 }
 
-        /* 2D Polyline state vars */
+               /* 2D Polyline state vars */
 static Object *p2dhold=NULL;
 static Mesh *p2dmhold=NULL;
 static char oldplay[32];
@@ -3131,35 +3131,35 @@ static void dxf_read_ellipse(Scene *scene, int noob)
        read_group(id, val);                                                            
        while(id!=0) {
          if (id==8) {
-           BLI_strncpy(layname, val, sizeof(layname));
+               BLI_strncpy(layname, val, sizeof(layname));
          } else if (id==10) {
-           center[0]= (float) atof(val);
+               center[0]= (float) atof(val);
          } else if (id==20) {
-           center[1]= (float) atof(val);
+               center[1]= (float) atof(val);
          } else if (id==30) {
-           center[2]= (float) atof(val);
+               center[2]= (float) atof(val);
          } else if (id==11) {
-           axis_endpoint[0]= (float) atof(val);
+               axis_endpoint[0]= (float) atof(val);
          } else if (id==21) {
-           axis_endpoint[1]= (float) atof(val);
+               axis_endpoint[1]= (float) atof(val);
          } else if (id==31) {
-           axis_endpoint[2]= (float) atof(val);
+               axis_endpoint[2]= (float) atof(val);
          } else if (id==40) {
-           axis_ratio = (float) atof(val);
+               axis_ratio = (float) atof(val);
                } else if (id==41) {
                        printf("dxf: start = %f", atof(val) * 180/M_PI);
-           start_angle = -atof(val) + M_PI_2;
+               start_angle = -atof(val) + M_PI_2;
          } else if (id==42) {
                        printf("dxf: end = %f", atof(val) * 180/M_PI);
                        end_angle = -atof(val) + M_PI_2; 
          } else if (id==62) {
-           int colorid= atoi(val);
-           CLAMP(colorid, 1, 255);
-           dxf_col_to_rgb(colorid, &color[0], &color[1], &color[2]);
+               int colorid= atoi(val);
+               CLAMP(colorid, 1, 255);
+               dxf_col_to_rgb(colorid, &color[0], &color[1], &color[2]);
          } else if (id==67) {
-           vspace= atoi(val);
+               vspace= atoi(val);
          } else if (id==100) {
-           isArc = 1;
+               isArc = 1;
          } else if (id==210) {
                        extrusion[0] = atof(val);
                } else if (id==220) {
@@ -3290,28 +3290,28 @@ static void dxf_read_arc(Scene *scene, int noob)
        read_group(id, val);                                                            
        while(id!=0) {
          if (id==8) {
-           BLI_strncpy(layname, val, sizeof(layname));
+               BLI_strncpy(layname, val, sizeof(layname));
          } else if (id==10) {
-           center[0]= (float) atof(val);
+               center[0]= (float) atof(val);
          } else if (id==20) {
-           center[1]= (float) atof(val);
+               center[1]= (float) atof(val);
          } else if (id==30) {
-           center[2]= (float) atof(val);
+               center[2]= (float) atof(val);
          } else if (id==40) {
-           dia = (float) atof(val);
+               dia = (float) atof(val);
          } else if (id==62) {
-           int colorid= atoi(val);
+               int colorid= atoi(val);
            
-           CLAMP(colorid, 1, 255);
-           dxf_col_to_rgb(colorid, &color[0], &color[1], &color[2]);
+               CLAMP(colorid, 1, 255);
+               dxf_col_to_rgb(colorid, &color[0], &color[1], &color[2]);
          } else if (id==67) {
-           vspace= atoi(val);
+               vspace= atoi(val);
          } else if (id==100) {
-           isArc = 1;
+               isArc = 1;
          } else if (id==50) {
-           start_angle = (90 - atoi(val)) * M_PI/180.0;
+               start_angle = (90 - atoi(val)) * M_PI/180.0;
          } else if (id==51) {
-           end_angle = (90 - atoi(val)) * M_PI/180.0;
+               end_angle = (90 - atoi(val)) * M_PI/180.0;
          } else if (id==210) {
                        extrusion[0] = atof(val);
                } else if (id==220) {
index 22eb057..fe0f52e 100644 (file)
@@ -609,9 +609,9 @@ void fluid_get_bb(MVert *mvert, int totvert, float obmat[][4],
 //-------------------------------------------------------------------------------
 
 void initElbeemMesh(struct Scene *scene, struct Object *ob, 
-                   int *numVertices, float **vertices, 
-      int *numTriangles, int **triangles,
-      int useGlobalCoords, int modifierIndex) 
+                       int *numVertices, float **vertices, 
+         int *numTriangles, int **triangles,
+         int useGlobalCoords, int modifierIndex) 
 {
        DerivedMesh *dm = NULL;
        MVert *mvert;
index 6c73a3a..d4a5b5b 100644 (file)
@@ -305,10 +305,10 @@ static void fcm_fn_generator_new_data (void *mdata)
  */
 static double sinc (double x)
 {
-    if (fabs(x) < 0.0001)
-        return 1.0;
-    else
-        return sin(M_PI * x) / (M_PI * x);
+       if (fabs(x) < 0.0001)
+               return 1.0;
+       else
+               return sin(M_PI * x) / (M_PI * x);
 }
 
 static void fcm_fn_generator_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
index 1ca39bb..9b8c05a 100644 (file)
@@ -160,7 +160,7 @@ According to RFC 3629 "UTF-8, a transformation format of ISO 10646"
 (http://tools.ietf.org/html/rfc3629), the valid UTF-8 encoding are:
 
   Char. number range  |        UTF-8 octet sequence
-      (hexadecimal)    |              (binary)
+         (hexadecimal)    |              (binary)
    --------------------+---------------------------------------------
    0000 0000-0000 007F | 0xxxxxxx
    0000 0080-0000 07FF | 110xxxxx 10xxxxxx
@@ -202,7 +202,7 @@ int utf8towchar(wchar_t *w, char *c)
                                *w = '?';
                        }
                } else
-                   *w=(c[0] & 0x7f);
+                       *w=(c[0] & 0x7f);
 
                c++;
                w++;
@@ -832,8 +832,8 @@ struct chartrans *BKE_text_to_curve(Scene *scene, Object *ob, int mode)
                        linedata4[lnr]= wsnr;
                        
                        if ( (tb->h != 0.0) &&
-                            ((-(yof-(tb->y/cu->fsize))) > ((tb->h/cu->fsize)-(linedist*cu->fsize))) &&
-                            (cu->totbox > (curbox+1)) ) {
+                                ((-(yof-(tb->y/cu->fsize))) > ((tb->h/cu->fsize)-(linedist*cu->fsize))) &&
+                                (cu->totbox > (curbox+1)) ) {
                                maxlen= 0;
                                tb++;
                                curbox++;
@@ -927,13 +927,13 @@ struct chartrans *BKE_text_to_curve(Scene *scene, Object *ob, int mode)
                                ct++;
                        }
                } else if((cu->spacemode==CU_FLUSH) &&
-                         (cu->tb[0].w != 0.0)) {
+                                 (cu->tb[0].w != 0.0)) {
                        for(i=0;i<lnr;i++)
                                if(linedata2[i]>1)
                                        linedata[i]= (linedata3[i]-linedata[i])/(linedata2[i]-1);
                        for (i=0; i<=slen; i++) {
                                for (j=i; (mem[j]) && (mem[j]!='\n') && 
-                                         (mem[j]!='\r') && (chartransdata[j].dobreak==0) && (j<slen); j++);
+                                                 (mem[j]!='\r') && (chartransdata[j].dobreak==0) && (j<slen); j++);
 //                             if ((mem[j]!='\r') && (mem[j]!='\n') && (mem[j])) {
                                        ct->xof+= ct->charnr*linedata[ct->linenr];
 //                             }
@@ -944,10 +944,10 @@ struct chartrans *BKE_text_to_curve(Scene *scene, Object *ob, int mode)
                        float curofs= 0.0f;
                        for (i=0; i<=slen; i++) {
                                for (j=i; (mem[j]) && (mem[j]!='\n') && 
-                                         (mem[j]!='\r') && (chartransdata[j].dobreak==0) && (j<slen); j++);
+                                                 (mem[j]!='\r') && (chartransdata[j].dobreak==0) && (j<slen); j++);
                                if ((mem[j]!='\r') && (mem[j]!='\n') &&
-                                   ((chartransdata[j].dobreak!=0))) {
-                                   if (mem[i]==' ') curofs += (linedata3[ct->linenr]-linedata[ct->linenr])/linedata4[ct->linenr];
+                                       ((chartransdata[j].dobreak!=0))) {
+                                       if (mem[i]==' ') curofs += (linedata3[ct->linenr]-linedata[ct->linenr])/linedata4[ct->linenr];
                                        ct->xof+= curofs;
                                }
                                if (mem[i]=='\n' || mem[i]=='\r' || chartransdata[i].dobreak) curofs= 0;
index 7981c66..98b3522 100644 (file)
@@ -289,12 +289,12 @@ IDProperty *IDP_CopyArray(IDProperty *prop)
 
 /*taken from readfile.c*/
 #define SWITCH_LONGINT(a) { \
-    char s_i, *p_i; \
-    p_i= (char *)&(a);  \
-    s_i=p_i[0]; p_i[0]=p_i[7]; p_i[7]=s_i; \
-    s_i=p_i[1]; p_i[1]=p_i[6]; p_i[6]=s_i; \
-    s_i=p_i[2]; p_i[2]=p_i[5]; p_i[5]=s_i; \
-    s_i=p_i[3]; p_i[3]=p_i[4]; p_i[4]=s_i; }
+       char s_i, *p_i; \
+       p_i= (char *)&(a);  \
+       s_i=p_i[0]; p_i[0]=p_i[7]; p_i[7]=s_i; \
+       s_i=p_i[1]; p_i[1]=p_i[6]; p_i[6]=s_i; \
+       s_i=p_i[2]; p_i[2]=p_i[5]; p_i[5]=s_i; \
+       s_i=p_i[3]; p_i[3]=p_i[4]; p_i[4]=s_i; }
 
 
 
index 85f1509..1a3c53e 100644 (file)
@@ -446,16 +446,16 @@ static ImBuf *add_ibuf_size(int width, int height, char *name, int floatbuf, sho
        strcpy(ibuf->name, "//Untitled");
        ibuf->userflags |= IB_BITMAPDIRTY;
        
-    switch(uvtestgrid) {
-    case 1:
-        BKE_image_buf_fill_checker(rect, rect_float, width, height);
-        break;
-    case 2:
-        BKE_image_buf_fill_checker_color(rect, rect_float, width, height);
-        break;
-    default:
-        BKE_image_buf_fill_color(rect, rect_float, width, height, color);
-    }
+       switch(uvtestgrid) {
+       case 1:
+               BKE_image_buf_fill_checker(rect, rect_float, width, height);
+               break;
+       case 2:
+               BKE_image_buf_fill_checker_color(rect, rect_float, width, height);
+               break;
+       default:
+               BKE_image_buf_fill_color(rect, rect_float, width, height, color);
+       }
 
        return ibuf;
 }
index 2c4851b..eb256e3 100644 (file)
@@ -73,8 +73,8 @@ void BKE_image_buf_fill_checker(unsigned char *rect, float *rect_float, int widt
        int checkerwidth= 32, dark= 1;
        int x, y;
     
-    unsigned char *rect_orig= rect;
-    float *rect_float_orig= rect_float;
+       unsigned char *rect_orig= rect;
+       float *rect_float_orig= rect_float;
     
        
        float h=0.0, hoffs=0.0, hue=0.0, s=0.9, v=0.9, r, g, b;
@@ -109,8 +109,8 @@ void BKE_image_buf_fill_checker(unsigned char *rect, float *rect_float, int widt
                }
        }
 
-    rect= rect_orig;
-    rect_float= rect_float_orig;
+       rect= rect_orig;
+       rect_float= rect_float_orig;
 
        /* 2nd pass, colored + */
        for(y= 0; y<height; y++) {
@@ -179,12 +179,12 @@ static void checker_board_color_fill(unsigned char *rect, float *rect_float, int
        sat= 1.0;
 
        hue_step= larger_pow2(width / 8);
-    if(hue_step < 8) hue_step= 8;
+       if(hue_step < 8) hue_step= 8;
 
        for(y= 0; y < height; y++)
        {
         
-        val= 0.1 + (y * (0.4 / height)); /* use a number lower then 1.0 else its too bright */
+               val= 0.1 + (y * (0.4 / height)); /* use a number lower then 1.0 else its too bright */
                for(x= 0; x < width; x++)
                {
                        hue= (float)((double)(x/hue_step) * 1.0 / width * hue_step);
@@ -301,55 +301,55 @@ extern void stamp_font_begin(int size);
 
 static void checker_board_text(unsigned char *rect, float *rect_float, int width, int height, int step, int outline)
 {
-    int x, y;
-    int pen_x, pen_y;
-    char text[3]= {'A', '1', '\0'};
+       int x, y;
+       int pen_x, pen_y;
+       char text[3]= {'A', '1', '\0'};
 
-    /* hard coded size! */
+       /* hard coded size! */
        stamp_font_begin(54);
-    BLF_buffer(rect_float, rect, width, height, 4);
+       BLF_buffer(rect_float, rect, width, height, 4);
     
        for(y= 0; y < height; y+=step)
        {
-        text[1]= '1';
+               text[1]= '1';
         
                for(x= 0; x < width; x+=step)
                {
-            /* hard coded offset */
-            pen_x = x + 33;
-            pen_y = y + 44;
+                       /* hard coded offset */
+                       pen_x = x + 33;
+                       pen_y = y + 44;
             
-            /* terribly crappy outline font! */
-            BLF_buffer_col(1.0, 1.0, 1.0, 1.0);
-
-            BLF_position(pen_x-outline, pen_y, 0.0);
-            BLF_draw_buffer(text);
-            BLF_position(pen_x+outline, pen_y, 0.0);
-            BLF_draw_buffer(text);
-            BLF_position(pen_x, pen_y-outline, 0.0);
-            BLF_draw_buffer(text);
-            BLF_position(pen_x, pen_y+outline, 0.0);
-            BLF_draw_buffer(text);
+                       /* terribly crappy outline font! */
+                       BLF_buffer_col(1.0, 1.0, 1.0, 1.0);
+
+                       BLF_position(pen_x-outline, pen_y, 0.0);
+                       BLF_draw_buffer(text);
+                       BLF_position(pen_x+outline, pen_y, 0.0);
+                       BLF_draw_buffer(text);
+                       BLF_position(pen_x, pen_y-outline, 0.0);
+                       BLF_draw_buffer(text);
+                       BLF_position(pen_x, pen_y+outline, 0.0);
+                       BLF_draw_buffer(text);
             
-            BLF_position(pen_x-outline, pen_y-outline, 0.0);
-            BLF_draw_buffer(text);
-            BLF_position(pen_x+outline, pen_y+outline, 0.0);
-            BLF_draw_buffer(text);
-            BLF_position(pen_x-outline, pen_y+outline, 0.0);
-            BLF_draw_buffer(text);
-            BLF_position(pen_x+outline, pen_y-outline, 0.0);
-            BLF_draw_buffer(text);
-
-            BLF_buffer_col(0.0, 0.0, 0.0, 1.0);
-            BLF_position(pen_x, pen_y, 0.0);
-            BLF_draw_buffer(text);
+                       BLF_position(pen_x-outline, pen_y-outline, 0.0);
+                       BLF_draw_buffer(text);
+                       BLF_position(pen_x+outline, pen_y+outline, 0.0);
+                       BLF_draw_buffer(text);
+                       BLF_position(pen_x-outline, pen_y+outline, 0.0);
+                       BLF_draw_buffer(text);
+                       BLF_position(pen_x+outline, pen_y-outline, 0.0);
+                       BLF_draw_buffer(text);
+
+                       BLF_buffer_col(0.0, 0.0, 0.0, 1.0);
+                       BLF_position(pen_x, pen_y, 0.0);
+                       BLF_draw_buffer(text);
             
-            text[1]++;
+                       text[1]++;
                }
-        text[0]++;
+               text[0]++;
        }
     
-    /* cleanup the buffer. */
+       /* cleanup the buffer. */
        BLF_buffer(0, 0, 0, 0, 0);
     
 }
index 2c0ca0f..cd33268 100644 (file)
@@ -1811,7 +1811,7 @@ void do_versions_ipos_to_animato(Main *main)
                        Sequence * seq;
                        
                        for(seq = scene->ed->seqbasep->first; 
-                           seq; seq = seq->next) {
+                               seq; seq = seq->next) {
                                short adrcode = SEQ_FAC1;
                                
                                if (G.f & G_DEBUG) 
index 9c78742..31b0a80 100644 (file)
@@ -178,11 +178,11 @@ Key *copy_key(Key *key)
 void make_local_key(Key *key)
 {
 
-    /* - only lib users: do nothing
-    * - only local users: set flag
-    * - mixed: make copy
-    */
-    if(key==0) return;
+       /* - only lib users: do nothing
+       * - only local users: set flag
+       * - mixed: make copy
+       */
+       if(key==0) return;
        
        key->id.lib= 0;
        new_id(0, (ID *)key, 0);
index 347fd01..b7003f4 100644 (file)
@@ -714,7 +714,7 @@ void curve_deform_verts(Scene *scene, Object *cuOb, Object *target, DerivedMesh
                
                /* find the group (weak loop-in-loop) */
                for(index = 0, curdef = target->defbase.first; curdef;
-                   curdef = curdef->next, index++)
+                       curdef = curdef->next, index++)
                        if (!strcmp(curdef->name, vgroup))
                                break;
 
@@ -746,7 +746,7 @@ void curve_deform_verts(Scene *scene, Object *cuOb, Object *target, DerivedMesh
                                                VECCOPY(vec, vertexCos[a]);
                                                calc_curve_deform(scene, cuOb, vec, defaxis, &cd, NULL);
                                                interp_v3_v3v3(vertexCos[a], vertexCos[a], vec,
-                                                        dvert->dw[j].weight);
+                                                                dvert->dw[j].weight);
                                                mul_m4_v3(cd.objectspace, vertexCos[a]);
                                                break;
                                        }
@@ -804,7 +804,7 @@ void curve_deform_vector(Scene *scene, Object *cuOb, Object *target, float *orco
 }
 
 void lattice_deform_verts(Object *laOb, Object *target, DerivedMesh *dm,
-                          float (*vertexCos)[3], int numVerts, char *vgroup)
+                                                 float (*vertexCos)[3], int numVerts, char *vgroup)
 {
        int a;
        int use_vgroups;
@@ -834,7 +834,7 @@ void lattice_deform_verts(Object *laOb, Object *target, DerivedMesh *dm,
                
                /* find the group (weak loop-in-loop) */
                for(curdef = target->defbase.first; curdef;
-                   curdef = curdef->next, index++)
+                       curdef = curdef->next, index++)
                        if(!strcmp(curdef->name, vgroup)) break;
 
                if(curdef && (me->dvert || dm)) {
@@ -865,7 +865,7 @@ int object_deform_mball(Object *ob)
 
                for (dl=ob->disp.first; dl; dl=dl->next) {
                        lattice_deform_verts(ob->parent, ob, NULL,
-                                            (float(*)[3]) dl->verts, dl->nr, NULL);
+                                                                (float(*)[3]) dl->verts, dl->nr, NULL);
                }
 
                return 1;
index 91e5374..bea641d 100644 (file)
@@ -598,10 +598,10 @@ static ID *alloc_libblock_notest(short type)
                        break;
                case ID_PA:
                        id = MEM_callocN(sizeof(ParticleSettings), "ParticleSettings");
-                       break;
+                         break;
                case ID_WM:
                        id = MEM_callocN(sizeof(wmWindowManager), "Window manager");
-                       break;
+                         break;
                case ID_GD:
                        id = MEM_callocN(sizeof(bGPdata), "Grease Pencil");
                        break;
@@ -682,7 +682,7 @@ void *copy_libblock(void *rt)
 
 static void free_library(Library *lib)
 {
-    /* no freeing needed for libraries yet */
+       /* no freeing needed for libraries yet */
 }
 
 static void (*free_windowmanager_cb)(bContext *, wmWindowManager *)= NULL;
@@ -1362,17 +1362,17 @@ void text_idbutton(struct ID *id, char *text)
        if(id) {
                if(GS(id->name)==ID_SCE)
                        strcpy(text, "SCE: ");
-        else if(GS(id->name)==ID_SCE)
+               else if(GS(id->name)==ID_SCE)
                        strcpy(text, "SCR: ");
-        else if(GS(id->name)==ID_MA && ((Material*)id)->use_nodes)
+               else if(GS(id->name)==ID_MA && ((Material*)id)->use_nodes)
                        strcpy(text, "NT: ");
-        else {
+               else {
                        text[0]= id->name[0];
                        text[1]= id->name[1];
                        text[2]= ':';
                        text[3]= ' ';
                        text[4]= 0;
-        }
+               }
        }
        else
                strcpy(text, "");
index 2a2d73c..e877abe 100644 (file)
@@ -244,9 +244,9 @@ void make_local_material(Material *ma)
        int a, local=0, lib=0;
 
        /* - only lib users: do nothing
-           * - only local users: set flag
-           * - mixed: make copy
-           */
+               * - only local users: set flag
+               * - mixed: make copy
+               */
        
        if(ma->id.lib==0) return;
        if(ma->id.us==1) {
@@ -1064,15 +1064,15 @@ void ramp_blend(int type, float *r, float *g, float *b, float fac, float *col)
                        }
                                break;
                case MA_RAMP_DARK:
-            tmp=col[0]+((1-col[0])*facm); 
-            if(tmp < *r) *r= tmp; 
-            if(g) { 
-                tmp=col[1]+((1-col[1])*facm); 
-                if(tmp < *g) *g= tmp; 
-                tmp=col[2]+((1-col[2])*facm); 
-                if(tmp < *b) *b= tmp; 
-            } 
-                break; 
+                       tmp=col[0]+((1-col[0])*facm); 
+                       if(tmp < *r) *r= tmp; 
+                       if(g) { 
+                               tmp=col[1]+((1-col[1])*facm); 
+                               if(tmp < *g) *g= tmp; 
+                               tmp=col[2]+((1-col[2])*facm); 
+                               if(tmp < *b) *b= tmp; 
+                       
+                               break; 
                case MA_RAMP_LIGHT:
                        tmp= fac*col[0];
                        if(tmp > *r) *r= tmp; 
@@ -1124,7 +1124,7 @@ void ramp_blend(int type, float *r, float *g, float *b, float fac, float *col)
                        if(tmp <= 0.0f)
                                *r = 0.0f;
                        else if (( tmp = (1.0f - (1.0f - (*r)) / tmp )) < 0.0f)
-                               *r = 0.0f;
+                                       *r = 0.0f;
                        else if (tmp > 1.0f)
                                *r=1.0f;
                        else 
@@ -1135,17 +1135,17 @@ void ramp_blend(int type, float *r, float *g, float *b, float fac, float *col)
                                if(tmp <= 0.0f)
                                        *g = 0.0f;
                                else if (( tmp = (1.0f - (1.0f - (*g)) / tmp )) < 0.0f )
-                                       *g = 0.0f;
+                                               *g = 0.0f;
                                else if(tmp >1.0f)
                                        *g=1.0f;
                                else
                                        *g = tmp;
                                        
-                               tmp = facm + fac*col[2];
-                               if(tmp <= 0.0f)
+                                       tmp = facm + fac*col[2];
+                                       if(tmp <= 0.0f)
                                        *b = 0.0f;
                                else if (( tmp = (1.0f - (1.0f - (*b)) / tmp )) < 0.0f  )
-                                       *b = 0.0f;
+                                               *b = 0.0f;
                                else if(tmp >1.0f)
                                        *b= 1.0f;
                                else
@@ -1202,36 +1202,36 @@ void ramp_blend(int type, float *r, float *g, float *b, float fac, float *col)
                                }
                        }
                                break;
-        case MA_RAMP_SOFT: 
-            if (g){ 
-                float scr, scg, scb; 
+               case MA_RAMP_SOFT: 
+                       if (g){ 
+                               float scr, scg, scb; 
                  
-                /* first calculate non-fac based Screen mix */ 
-                scr = 1.0f - (1.0f - col[0]) * (1.0f - *r); 
-                scg = 1.0f - (1.0f - col[1]) * (1.0f - *g); 
-                scb = 1.0f - (1.0f - col[2]) * (1.0f - *b); 
+                               /* first calculate non-fac based Screen mix */ 
+                               scr = 1.0f - (1.0f - col[0]) * (1.0f - *r); 
+                               scg = 1.0f - (1.0f - col[1]) * (1.0f - *g); 
+                               scb = 1.0f - (1.0f - col[2]) * (1.0f - *b); 
                  
-                *r = facm*(*r) + fac*(((1.0f - *r) * col[0] * (*r)) + (*r * scr)); 
-                *g = facm*(*g) + fac*(((1.0f - *g) * col[1] * (*g)) + (*g * scg)); 
-                *b = facm*(*b) + fac*(((1.0f - *b) * col[2] * (*b)) + (*b * scb)); 
-            } 
-                break; 
-        case MA_RAMP_LINEAR: 
-            if (col[0] > 0.5f)  
-                *r = *r + fac*(2.0f*(col[0]-0.5f)); 
-            else  
-                *r = *r + fac*(2.0f*(col[0]) - 1.0f); 
-            if (g){ 
-                if (col[1] > 0.5f)  
-                    *g = *g + fac*(2.0f*(col[1]-0.5f)); 
-                else  
-                    *g = *g + fac*(2.0f*(col[1]) -1.0f); 
-                if (col[2] > 0.5f)  
-                    *b = *b + fac*(2.0f*(col[2]-0.5f)); 
-                else  
-                    *b = *b + fac*(2.0f*(col[2]) - 1.0f); 
-            } 
-                break; 
+                               *r = facm*(*r) + fac*(((1.0f - *r) * col[0] * (*r)) + (*r * scr)); 
+                               *g = facm*(*g) + fac*(((1.0f - *g) * col[1] * (*g)) + (*g * scg)); 
+                               *b = facm*(*b) + fac*(((1.0f - *b) * col[2] * (*b)) + (*b * scb)); 
+                       
+                               break; 
+               case MA_RAMP_LINEAR: 
+                       if (col[0] > 0.5f)  
+                               *r = *r + fac*(2.0f*(col[0]-0.5f)); 
+                       else  
+                               *r = *r + fac*(2.0f*(col[0]) - 1.0f); 
+                       if (g){ 
+                               if (col[1] > 0.5f)  
+                                       *g = *g + fac*(2.0f*(col[1]-0.5f)); 
+                               else  
+                                       *g = *g + fac*(2.0f*(col[1]) -1.0f); 
+                               if (col[2] > 0.5f)  
+                                       *b = *b + fac*(2.0f*(col[2]-0.5f)); 
+                               else  
+                                       *b = *b + fac*(2.0f*(col[2]) - 1.0f); 
+                       
+                               break; 
        }       
 }
 
index d65870b..9857831 100644 (file)
@@ -686,7 +686,7 @@ void *new_pgn_element(int size)
        if(cur) {
                if(size+offs < blocksize) {
                        adr= (void *) (cur->data+offs);
-                       offs+= size;
+                        offs+= size;
                        return adr;
                }
        }
@@ -1091,7 +1091,7 @@ int getedge (EDGELIST *table[],
        q = table[HASH(i1, j1, k1)+HASH(i2, j2, k2)];
        for (; q != NULL; q = q->next)
                if (q->i1 == i1 && q->j1 == j1 && q->k1 == k1 &&
-                   q->i2 == i2 && q->j2 == j2 && q->k2 == k2)
+                       q->i2 == i2 && q->j2 == j2 && q->k2 == k2)
                        return q->vid;
        return -1;
 }
@@ -1240,7 +1240,7 @@ void converge (MB_POINT *p1, MB_POINT *p2, float v1, float v2,
                p->z = neg.z;
                return;
        }
-       if((dx == 0.0f) && (dz == 0.0f)){
+         if((dx == 0.0f) && (dz == 0.0f)){
                p->x = neg.x;
                p->y = neg.y - negative*dy/(positive-negative);
                p->z = neg.z;
@@ -1272,7 +1272,7 @@ void converge (MB_POINT *p1, MB_POINT *p2, float v1, float v2,
                        p->y = 0.5f*(pos.y + neg.y);
                        if ((function(p->x,p->y,p->z)) > 0.0)   pos.y = p->y; else neg.y = p->y;
                }
-       }
+         }
    
        if((dx == 0.0f) && (dy == 0.0f)){
                p->x = neg.x;
@@ -1580,7 +1580,7 @@ float init_meta(Scene *scene, Object *ob) /* return totsize */
                                        if(ml->s > 10.0) ml->s = 10.0;
                                        
                                        /* Rotation of MetaElem is stored in quat */
-                                       quat_to_mat4( temp3,ml->quat);
+                                        quat_to_mat4( temp3,ml->quat);
 
                                        /* Translation of MetaElem */
                                        unit_m4(temp2);
@@ -2120,8 +2120,8 @@ void metaball_polygonize(Scene *scene, Object *ob)
        /* don't polygonize metaballs with too high resolution (base mball to small) */
        if(metaball_tree) {
                if(ob->size[0]<=0.0001f*(metaball_tree->first->x_max - metaball_tree->first->x_min) ||
-                      ob->size[1]<=0.0001f*(metaball_tree->first->y_max - metaball_tree->first->y_min) ||
-                      ob->size[2]<=0.0001f*(metaball_tree->first->z_max - metaball_tree->first->z_min))
+                          ob->size[1]<=0.0001f*(metaball_tree->first->y_max - metaball_tree->first->y_min) ||
+                          ob->size[2]<=0.0001f*(metaball_tree->first->z_max - metaball_tree->first->z_min))
                {
                        MEM_freeN(mainb);
                        return;
index 15f9fc4..543895a 100644 (file)
@@ -108,7 +108,7 @@ void unlink_mesh(Mesh *me)
        }
 
        if(me->key) {
-               me->key->id.us--;
+                  me->key->id.us--;
                if (me->key->id.us == 0 && me->key->ipo )
                        me->key->ipo->id.us--;
        }
@@ -274,9 +274,9 @@ void make_local_mesh(Mesh *me)
        int local=0, lib=0;
 
        /* - only lib users: do nothing
-           * - only local users: set flag
-           * - mixed: make copy
-           */
+               * - only local users: set flag
+               * - mixed: make copy
+               */
        
        if(me->id.lib==0) return;
        if(me->id.us==1) {
index 7eb967a..ad1fb80 100644 (file)
@@ -204,7 +204,7 @@ static int curveModifier_isDisabled(ModifierData *md, int userRenderParams)
 }
 
 static void curveModifier_foreachObjectLink(
-                                           ModifierData *md, Object *ob,
+                                               ModifierData *md, Object *ob,
         void (*walk)(void *userData, Object *ob, Object **obpoin),
                void *userData)
 {
@@ -215,7 +215,7 @@ static void curveModifier_foreachObjectLink(
 
 static void curveModifier_updateDepgraph(
                                         ModifierData *md, DagForest *forest, Scene *scene,
-      Object *ob, DagNode *obNode)
+         Object *ob, DagNode *obNode)
 {
        CurveModifierData *cmd = (CurveModifierData*) md;
 
@@ -228,7 +228,7 @@ static void curveModifier_updateDepgraph(
 }
 
 static void curveModifier_deformVerts(
-                                     ModifierData *md, Object *ob, DerivedMesh *derivedData,
+                                         ModifierData *md, Object *ob, DerivedMesh *derivedData,
          float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
 {
        CurveModifierData *cmd = (CurveModifierData*) md;
@@ -239,7 +239,7 @@ static void curveModifier_deformVerts(
 
 static void curveModifier_deformVertsEM(
                                        ModifierData *md, Object *ob, EditMesh *editData,
-     DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
+        DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
 {
        DerivedMesh *dm = derivedData;
 
@@ -280,7 +280,7 @@ static int latticeModifier_isDisabled(ModifierData *md, int userRenderParams)
 }
 
 static void latticeModifier_foreachObjectLink(
-                                             ModifierData *md, Object *ob,
+                                                 ModifierData *md, Object *ob,
           void (*walk)(void *userData, Object *ob, Object **obpoin),
                  void *userData)
 {
@@ -317,7 +317,7 @@ static void modifier_vgroup_cache(ModifierData *md, float (*vertexCos)[3])
 
 static void latticeModifier_deformVerts(
                                        ModifierData *md, Object *ob, DerivedMesh *derivedData,
-     float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
+        float (*vertexCos)[3], int numVerts, int useRenderParams, int isFinalCalc)
 {
        LatticeModifierData *lmd = (LatticeModifierData*) md;
 
@@ -325,12 +325,12 @@ static void latticeModifier_deformVerts(
        modifier_vgroup_cache(md, vertexCos); /* if next modifier needs original vertices */
        
        lattice_deform_verts(lmd->object, ob, derivedData,
-                            vertexCos, numVerts, lmd->name);
+                                vertexCos, numVerts, lmd->name);
 }
 
 static void latticeModifier_deformVertsEM(
                                          ModifierData *md, Object *ob, EditMesh *editData,
-       DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
+          DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
 {
        DerivedMesh *dm = derivedData;
 
@@ -463,22 +463,22 @@ static DerivedMesh *buildModifier_applyModifier(ModifierData *md, Object *ob,
 
        maxVerts = dm->getNumVerts(dm);
        vertMap =&