style cleanup: comment blocks
authorCampbell Barton <ideasman42@gmail.com>
Fri, 9 Mar 2012 18:28:30 +0000 (18:28 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Fri, 9 Mar 2012 18:28:30 +0000 (18:28 +0000)
236 files changed:
source/blender/avi/intern/avi.c
source/blender/blenfont/BLF_api.h
source/blender/blenkernel/BKE_customdata.h
source/blender/blenkernel/BKE_sequencer.h
source/blender/blenkernel/intern/DerivedMesh.c
source/blender/blenkernel/intern/cdderivedmesh.c
source/blender/blenkernel/intern/depsgraph.c
source/blender/blenkernel/intern/displist.c
source/blender/blenkernel/intern/dynamicpaint.c
source/blender/blenkernel/intern/multires.c
source/blender/blenkernel/intern/seqeffects.c
source/blender/blenkernel/intern/sequencer.c
source/blender/blenkernel/intern/softbody.c
source/blender/blenkernel/intern/text.c
source/blender/blenlib/BLI_utildefines.h
source/blender/blenlib/CMakeLists.txt
source/blender/blenlib/intern/dynamiclist.h [deleted file]
source/blender/blenlib/intern/pbvh.c
source/blender/blenlib/intern/string_cursor_utf8.c
source/blender/blenpluginapi/iff.h
source/blender/blenpluginapi/intern/pluginapi.c
source/blender/bmesh/bmesh_class.h
source/blender/bmesh/intern/bmesh_polygon.c
source/blender/collada/collada_internal.cpp
source/blender/editors/mesh/knifetool.c
source/blender/editors/screen/screen_edit.c
source/blender/gpu/GPU_buffers.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/ikplugin/intern/iksolver_plugin.c
source/blender/ikplugin/intern/itasc_plugin.cpp
source/blender/imbuf/IMB_imbuf.h
source/blender/imbuf/IMB_imbuf_types.h
source/blender/imbuf/IMB_moviecache.h
source/blender/imbuf/intern/IMB_indexer.h
source/blender/imbuf/intern/IMB_metadata.h
source/blender/imbuf/intern/anim_movie.c
source/blender/imbuf/intern/bmp.c
source/blender/imbuf/intern/cache.c
source/blender/imbuf/intern/cineon/logmemfile.c
source/blender/imbuf/intern/dds/Image.h
source/blender/imbuf/intern/filter.c
source/blender/imbuf/intern/imageprocess.c
source/blender/imbuf/intern/jp2.c
source/blender/imbuf/intern/jpeg.c
source/blender/imbuf/intern/openexr/openexr_api.cpp
source/blender/imbuf/intern/openexr/openexr_api.h
source/blender/imbuf/intern/openexr/openexr_multi.h
source/blender/imbuf/intern/openexr/openexr_stub.cpp
source/blender/imbuf/intern/png.c
source/blender/imbuf/intern/radiance_hdr.c
source/blender/imbuf/intern/rectop.c
source/blender/imbuf/intern/scaling.c
source/blender/imbuf/intern/tiff.c
source/blender/makesdna/DNA_ID.h
source/blender/makesdna/DNA_action_types.h
source/blender/makesdna/DNA_actuator_types.h
source/blender/makesdna/DNA_armature_types.h
source/blender/makesdna/DNA_camera_types.h
source/blender/makesdna/DNA_cloth_types.h
source/blender/makesdna/DNA_curve_types.h
source/blender/makesdna/DNA_documentation.h
source/blender/makesdna/DNA_dynamicpaint_types.h
source/blender/makesdna/DNA_material_types.h
source/blender/makesdna/DNA_mesh_types.h
source/blender/makesdna/DNA_meshdata_types.h
source/blender/makesdna/DNA_meta_types.h
source/blender/makesdna/DNA_modifier_types.h
source/blender/makesdna/DNA_movieclip_types.h
source/blender/makesdna/DNA_node_types.h
source/blender/makesdna/DNA_object_force.h
source/blender/makesdna/DNA_scene_types.h
source/blender/makesdna/DNA_sdna_types.h
source/blender/makesdna/DNA_smoke_types.h
source/blender/makesdna/DNA_sound_types.h
source/blender/makesdna/DNA_space_types.h
source/blender/makesdna/DNA_userdef_types.h
source/blender/makesdna/intern/dna_genfile.c
source/blender/makesdna/intern/makesdna.c
source/blender/makesrna/RNA_define.h
source/blender/makesrna/RNA_types.h
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_ID.c
source/blender/makesrna/intern/rna_access.c
source/blender/makesrna/intern/rna_define.c
source/blender/makesrna/intern/rna_dynamicpaint.c
source/blender/makesrna/intern/rna_gpencil.c
source/blender/makesrna/intern/rna_key.c
source/blender/makesrna/intern/rna_object_api.c
source/blender/makesrna/intern/rna_sculpt_paint.c
source/blender/makesrna/intern/rna_space.c
source/blender/makesrna/intern/rna_wm.c
source/blender/modifiers/intern/MOD_array.c
source/blender/modifiers/intern/MOD_bevel.c
source/blender/modifiers/intern/MOD_boolean.c
source/blender/modifiers/intern/MOD_boolean_util.c
source/blender/modifiers/intern/MOD_boolean_util.h
source/blender/modifiers/intern/MOD_build.c
source/blender/modifiers/intern/MOD_cast.c
source/blender/modifiers/intern/MOD_edgesplit.c
source/blender/modifiers/intern/MOD_fluidsim_util.c
source/blender/modifiers/intern/MOD_multires.c
source/blender/modifiers/intern/MOD_particlesystem.c
source/blender/modifiers/intern/MOD_remesh.c
source/blender/modifiers/intern/MOD_screw.c
source/blender/modifiers/intern/MOD_simpledeform.c
source/blender/modifiers/intern/MOD_smooth.c
source/blender/modifiers/intern/MOD_solidify.c
source/blender/modifiers/intern/MOD_util.c
source/blender/modifiers/intern/MOD_uvproject.c
source/blender/nodes/shader/node_shader_tree.c
source/blender/nodes/shader/nodes/node_shader_dynamic.c
source/blender/nodes/shader/nodes/node_shader_output.c
source/blender/python/generic/py_capi_utils.c
source/blender/python/intern/gpu.c
source/blender/python/mathutils/mathutils.c
source/blender/python/mathutils/mathutils_Vector.c
source/blender/render/extern/include/RE_pipeline.h
source/blender/render/intern/include/pixelblending.h
source/blender/render/intern/include/pixelshading.h
source/blender/render/intern/include/rayintersection.h
source/blender/render/intern/include/render_types.h
source/blender/render/intern/raytrace/bvh.h
source/blender/render/intern/raytrace/rayobject.cpp
source/blender/render/intern/raytrace/rayobject_hint.h
source/blender/render/intern/raytrace/rayobject_internal.h
source/blender/render/intern/raytrace/rayobject_octree.cpp
source/blender/render/intern/raytrace/rayobject_rtbuild.cpp
source/blender/render/intern/raytrace/vbvh.h
source/blender/render/intern/source/convertblender.c
source/blender/render/intern/source/envmap.c
source/blender/render/intern/source/imagetexture.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/rayshade.c
source/blender/render/intern/source/render_result.c
source/blender/render/intern/source/render_texture.c
source/blender/render/intern/source/rendercore.c
source/blender/render/intern/source/renderdatabase.c
source/blender/render/intern/source/shadbuf.c
source/blender/render/intern/source/shadeinput.c
source/blender/render/intern/source/shadeoutput.c
source/blender/render/intern/source/sss.c
source/blender/render/intern/source/strand.c
source/blender/render/intern/source/volumetric.c
source/blender/render/intern/source/zbuf.c
source/blender/windowmanager/WM_types.h
source/blender/windowmanager/intern/wm.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_event_system.c
source/blender/windowmanager/intern/wm_files.c
source/blender/windowmanager/intern/wm_init_exit.c
source/blender/windowmanager/intern/wm_jobs.c
source/blender/windowmanager/intern/wm_keymap.c
source/blender/windowmanager/intern/wm_operators.c
source/blender/windowmanager/intern/wm_subwindow.c
source/blender/windowmanager/intern/wm_window.c
source/blender/windowmanager/wm_event_types.h
source/creator/creator.c
source/gameengine/Converter/BL_ActionActuator.cpp
source/gameengine/Converter/BL_ArmatureChannel.h
source/gameengine/Converter/BL_BlenderDataConversion.cpp
source/gameengine/Converter/KX_ConvertActuators.cpp
source/gameengine/Converter/KX_ConvertSensors.cpp
source/gameengine/Expressions/BoolValue.cpp
source/gameengine/Expressions/BoolValue.h
source/gameengine/Expressions/EmptyValue.h
source/gameengine/Expressions/ErrorValue.h
source/gameengine/Expressions/Expression.h
source/gameengine/Expressions/FloatValue.h
source/gameengine/Expressions/IfExpr.cpp
source/gameengine/Expressions/InputParser.cpp
source/gameengine/Expressions/IntValue.cpp
source/gameengine/Expressions/IntValue.h
source/gameengine/Expressions/ListValue.h
source/gameengine/Expressions/Operator2Expr.h
source/gameengine/Expressions/PyObjectPlus.h
source/gameengine/Expressions/StringValue.cpp
source/gameengine/Expressions/Value.h
source/gameengine/Expressions/VectorValue.cpp
source/gameengine/Expressions/VectorValue.h
source/gameengine/GameLogic/Joystick/SCA_Joystick.h
source/gameengine/GamePlayer/common/GPC_Canvas.cpp
source/gameengine/Ketsji/BL_Material.h
source/gameengine/Ketsji/KX_BulletPhysicsController.cpp
source/gameengine/Ketsji/KX_Camera.cpp
source/gameengine/Ketsji/KX_Camera.h
source/gameengine/Ketsji/KX_CameraActuator.cpp
source/gameengine/Ketsji/KX_ConstraintActuator.cpp
source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
source/gameengine/Ketsji/KX_Dome.cpp
source/gameengine/Ketsji/KX_Dome.h
source/gameengine/Ketsji/KX_FontObject.cpp
source/gameengine/Ketsji/KX_FontObject.h
source/gameengine/Ketsji/KX_GameObject.cpp
source/gameengine/Ketsji/KX_IPhysicsController.h
source/gameengine/Ketsji/KX_ISceneConverter.h
source/gameengine/Ketsji/KX_IpoActuator.h
source/gameengine/Ketsji/KX_KetsjiEngine.cpp
source/gameengine/Ketsji/KX_MouseFocusSensor.cpp
source/gameengine/Ketsji/KX_MouseFocusSensor.h
source/gameengine/Ketsji/KX_NearSensor.h
source/gameengine/Ketsji/KX_PythonInit.cpp
source/gameengine/Ketsji/KX_PythonInitTypes.cpp
source/gameengine/Ketsji/KX_RadarSensor.h
source/gameengine/Ketsji/KX_RaySensor.cpp
source/gameengine/Ketsji/KX_Scene.cpp
source/gameengine/Ketsji/KX_Scene.h
source/gameengine/Rasterizer/RAS_2DFilterManager.cpp
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.cpp
source/gameengine/VideoTexture/BlendType.h
source/gameengine/VideoTexture/Common.h
source/gameengine/VideoTexture/Exception.h
source/gameengine/VideoTexture/FilterBase.h
source/gameengine/VideoTexture/FilterBlueScreen.h
source/gameengine/VideoTexture/FilterColor.h
source/gameengine/VideoTexture/FilterNormal.h
source/gameengine/VideoTexture/FilterSource.h
source/gameengine/VideoTexture/ImageBase.h
source/gameengine/VideoTexture/ImageBuff.h
source/gameengine/VideoTexture/ImageMix.h
source/gameengine/VideoTexture/ImageRender.h
source/gameengine/VideoTexture/ImageViewport.h
source/gameengine/VideoTexture/PyTypeList.h
source/gameengine/VideoTexture/Texture.h
source/gameengine/VideoTexture/VideoBase.h
source/gameengine/VideoTexture/VideoFFmpeg.h

index 1da93d5ed50ae4542bde350df3f3fc8f68e0a073..cc4d6b41f9807653d9ba28c5d630ec27cecdf26d 100644 (file)
@@ -197,13 +197,12 @@ AviError AVI_print_error (AviError in_error)
 
        return in_error;
 }
-/*
+#if 0
 void AVI_set_debug (int mode)
 {
        AVI_DEBUG= mode;
 }
-*/
-/*
+
 int AVI_is_avi (char *name)
 {
        FILE *fp;
@@ -224,7 +223,7 @@ int AVI_is_avi (char *name)
        fclose(fp);
        return ret;
 }
-*/
+#endif
 
 int AVI_is_avi (const char *name)
 {
@@ -659,7 +658,7 @@ void *AVI_read_frame (AviMovie *movie, AviFormat format, int frame, int stream)
        void *buffer;
 
        /* Retrieve the record number of the desired frame in the index 
-               If a chunk has Size 0 we need to rewind to previous frame */
+        * If a chunk has Size 0 we need to rewind to previous frame */
        while(rewind && frame > -1) {
                i=0;
                cur_frame=-1;
@@ -798,13 +797,13 @@ AviError AVI_open_compress (char *name, AviMovie *movie, int streams, ...)
                movie->streams[i].sh.bottom = 0;
 
                if (movie->streams[i].sh.Type == FCC("vids")) { 
-/*
+#if 0
                        if (movie->streams[i].format == AVI_FORMAT_MJPEG) {
                                movie->streams[i].sf = MEM_mallocN (sizeof(AviBitmapInfoHeader) 
                                                                                + sizeof(AviMJPEGUnknown),"moviestreamformatL");
                                movie->streams[i].sf_size = sizeof(AviBitmapInfoHeader) + sizeof(AviMJPEGUnknown);
                        } else {
-*/
+#endif
                        movie->streams[i].sf = MEM_mallocN (sizeof(AviBitmapInfoHeader),  "moviestreamformatS");
                        movie->streams[i].sf_size = sizeof(AviBitmapInfoHeader);
 
index d7b441e70e1e4c205051a3a1e160f67982d10f2d..1e242deece408a28a33c03633146d8d7ea9803d0 100644 (file)
@@ -59,12 +59,12 @@ void BLF_size(int fontid, int size, int dpi);
  * to enable this.
  *
  * The order of the matrix is like GL:
-
      | m[0]  m[4]  m[8]  m[12] |
      | m[1]  m[5]  m[9]  m[13] |
      | m[2]  m[6]  m[10] m[14] |
      | m[3]  m[7]  m[11] m[15] |
-
+ *
*  | m[0]  m[4]  m[8]  m[12] |
*  | m[1]  m[5]  m[9]  m[13] |
*  | m[2]  m[6]  m[10] m[14] |
*  | m[3]  m[7]  m[11] m[15] |
+ *
  */
 void BLF_matrix(int fontid, const double m[16]);
 
index ee5e4f20af14f1dc871c3de0b33a34628427dfcd..27b27ce5b42b7f114e81b17fd94c0bf773cefeca 100644 (file)
@@ -69,7 +69,7 @@ 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 */
 
 #define CD_TYPE_AS_MASK(_type) (CustomDataMask)((CustomDataMask)1 << (CustomDataMask)(_type))
 
index ab7e0e72191f05824a96f3ce4c88ffcc02a67435..4b3a15181c10013fcafc06c802c2c2427fb5a887 100644 (file)
@@ -118,11 +118,11 @@ struct SeqEffectHandle {
        void (*init_plugin)(struct Sequence *seq, const char *fname);
        
        /* number of input strips needed 
-               (called directly after construction) */
+        * (called directly after construction) */
        int (*num_inputs)(void);
        
        /* load is called first time after readblenfile in
-               get_sequence_effect automatically */
+        * get_sequence_effect automatically */
        void (*load)(struct Sequence *seq);
        
        /* duplicate */
@@ -132,9 +132,9 @@ struct SeqEffectHandle {
        void (*free)(struct Sequence *seq);
        
        /* returns: -1: no input needed,
-       0: no early out, 
-       1: out = ibuf1, 
-       2: out = ibuf2 */
+        * 0: no early out,
+        * 1: out = ibuf1,
+        * 2: out = ibuf2 */
        int (*early_out)(struct Sequence *seq, float facf0, float facf1); 
        
        /* stores the y-range of the effect IPO */
@@ -146,9 +146,9 @@ struct SeqEffectHandle {
                                 float * facf0, float * facf1);
        
        /* execute the effect
-           sequence effects are only required to either support
-           float-rects or byte-rects 
-           (mixed cases are handled one layer up...) */
+        * sequence effects are only required to either support
+        * float-rects or byte-rects
+        * (mixed cases are handled one layer up...) */
        
        struct ImBuf* (*execute)(
                SeqRenderData context,
@@ -161,10 +161,10 @@ struct SeqEffectHandle {
 /* ********************* prototypes *************** */
 
 /* **********************************************************************
  * sequence.c
-
  * sequencer render functions
  ********************************************************************** */
+ * sequence.c
+ *
+ * sequencer render functions
* ********************************************************************** */
 
 struct ImBuf *give_ibuf_seq(SeqRenderData context, float cfra, int chanshown);
 struct ImBuf *give_ibuf_seq_threaded(SeqRenderData context, float cfra, int chanshown);
@@ -209,10 +209,10 @@ void seq_proxy_rebuild_finish(struct SeqIndexBuildContext *context, short stop);
 
 
 /* **********************************************************************
  seqcache.c
-
  Sequencer memory cache management functions
  ********************************************************************** */
* seqcache.c
+ *
* Sequencer memory cache management functions
* ********************************************************************** */
 
 typedef enum {
        SEQ_STRIPELEM_IBUF,
@@ -230,20 +230,20 @@ struct ImBuf * seq_stripelem_cache_get(
        float cfra, seq_stripelem_ibuf_t type);
 
 /* passed ImBuf is properly refed, so ownership is *not* 
  transfered to the cache.
  you can pass the same ImBuf multiple times to the cache without problems.
-*/
* transfered to the cache.
* you can pass the same ImBuf multiple times to the cache without problems.
+ */
    
 void seq_stripelem_cache_put(
        SeqRenderData context, struct Sequence * seq, 
        float cfra, seq_stripelem_ibuf_t type, struct ImBuf * nval);
 
 /* **********************************************************************
-   seqeffects.c 
-
  Sequencer effect strip managment functions
-   **********************************************************************
-*/
+ * seqeffects.c
+ *
* Sequencer effect strip managment functions
*  **********************************************************************
+ */
 
 /* intern */
 struct SeqEffectHandle get_sequence_blend(struct Sequence *seq);
@@ -255,9 +255,9 @@ int get_sequence_effect_num_inputs(int seq_type);
 
 
 /* **********************************************************************
  Sequencer editing functions
  **********************************************************************
-*/
* Sequencer editing functions
* **********************************************************************
+ */
    
 /* for transform but also could use elsewhere */
 int seq_tx_get_start(struct Sequence *seq);
index 5bd5c09be28674b0448552fe9e7c9ef7fda09339..4c683b2b2c8a069c33b83d158c7432aed97bc5e7 100644 (file)
@@ -421,7 +421,7 @@ void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob)
        }
        
        /* not all DerivedMeshes store their verts/edges/faces in CustomData, so
-          we set them here in case they are missing */
+        * we set them here in case they are missing */
        if(!CustomData_has_layer(&tmp.vdata, CD_MVERT))
                CustomData_add_layer(&tmp.vdata, CD_MVERT, CD_ASSIGN, dm->dupVertArray(dm), totvert);
        if(!CustomData_has_layer(&tmp.edata, CD_MEDGE))
@@ -454,9 +454,9 @@ void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob)
        CustomData_free(&me->ldata, me->totloop);
        CustomData_free(&me->pdata, me->totpoly);
 
-       /*  ok, this should now use new CD shapekey data,
-           which shouuld be fed through the modifier 
-               stack*/
+       /* ok, this should now use new CD shapekey data,
+        * which shouuld be fed through the modifier
+        * stack*/
        if(tmp.totvert != me->totvert && !did_shapekeys && me->key) {
                printf("YEEK! this should be recoded! Shape key loss!!!\n");
                if(tmp.key) tmp.key->id.us--;
@@ -787,7 +787,7 @@ static void *get_orco_coords_dm(Object *ob, BMEditMesh *em, int layer, int *free
        }
        else if(layer == CD_CLOTH_ORCO) {
                /* apply shape key for cloth, this should really be solved
-                  by a more flexible customdata system, but not simple */
+                * by a more flexible customdata system, but not simple */
                if(!em) {
                        ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
                        KeyBlock *kb= key_get_keyblock(ob_get_key(ob), clmd->sim_parms->shapekey_rest);
@@ -2636,8 +2636,9 @@ void DM_vertex_attributes_from_gpu(DerivedMesh *dm, GPUVertexAttribs *gattribs,
                                attribs->tface[a].glIndex = gattribs->layer[b].glindex;
                                attribs->tface[a].glTexco = gattribs->layer[b].gltexco;
                        }
-                       /* BMESH ONLY, may need to get this working?, otherwise remove */
-                       /* else {
+                       /* BMESH_TODO - BMESH ONLY, may need to get this working?, otherwise remove */
+#if 0
+                       else {
                                int player;
                                CustomData *pdata = dm->getPolyDataLayout(dm);
                                
@@ -2657,7 +2658,7 @@ void DM_vertex_attributes_from_gpu(DerivedMesh *dm, GPUVertexAttribs *gattribs,
                                        
                                }
                        }
-                       */
+#endif
                }
                else if(gattribs->layer[b].type == CD_MCOL) {
                        /* vertex colors */
@@ -2756,13 +2757,14 @@ static void navmesh_drawColored(DerivedMesh *dm)
        if (!polygonIdx)
                return;
 
-       /*
+#if 0
        //UI_ThemeColor(TH_WIRE);
        glDisable(GL_LIGHTING);
        glLineWidth(2.0);
        dm->drawEdges(dm, 0, 1);
        glLineWidth(1.0);
-       glEnable(GL_LIGHTING);*/
+       glEnable(GL_LIGHTING);
+#endif
 
        glDisable(GL_LIGHTING);
        /*  if(GPU_buffer_legacy(dm) ) */ { /* TODO - VBO draw code, not high priority - campbell */
index 7ba9e6b9686f676034d5ece893beea8abf7c6f84..cf435e96332303bdaa480465829150dd9fad368d 100644 (file)
@@ -79,7 +79,7 @@ typedef struct {
        DerivedMesh dm;
 
        /* these point to data in the DerivedMesh custom data layers,
-          they are only here for efficiency and convenience **/
+        * they are only here for efficiency and convenience **/
        MVert *mvert;
        MEdge *medge;
        MFace *mface;
@@ -237,13 +237,13 @@ static int can_pbvh_draw(Object *ob, DerivedMesh *dm)
        int deformed= 0;
 
        /* active modifiers means extra deformation, which can't be handled correct
-          on bith of PBVH and sculpt "layer" levels, so use PBVH only for internal brush
-          stuff and show final DerivedMesh so user would see actual object shape */
+        * on bith of PBVH and sculpt "layer" levels, so use PBVH only for internal brush
+        * stuff and show final DerivedMesh so user would see actual object shape */
        deformed|= ob->sculpt->modifiers_active;
 
        /* as in case with modifiers, we can't synchronize deformation made against
-          PBVH and non-locked keyblock, so also use PBVH only for brushes and
-          final DM to give final result to user */
+        * PBVH and non-locked keyblock, so also use PBVH only for brushes and
+        * final DM to give final result to user */
        deformed|= ob->sculpt->kb && (ob->shapeflag&OB_SHAPE_LOCK) == 0;
 
        if(deformed)
@@ -269,8 +269,8 @@ static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
        }
 
        /* always build pbvh from original mesh, and only use it for drawing if
-          this derivedmesh is just original mesh. it's the multires subsurf dm
-          that this is actually for, to support a pbvh on a modified mesh */
+        * this derivedmesh is just original mesh. it's the multires subsurf dm
+        * that this is actually for, to support a pbvh on a modified mesh */
        if(!cddm->pbvh && ob->type == OB_MESH) {
                SculptSession *ss= ob->sculpt;
                Mesh *me= ob->data;
@@ -297,7 +297,7 @@ static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
 }
 
 /* update vertex normals so that drawing smooth faces works during sculpt
  TODO: proper fix is to support the pbvh in all drawing modes */
* TODO: proper fix is to support the pbvh in all drawing modes */
 static void cdDM_update_normals_from_pbvh(DerivedMesh *dm)
 {
        CDDerivedMesh *cddm = (CDDerivedMesh*) dm;
@@ -760,7 +760,7 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm,
 
                                if(!flush && compareDrawOptions) {
                                        /* also compare draw options and flush buffer if they're different
-                                          need for face selection highlight in edit mode */
+                                        * need for face selection highlight in edit mode */
                                        flush|= compareDrawOptions(userData, actualFace, next_actualFace) == 0;
                                }
 
@@ -840,7 +840,7 @@ static void cdDM_drawMappedFaces(DerivedMesh *dm,
                                        cp = (unsigned char *)&mc[i * 4];
 
                                /* no need to set shading mode to flat because
-                               *  normals are already used to change shading */
+                                *  normals are already used to change shading */
                                glShadeModel(GL_SMOOTH);
                                glBegin(mf->v4?GL_QUADS:GL_TRIANGLES);
 
@@ -931,8 +931,8 @@ static void cdDM_drawMappedFaces(DerivedMesh *dm,
                                                draw_option= setDrawOptions(userData, orig);
        
                                        /* Goal is to draw as long of a contiguous triangle
-                                          array as possible, so draw when we hit either an
-                                          invisible triangle or at the end of the array */
+                                        * array as possible, so draw when we hit either an
+                                        * invisible triangle or at the end of the array */
 
                                        /* flush buffer if current triangle isn't drawable or it's last triangle... */
                                        flush= (draw_option == DM_DRAW_OPTION_SKIP) || (i == tottri - 1);
@@ -1517,7 +1517,7 @@ void CDDM_recalc_tessellation_ex(DerivedMesh *dm, const int do_face_nor_cpy)
        cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
 
        /* Tessellation recreated faceData, and the active layer indices need to get re-propagated
-          from loops and polys to faces */
+        * from loops and polys to faces */
        CustomData_bmesh_update_active_layers(&dm->faceData, &dm->polyData, &dm->loopData);
 }
 
@@ -1826,8 +1826,8 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
 
        mask = use_mdisps ? CD_MASK_DERIVEDMESH|CD_MASK_MDISPS : CD_MASK_DERIVEDMESH;
        
-       /*don't process shapekeys, we only feed them through the modifier stack as needed,
-         e.g. for applying modifiers or the like*/
+       /* don't process shapekeys, we only feed them through the modifier stack as needed,
+        * e.g. for applying modifiers or the like*/
        mask &= ~CD_MASK_SHAPEKEY;
        CustomData_merge(&bm->vdata, &dm->vertData, mask,
                         CD_CALLOC, dm->numVertData);
@@ -1992,7 +1992,7 @@ static DerivedMesh *cddm_copy_ex(DerivedMesh *source, int faces_from_tessfaces)
        /* any callers that need tessface data can calculate it - campbell */
 #if 0
        /* BMESH_TODO: Find out why this is necessary (or else find a way to remove
-          it). If it is necessary, add a comment explaining why. */
+        * it). If it is necessary, add a comment explaining why. */
        CDDM_recalc_tessellation((DerivedMesh *)cddm);
 #endif
 
index 72890908457f3805f7266a1ce9411d5a425b8909..c178a4ef6ea4cfbf674d3261773b952800dcd3f8 100644 (file)
@@ -595,8 +595,8 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O
                        if(part->ren_as == PART_DRAW_OB && part->dup_ob) {
                                node2 = dag_get_node(dag, part->dup_ob);
                                /* note that this relation actually runs in the wrong direction, the problem
-                                  is that dupli system all have this (due to parenting), and the render
-                                  engine instancing assumes particular ordering of objects in list */
+                                * is that dupli system all have this (due to parenting), and the render
+                                * engine instancing assumes particular ordering of objects in list */
                                dag_add_relation(dag, node, node2, DAG_RL_OB_OB, "Particle Object Visualisation");
                                if(part->dup_ob->type == OB_MBALL)
                                        dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA, "Particle Object Visualisation");
@@ -756,8 +756,8 @@ struct DagForest *build_dag(Main *bmain, Scene *sce, short mask)
        }
        
        /* Now all relations were built, but we need to solve 1 exceptional case;
-          When objects have multiple "parents" (for example parent + constraint working on same object)
-          the relation type has to be synced. One of the parents can change, and should give same event to child */
+        * When objects have multiple "parents" (for example parent + constraint working on same object)
+        * the relation type has to be synced. One of the parents can change, and should give same event to child */
        
        /* nodes were callocced, so we can use node->color for temporal storage */
        for(node = sce->theDag->DagNode.first; node; node= node->next) {
@@ -1159,9 +1159,8 @@ void graph_bfs(void)
                        }
                        set_node_xy(node, node->BFS_dist*DEPSX*2, pos[node->BFS_dist]*DEPSY*2);
                        node->color = DAG_BLACK;
-                       /*
-                       fprintf(stderr,"BFS node : %20s %i %5.0f %5.0f\n",((ID *) node->ob)->name,node->BFS_dist, node->x, node->y);
-                       */
+
+                       // fprintf(stderr,"BFS node : %20s %i %5.0f %5.0f\n",((ID *) node->ob)->name,node->BFS_dist, node->x, node->y);
                }
        }
        queue_delete(nqueue);
@@ -1185,8 +1184,8 @@ int pre_and_post_source_BFS(DagForest *dag, short mask, DagNode *source, graph_a
        /* fprintf(stderr,"starting BFS \n ------------\n"); */ 
        
        /* Init
-               * dagnode.first is always the root (scene)
-               */
+        * dagnode.first is always the root (scene)
+        */
        node = dag->DagNode.first;
        nqueue = queue_create(DAGQUEUEALLOC);
        while(node) {
@@ -1220,9 +1219,8 @@ int pre_and_post_source_BFS(DagForest *dag, short mask, DagNode *source, graph_a
                        }
                        post_func(node->ob,data);
                        node->color = DAG_BLACK;
-                       /*
-                       fprintf(stderr,"BFS node : %20s %i %5.0f %5.0f\n",((ID *) node->ob)->name,node->BFS_dist, node->x, node->y);
-                       */
+
+                       // fprintf(stderr,"BFS node : %20s %i %5.0f %5.0f\n",((ID *) node->ob)->name,node->BFS_dist, node->x, node->y);
                }
        }
        queue_delete(nqueue);
@@ -1303,7 +1301,7 @@ DagNodeQueue * graph_dfs(void)
                                                ;
                                                /* already processed node but we may want later to change distance either to shorter to longer.
                                                 * DFS_dist is the first encounter  
-                                               */
+                                                */
                                                /*if (node->DFS_dist >= itA->node->DFS_dist)
                                                        itA->node->DFS_dist = node->DFS_dist + 1;
 
@@ -1337,9 +1335,8 @@ DagNodeQueue * graph_dfs(void)
                                }
                                set_node_xy(node, node->DFS_dist*DEPSX*2, pos[node->DFS_dist]*DEPSY*2);
                                
-                               /*
-                               fprintf(stderr,"DFS node : %20s %i %i %i %i\n",((ID *) node->ob)->name,node->BFS_dist, node->DFS_dist, node->DFS_dvtm, node->DFS_fntm );
-                               */
+                               // fprintf(stderr,"DFS node : %20s %i %i %i %i\n",((ID *) node->ob)->name,node->BFS_dist, node->DFS_dist, node->DFS_dvtm, node->DFS_fntm );
+
                                push_stack(retqueue,node);
                                
                        }
@@ -1376,8 +1373,8 @@ int pre_and_post_source_DFS(DagForest *dag, short mask, DagNode *source, graph_a
        nqueue = queue_create(DAGQUEUEALLOC);
        
        /* Init
-               * dagnode.first is always the root (scene)
-               */
+        * dagnode.first is always the root (scene)
+        */
        node = dag->DagNode.first;
        while(node) {
                node->color = DAG_WHITE;
@@ -1652,7 +1649,7 @@ void graph_print_adj_list(void)
 /* ************************ API *********************** */
 
 /* mechanism to allow editors to be informed of depsgraph updates,
  to do their own updates based on changes... */
* to do their own updates based on changes... */
 static void (*EditorsUpdateIDCb)(Main *bmain, ID *id)= NULL;
 static void (*EditorsUpdateSceneCb)(Main *bmain, Scene *scene, int updated)= NULL;
 
@@ -2363,7 +2360,7 @@ static void dag_current_scene_layers(Main *bmain, Scene **sce, unsigned int *lay
        wmWindow *win;
 
        /* only one scene supported currently, making more scenes work
-          correctly requires changes beyond just the dependency graph */
+        * correctly requires changes beyond just the dependency graph */
 
        *sce= NULL;
        *lay= 0;
@@ -2383,8 +2380,8 @@ static void dag_current_scene_layers(Main *bmain, Scene **sce, unsigned int *lay
                if(*sce) *lay= (*sce)->lay;
 
                /* XXX for background mode, we should get the scene
-                  from somewhere, for the -S option, but it's in
-                  the context, how to get it here? */
+                * from somewhere, for the -S option, but it's in
+                * the context, how to get it here? */
        }
 }
 
@@ -2414,9 +2411,9 @@ void DAG_on_visible_update(Main *bmain, const short do_time)
        if(scene && scene->theDag) {
                Scene *sce_iter;
                /* derivedmeshes and displists are not saved to file so need to be
-                  remade, tag them so they get remade in the scene update loop,
-                  note armature poses or object matrices are preserved and do not
-                  require updates, so we skip those */
+                * remade, tag them so they get remade in the scene update loop,
+                * note armature poses or object matrices are preserved and do not
+                * require updates, so we skip those */
                dag_scene_flush_layers(scene, lay);
 
                for(SETLOOPER(scene, sce_iter, base)) {
@@ -2471,7 +2468,7 @@ static void dag_id_flush_update(Scene *sce, ID *id)
        short idtype;
 
        /* here we flush a few things before actual scene wide flush, mostly
-          due to only objects and not other datablocks being in the depsgraph */
+        * due to only objects and not other datablocks being in the depsgraph */
 
        /* set flags & pointcache for object */
        if(GS(id->name) == ID_OB) {
@@ -2591,8 +2588,8 @@ static void dag_id_flush_update(Scene *sce, ID *id)
                }
 
                /* camera's matrix is used to orient reconstructed stuff,
-                  so it should happen tracking-related constraints recalculation
-                  when camera is changing (sergey) */
+                * so it should happen tracking-related constraints recalculation
+                * when camera is changing (sergey) */
                if(sce->camera && &sce->camera->id == id) {
                        MovieClip *clip = object_get_movieclip(sce, sce->camera, 1);
 
@@ -2625,7 +2622,7 @@ void DAG_ids_flush_tagged(Main *bmain)
                ID *id = lb->first;
 
                /* we tag based on first ID type character to avoid 
-                  looping over all ID's in case there are no tags */
+                * looping over all ID's in case there are no tags */
                if(id && bmain->id_tag_update[id->name[0]]) {
                        for(; id; id=id->next) {
                                if(id->flag & (LIB_ID_RECALC|LIB_ID_RECALC_DATA)) {
@@ -2654,7 +2651,7 @@ void DAG_ids_check_recalc(Main *bmain, Scene *scene, int time)
                ID *id = lb->first;
 
                /* we tag based on first ID type character to avoid 
-                  looping over all ID's in case there are no tags */
+                * looping over all ID's in case there are no tags */
                if(id && bmain->id_tag_update[id->name[0]]) {
                        updated= 1;
                        break;
@@ -2677,7 +2674,7 @@ void DAG_ids_clear_recalc(Main *bmain)
                ID *id = lb->first;
 
                /* we tag based on first ID type character to avoid 
-                  looping over all ID's in case there are no tags */
+                * looping over all ID's in case there are no tags */
                if(id && bmain->id_tag_update[id->name[0]]) {
                        for(; id; id=id->next)
                                if(id->flag & (LIB_ID_RECALC|LIB_ID_RECALC_DATA))
index 6383f7b904013f9d9c29691f60013b9dade754fc..d10c060cc7f744841abac10fda4f649adc7ce3b9 100644 (file)
@@ -613,10 +613,10 @@ static void curve_to_filledpoly(Curve *cu, ListBase *UNUSED(nurb), ListBase *dis
 }
 
 /* taper rules:
-  - only 1 curve
-  - first point left, last point right
-  - based on subdivided points in original curve, not on points in taper curve (still)
-*/
* - only 1 curve
* - first point left, last point right
* - based on subdivided points in original curve, not on points in taper curve (still)
+ */
 float calc_taper(Scene *scene, Object *taperobj, int cur, int tot)
 {
        DispList *dl;
@@ -710,8 +710,8 @@ static ModifierData *curve_get_tesselate_point(Scene *scene, Object *ob, int for
                        preTesselatePoint = md;
 
                        /* this modifiers are moving point of tessellation automatically
-                          (some of them even can't be applied on tesselated curve), set flag
-                          for incformation button in modifier's header */
+                        * (some of them even can't be applied on tesselated curve), set flag
+                        * for incformation button in modifier's header */
                        md->mode |= eModifierMode_ApplyOnSpline;
                } else if(md->mode&eModifierMode_ApplyOnSpline) {
                        preTesselatePoint = md;
@@ -746,9 +746,9 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, int forRender, fl
 
                if(keyVerts) {
                        /* split coords from key data, the latter also includes
-                          tilts, which is passed through in the modifier stack.
-                          this is also the reason curves do not use a virtual
-                          shape key modifier yet. */
+                        * tilts, which is passed through in the modifier stack.
+                        * this is also the reason curves do not use a virtual
+                        * shape key modifier yet. */
                        deformedVerts= curve_getKeyVertexCos(cu, nurb, keyVerts);
                        originalVerts= MEM_dupallocN(deformedVerts);
                }
@@ -1168,8 +1168,8 @@ void makeDispListSurf(Scene *scene, Object *ob, ListBase *dispbase,
        }
 
        /* make copy of 'undeformed" displist for texture space calculation
-          actually, it's not totally undeformed -- pre-tessellation modifiers are
-          already applied, thats how it worked for years, so keep for compatibility (sergey) */
+        * actually, it's not totally undeformed -- pre-tessellation modifiers are
+        * already applied, thats how it worked for years, so keep for compatibility (sergey) */
        copy_displist(&cu->disp, dispbase);
 
        if (!forRender) {
@@ -1394,8 +1394,8 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
                if(cu->flag & CU_PATH) calc_curvepath(ob);
 
                /* make copy of 'undeformed" displist for texture space calculation
-                  actually, it's not totally undeformed -- pre-tessellation modifiers are
-                  already applied, thats how it worked for years, so keep for compatibility (sergey) */
+                * actually, it's not totally undeformed -- pre-tessellation modifiers are
+                * already applied, thats how it worked for years, so keep for compatibility (sergey) */
                copy_displist(&cu->disp, dispbase);
 
                if (!forRender) {
@@ -1416,8 +1416,8 @@ void makeDispListCurveTypes(Scene *scene, Object *ob, int forOrco)
        ListBase *dispbase;
 
        /* The same check for duplis as in do_makeDispListCurveTypes.
-          Happens when curve used for constraint/bevel was converted to mesh.
-          check there is still needed for render displist and orco displists. */
+        * Happens when curve used for constraint/bevel was converted to mesh.
+        * check there is still needed for render displist and orco displists. */
        if(!ELEM3(ob->type, OB_SURF, OB_CURVE, OB_FONT)) return;
 
        freedisplist(&(ob->disp));
index 5280215d15c16eb3d28816424bdb735ac81d1632..2c7814a6a4340f600310982f519e9bed2b7dd904 100644 (file)
@@ -156,7 +156,7 @@ typedef struct PaintBakeData {
        int *s_pos;     /* index to start reading point sample realCoord */
        int *s_num;     /* num of realCoord samples */
        Vec3f *realCoord;  /* current pixel center world-space coordinates for each sample
-                                          *  ordered as (s_pos+s_num)*/
+                           *  ordered as (s_pos+s_num)*/
        Bounds3D mesh_bounds;
 
        /* adjacency info */
@@ -4145,9 +4145,9 @@ static int dynamicPaint_prepareEffectStep(DynamicPaintSurface *surface, Scene *s
        return steps;
 }
 
-/*
-     Processes active effect step.
-*/
+/**
+ *     Processes active effect step.
+ */
 static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force, PaintPoint *prevPoint, float timescale, float steps)
 {
        PaintSurfaceData *sData = surface->data;
@@ -4159,8 +4159,8 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
        if (!sData->adj_data) return;
 
        /*
-             Spread Effect
-       */
+        *      Spread Effect
+        */
        if (surface->effect & MOD_DPAINT_EFFECT_DO_SPREAD) {
                float eff_scale = distance_scale*EFF_MOVEMENT_PER_FRAME*surface->spread_speed*timescale;
 
@@ -4175,7 +4175,7 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
                        PaintPoint *pPoint = &((PaintPoint*)sData->type_data)[index];
 
                        /*  Only reads values from the surface copy (prevPoint[]),
-                             so this one is thread safe */
+                        *      so this one is thread safe */
 
                        /*      Loop through neighboring points */
                        for (i=0; i<numOfNeighs; i++) {
@@ -4202,8 +4202,8 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
        }
 
        /*
-             Shrink Effect
-       */
+        *      Shrink Effect
+        */
        if (surface->effect & MOD_DPAINT_EFFECT_DO_SHRINK) {
                float eff_scale = distance_scale*EFF_MOVEMENT_PER_FRAME*surface->shrink_speed*timescale;
 
@@ -4227,7 +4227,7 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
                                totalAlpha += ePoint->e_alpha;
 
                                /* Check if neighboring point has lower alpha,
-                               *  if so, decrease this point's alpha as well*/
+                                *  if so, decrease this point's alpha as well*/
                                if (pPoint->alpha <= 0.0f && pPoint->e_alpha <= 0.0f && pPoint->wetness <= 0.0f) continue;
 
                                /* decrease factor for dry paint alpha */
@@ -4251,8 +4251,8 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
        }
 
        /*
-             Drip Effect
-       */
+        *      Drip Effect
+        */
        if (surface->effect & MOD_DPAINT_EFFECT_DO_DRIP && force) 
        {
                float eff_scale = distance_scale*EFF_MOVEMENT_PER_FRAME*timescale/2.0f;
@@ -4450,8 +4450,8 @@ static void dynamicPaint_surfacePreStep(DynamicPaintSurface *surface, float time
                                                dry_ratio = pPoint->wetness/p_wetness;
 
                                                /*
-                                                     Slowly "shift" paint from wet layer to dry layer as it drys:
-                                               */
+                                                *      Slowly "shift" paint from wet layer to dry layer as it drys:
+                                                */
                                                /* make sure alpha values are within proper range */
                                                CLAMP(pPoint->alpha, 0.0f, 1.0f);
                                                CLAMP(pPoint->e_alpha, 0.0f, 1.0f);
@@ -4464,7 +4464,7 @@ static void dynamicPaint_surfacePreStep(DynamicPaintSurface *surface, float time
                                                /* now calculate new alpha for dry layer that keeps final blended color unchanged */
                                                pPoint->alpha = (f_color[3] - pPoint->e_alpha)/(1.0f-pPoint->e_alpha);
                                                /* for each rgb component, calculate a new dry layer color that keeps the final blend color
-                                               *  with these new alpha values. (wet layer color doesnt change)*/
+                                                *  with these new alpha values. (wet layer color doesnt change)*/
                                                if (pPoint->alpha) {
                                                        for (i=0; i<3; i++) {
                                                                pPoint->color[i] = (f_color[i]*f_color[3] - pPoint->e_color[i]*pPoint->e_alpha)/(pPoint->alpha*(1.0f-pPoint->e_alpha));
@@ -4635,8 +4635,8 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, Scene *sc
        }
 
        /*
-             Make a transformed copy of canvas derived mesh vertices to avoid recalculation.
-       */
+        *      Make a transformed copy of canvas derived mesh vertices to avoid recalculation.
+        */
        bData->mesh_bounds.valid = 0;
        for (index=0; index<canvasNumOfVerts; index++) {
                copy_v3_v3(canvas_verts[index].v, mvert[index].co);
@@ -4645,8 +4645,8 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, Scene *sc
        }
 
        /*
-             Prepare each surface point for a new step
-       */
+        *      Prepare each surface point for a new step
+        */
        #pragma omp parallel for schedule(static)
        for (index=0; index<sData->total_points; index++)
        {
@@ -4655,8 +4655,8 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, Scene *sc
                        copy_v3_v3(prev_point, bData->realCoord[bData->s_pos[index]].v);
                }
                /*
-                     Calculate current 3D-position and normal of each surface point
-               */
+                *      Calculate current 3D-position and normal of each surface point
+                */
                if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
                        float n1[3], n2[3], n3[3];
                        ImgSeqFormatData *f_data = (ImgSeqFormatData*)sData->format_data;
@@ -4716,7 +4716,7 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, Scene *sc
                }
 
                /* Prepare surface normal directional scale to easily convert
-               *  brush intersection amount between global and local space */
+                *  brush intersection amount between global and local space */
                if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE ||
                        surface->type == MOD_DPAINT_SURFACE_T_WAVE) {
                        float temp_nor[3];
index 95f4b465beba39f007188eaa4e375d1ead66a9f3..6581c4423562b11c969005455fd1b4d5228723a1 100644 (file)
@@ -106,8 +106,8 @@ MultiresModifierData *find_multires_modifier_before(Scene *scene, ModifierData *
 }
 
 /* used for applying scale on mdisps layer and syncing subdivide levels when joining objects
  use_first - return first multires modifier if all multires'es are disabled
-*/
* use_first - return first multires modifier if all multires'es are disabled
+ */
 MultiresModifierData *get_multires_modifier(Scene *scene, Object *ob, int use_first)
 {
        ModifierData *md;
@@ -128,7 +128,7 @@ MultiresModifierData *get_multires_modifier(Scene *scene, Object *ob, int use_fi
 
        if (!mmd && use_first) {
                /* active multires have not been found
-                  try to use first one */
+                * try to use first one */
                return firstmmd;
        }
 
@@ -491,7 +491,7 @@ static DerivedMesh *subsurf_dm_create_local(Object *ob, DerivedMesh *dm, int lvl
 
 
 /* assumes no is normalized; return value's sign is negative if v is on
  the other side of the plane */
* the other side of the plane */
 static float v3_dist_from_plane(float v[3], float center[3], float no[3])
 {
        float s[3];
@@ -572,7 +572,7 @@ void multiresModifier_base_apply(MultiresModifierData *mmd, Object *ob)
                        float no[3];
 
                        /* set up poly, loops, and coords in order to call
-                          mesh_calc_poly_normal_coords() */
+                        * mesh_calc_poly_normal_coords() */
                        fake_poly.totloop = p->totloop;
                        fake_poly.loopstart = 0;
                        fake_loops = MEM_mallocN(sizeof(MLoop) * p->totloop, "fake_loops");
@@ -813,20 +813,20 @@ static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, DerivedMesh *dm
                                        switch(op) {
                                        case APPLY_DISPLACEMENTS:
                                                /* Convert displacement to object space
-                                                  and add to grid points */
+                                                * and add to grid points */
                                                mul_v3_m3v3(disp, mat, data);
                                                add_v3_v3v3(co, sco, disp);
                                                break;
                                        case CALC_DISPLACEMENTS:
                                                /* Calculate displacement between new and old
-                                                  grid points and convert to tangent space */
+                                                * grid points and convert to tangent space */
                                                sub_v3_v3v3(disp, co, sco);
                                                invert_m3(mat);
                                                mul_v3_m3v3(data, mat, disp);
                                                break;
                                        case ADD_DISPLACEMENTS:
                                                /* Convert subdivided displacements to tangent
-                                                  space and add to the original displacements */
+                                                * space and add to the original displacements */
                                                invert_m3(mat);
                                                mul_v3_m3v3(d, mat, co);
                                                add_v3_v3(data, d);
@@ -1138,7 +1138,7 @@ DerivedMesh *multires_dm_create_from_derived(MultiresModifierData *mmd, int loca
 }
 
 /**** Old Multires code ****
-***************************/
+ ***************************/
 
 /* Adapted from sculptmode.c */
 void old_mdisps_bilinear(float out[3], float (*disps)[3], const int st, float u, float v)
@@ -1669,7 +1669,7 @@ static void multires_load_old_vcols(Mesh *me)
                return;
 
        /* older multires format never supported multiple vcol layers,
-          so we can assume the active vcol layer is the correct one */
+        * so we can assume the active vcol layer is the correct one */
        if (!(mcol = CustomData_get_layer(&me->fdata, CD_MCOL)))
                return;
        
@@ -1776,9 +1776,9 @@ static void multires_sync_levels(Scene *scene, Object *ob, Object *to_ob)
 
        if (!mmd) {
                /* object could have MDISP even when there is no multires modifier
-                  this could lead to troubles due to i've got no idea how mdisp could be
-                  upsampled correct without modifier data.
-                  just remove mdisps if no multires present (nazgul) */
+                * this could lead to troubles due to i've got no idea how mdisp could be
+                * upsampled correct without modifier data.
+                * just remove mdisps if no multires present (nazgul) */
 
                Mesh *me= (Mesh*)ob->data;
 
index 6a72933332bcd9dd2041acd4e82781387e32b622..b24b885c001742d4194bb10a63e09d125ec3bf96 100644 (file)
@@ -119,8 +119,8 @@ static struct ImBuf * prepare_effect_imbufs(
 }
 
 /* **********************************************************************
  PLUGINS
  ********************************************************************** */
* PLUGINS
* ********************************************************************** */
 
 static void open_plugin_seq(PluginSeq *pis, const char *seqname)
 {
@@ -288,8 +288,8 @@ static struct ImBuf * do_plugin_effect(
        char *cp;
        int float_rendering;
        int use_temp_bufs = 0; /* Are needed since blur.c (and maybe some other
-                                 old plugins) do very bad stuff
-                                 with imbuf-internals */
+                               * old plugins) do very bad stuff
+                               * with imbuf-internals */
 
        struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
        int x = context.rectx;
@@ -394,8 +394,8 @@ static void free_plugin(struct Sequence * seq)
 }
 
 /* **********************************************************************
  ALPHA OVER
  ********************************************************************** */
* ALPHA OVER
* ********************************************************************** */
 
 static void init_alpha_over_or_under(Sequence * seq)
 {
@@ -558,8 +558,8 @@ static struct ImBuf * do_alphaover_effect(
 
 
 /* **********************************************************************
  ALPHA UNDER
  ********************************************************************** */
* ALPHA UNDER
* ********************************************************************** */
 
 static void do_alphaunder_effect_byte(
        float facf0, float facf1, int x, int y, char *rect1, 
@@ -730,8 +730,8 @@ static struct ImBuf* do_alphaunder_effect(
 
 
 /* **********************************************************************
  CROSS
  ********************************************************************** */
* CROSS
* ********************************************************************** */
 
 static void do_cross_effect_byte(float facf0, float facf1, int x, int y, 
                          char *rect1, char *rect2, 
@@ -855,8 +855,8 @@ static struct ImBuf* do_cross_effect(
 
 
 /* **********************************************************************
  GAMMA CROSS
  ********************************************************************** */
* GAMMA CROSS
* ********************************************************************** */
 
 /* copied code from initrender.c */
 static unsigned short gamtab[65536];
@@ -1124,8 +1124,8 @@ static struct ImBuf * do_gammacross_effect(
 
 
 /* **********************************************************************
  ADD
  ********************************************************************** */
* ADD
* ********************************************************************** */
 
 static void do_add_effect_byte(float facf0, float facf1, int x, int y, 
                                   unsigned char *rect1, unsigned char *rect2, 
@@ -1240,8 +1240,8 @@ static struct ImBuf * do_add_effect(SeqRenderData context,
 
 
 /* **********************************************************************
  SUB
  ********************************************************************** */
* SUB
* ********************************************************************** */
 
 static void do_sub_effect_byte(float facf0, float facf1, 
                                   int x, int y, 
@@ -1355,8 +1355,8 @@ static struct ImBuf * do_sub_effect(
 }
 
 /* **********************************************************************
  DROP
  ********************************************************************** */
* DROP
* ********************************************************************** */
 
 /* Must be > 0 or add precopy, etc to the function */
 #define XOFF   8
@@ -1444,8 +1444,8 @@ static void do_drop_effect_float(float facf0, float facf1, int x, int y,
 }
 
 /* **********************************************************************
  MUL
  ********************************************************************** */
* MUL
* ********************************************************************** */
 
 static void do_mul_effect_byte(float facf0, float facf1, int x, int y, 
                                   unsigned char *rect1, unsigned char *rect2, 
@@ -1464,7 +1464,7 @@ static void do_mul_effect_byte(float facf0, float facf1, int x, int y,
 
        /* formula:
         *              fac*(a*b) + (1-fac)*a  => fac*a*(b-1)+axaux= c*px + py*s ;//+centx
-                       yaux= -s*px + c*py;//+centy
+        *              yaux= -s*px + c*py;//+centy
         */
 
        while(y--) {
@@ -1569,8 +1569,8 @@ static struct ImBuf * do_mul_effect(
 }
 
 /* **********************************************************************
  WIPE
  ********************************************************************** */
* WIPE
* ********************************************************************** */
 
 typedef struct WipeZone {
        float angle;
@@ -1616,9 +1616,8 @@ static float check_zone(WipeZone *wipezone, int x, int y,
        Sequence *seq, float facf0) 
 {
        float posx, posy,hyp,hyp2,angle,hwidth,b1,b2,b3,pointdist;
-/*some future stuff
-float hyp3,hyp4,b4,b5     
-*/
+       /* some future stuff */
+       // float hyp3,hyp4,b4,b5
        float temp1,temp2,temp3,temp4; //some placeholder variables
        int xo = wipezone->xo;
        int yo = wipezone->yo;
@@ -1714,12 +1713,12 @@ float hyp3,hyp4,b4,b5
                        if(!wipe->forward)output = 1-output;
                break;
                case DO_CLOCK_WIPE:
-                         /*
-                                 temp1: angle of effect center in rads
-                                 temp2: angle of line through (halfx,halfy) and (x,y) in rads
-                                 temp3: angle of low side of blur
-                                 temp4: angle of high side of blur
-                         */
+                       /*
+                        *  temp1: angle of effect center in rads
+                        *  temp2: angle of line through (halfx,halfy) and (x,y) in rads
+                        *  temp3: angle of low side of blur
+                        *  temp4: angle of high side of blur
+                        */
                        output = 1.0f - facf0;
                        widthf = wipe->edgeWidth*2.0f*(float)M_PI;
                        temp1 = 2.0f * (float)M_PI * facf0;
@@ -2002,8 +2001,8 @@ static struct ImBuf * do_wipe_effect(
        return out;
 }
 /* **********************************************************************
  TRANSFORM
  ********************************************************************** */
* TRANSFORM
* ********************************************************************** */
 static void init_transform_effect(Sequence *seq)
 {
        TransformVars *transform;
@@ -2140,8 +2139,8 @@ static struct ImBuf * do_transform_effect(
 
 
 /* **********************************************************************
  GLOW
  ********************************************************************** */
* GLOW
* ********************************************************************** */
 
 static void RVBlurBitmap2_byte ( unsigned char* map, int width,int height,
                                 float blur,
@@ -2667,8 +2666,8 @@ static struct ImBuf * do_glow_effect(
 }
 
 /* **********************************************************************
  SOLID COLOR
  ********************************************************************** */
* SOLID COLOR
* ********************************************************************** */
 
 static void init_solid_color(Sequence *seq)
 {
@@ -2786,8 +2785,8 @@ static struct ImBuf * do_solid_color(
 }
 
 /* **********************************************************************
  MULTICAM
  ********************************************************************** */
* MULTICAM
* ********************************************************************** */
 
 /* no effect inputs for multicam, we use give_ibuf_seq */
 static int num_inputs_multicam(void)
@@ -2840,8 +2839,8 @@ static struct ImBuf * do_multicam(
 }
 
 /* **********************************************************************
  ADJUSTMENT
  ********************************************************************** */
* ADJUSTMENT
* ********************************************************************** */
 
 /* no effect inputs for adjustment, we use give_ibuf_seq */
 static int num_inputs_adjustment(void)
@@ -2871,10 +2870,10 @@ static struct ImBuf * do_adjustment_impl(SeqRenderData context, Sequence * seq,
        }
 
        /* found nothing? so let's work the way up the metastrip stack, so
-          that it is possible to group a bunch of adjustment strips into
-          a metastrip and have that work on everything below the metastrip
-       */
-          
+        *  that it is possible to group a bunch of adjustment strips into
+        *  a metastrip and have that work on everything below the metastrip
+        */
+
        if (!i) {
                Sequence * meta;
 
@@ -2917,8 +2916,8 @@ static struct ImBuf * do_adjustment(
 }
 
 /* **********************************************************************
  SPEED
  ********************************************************************** */
* SPEED
* ********************************************************************** */
 static void init_speed_effect(Sequence *seq)
 {
        SpeedControlVars * v;
@@ -3010,8 +3009,7 @@ void sequence_effect_speed_rebuild_map(Scene *scene, Sequence * seq, int force)
        }
        if (    (seq->seq1 == NULL) ||
                (seq->len < 1)
-       ) { /* make coverity happy and check for (CID 598)
-                                                input strip ... */
+       ) { /* make coverity happy and check for (CID 598) input strip ... */
                return;
        }
 
index 4b2a2fef27f1d73875557b504170a6ec8bb88b6c..8f8874d3a3ca19a73dd54ede4ad41ffd40ec563f 100644 (file)
@@ -124,8 +124,8 @@ int seq_recursive_apply(Sequence *seq, int (*apply_func)(Sequence *, void *), vo
 }
 
 /* **********************************************************************
  alloc / free functions
  ********************************************************************** */
* alloc / free functions
* ********************************************************************** */
 
 
 
@@ -281,8 +281,8 @@ void seq_free_editing(Scene *scene)
 }
 
 /* **********************************************************************
  * sequencer pipeline functions
  ********************************************************************** */
+ * sequencer pipeline functions
* ********************************************************************** */
 
 SeqRenderData seq_new_render_data(
        struct Main * bmain, struct Scene * scene,
@@ -456,13 +456,13 @@ void seq_end(SeqIterator *iter)
 }
 
 /*
-  **********************************************************************
 * build_seqar
 **********************************************************************
 * Build a complete array of _all_ sequencies (including those
 * in metastrips!)
 **********************************************************************
-*/
* **********************************************************************
+ * build_seqar
*********************************************************************
+ * Build a complete array of _all_ sequencies (including those
+ * in metastrips!)
*********************************************************************
+ */
 
 static void do_seq_count_cb(ListBase *seqbase, int *totseq,
                                int (*test_func)(Sequence * seq))
@@ -1048,11 +1048,11 @@ StripElem *give_stripelem(Sequence *seq, int cfra)
 {
        StripElem *se= seq->strip->stripdata;
 
-       if(seq->type == SEQ_IMAGE) { /* only 
-                                       IMAGE strips use the whole array,
-                                       MOVIE strips use only 
-                                       the first element, all other strips
-                                       don't use this... */
+       if(seq->type == SEQ_IMAGE) { /* only
+                                         * IMAGE strips use the whole array,
+                                         * MOVIE strips use only
+                                         * the first element, all other strips
+                                         * don't use this... */
                int nr = (int) give_stripelem_index(seq, cfra);
 
                if (nr == -1 || se == NULL) return NULL;
@@ -1137,8 +1137,8 @@ static int get_shown_sequences(   ListBase * seqbasep, int cfra, int chanshown, Se
 
 
 /* **********************************************************************
  proxy management
  ********************************************************************** */
* proxy management
* ********************************************************************** */
 
 typedef struct SeqIndexBuildContext {
        struct IndexBuildContext *index_context;
@@ -1214,12 +1214,12 @@ static int seq_proxy_get_fname(Sequence * seq, int cfra, int render_size, char *
        }
 
        /* MOVIE tracks (only exception: custom files) are now handled 
-          internally by ImBuf module for various reasons: proper time code 
-          support, quicker index build, using one file instead 
-          of a full directory of jpeg files, etc. Trying to support old
-          and new method at once could lead to funny effects, if people
-          have both, a directory full of jpeg files and proxy avis, so
-          sorry folks, please rebuild your proxies... */
+        * internally by ImBuf module for various reasons: proper time code
+        * support, quicker index build, using one file instead
+        * of a full directory of jpeg files, etc. Trying to support old
+        * and new method at once could lead to funny effects, if people
+        * have both, a directory full of jpeg files and proxy avis, so
+        * sorry folks, please rebuild your proxies... */
 
        if (seq->flag & (SEQ_USE_PROXY_CUSTOM_DIR|SEQ_USE_PROXY_CUSTOM_FILE)) {
                BLI_strncpy(dir, seq->strip->proxy->dir, sizeof(dir));
@@ -1339,7 +1339,7 @@ static void seq_proxy_build_frame(SeqRenderData context,
        }
 
        /* depth = 32 is intentionally left in, otherwise ALPHA channels
-          won't work... */
+        * won't work... */
        quality = seq->strip->proxy->quality;
        ibuf->ftype= JPG | quality;
 
@@ -1465,8 +1465,8 @@ void seq_proxy_rebuild_finish(SeqIndexBuildContext *context, short stop)
 }
 
 /* **********************************************************************
-   color balance 
  ********************************************************************** */
+ * color balance
* ********************************************************************** */
 
 static StripColorBalance calc_cb(StripColorBalance * cb_)
 {
@@ -1628,23 +1628,22 @@ static void color_balance(Sequence * seq, ImBuf* ibuf, float mul)
 }
 
 /*
-  input preprocessing for SEQ_IMAGE, SEQ_MOVIE and SEQ_SCENE
-
-  Do all the things you can't really do afterwards using sequence effects
-  (read: before rescaling to render resolution has been done)
-
-  Order is important!
-
-  - Deinterlace
-  - Crop and transform in image source coordinate space
-  - Flip X + Flip Y (could be done afterwards, backward compatibility)
-  - Promote image to float data (affects pipeline operations afterwards)
-  - Color balance (is most efficient in the byte -> float 
-       (future: half -> float should also work fine!)
-       case, if done on load, since we can use lookup tables)
-  - Premultiply
-
-*/
+ *  input preprocessing for SEQ_IMAGE, SEQ_MOVIE and SEQ_SCENE
+ *
+ *  Do all the things you can't really do afterwards using sequence effects
+ *  (read: before rescaling to render resolution has been done)
+ *
+ *  Order is important!
+ *
+ *  - Deinterlace
+ *  - Crop and transform in image source coordinate space
+ *  - Flip X + Flip Y (could be done afterwards, backward compatibility)
+ *  - Promote image to float data (affects pipeline operations afterwards)
+ *  - Color balance (is most efficient in the byte -> float
+ *    (future: half -> float should also work fine!)
+ *    case, if done on load, since we can use lookup tables)
+ *  - Premultiply
+ */
 
 int input_have_to_preprocess(
        SeqRenderData UNUSED(context), Sequence * seq, float UNUSED(cfra))
@@ -1824,8 +1823,8 @@ static void copy_to_ibuf_still(SeqRenderData context, Sequence * seq, float nr,
 {
        if (nr == 0 || nr == seq->len - 1) {
                /* we have to store a copy, since the passed ibuf
-                  could be preprocessed afterwards (thereby silently
-                  changing the cached image... */
+                * could be preprocessed afterwards (thereby silently
+                * changing the cached image... */
                ibuf = IMB_dupImBuf(ibuf);
 
                if (nr == 0) {
@@ -1845,8 +1844,8 @@ static void copy_to_ibuf_still(SeqRenderData context, Sequence * seq, float nr,
 }
 
 /* **********************************************************************
  strip rendering functions
  ********************************************************************** */
* strip rendering functions
* ********************************************************************** */
 
 static ImBuf* seq_render_strip_stack( 
        SeqRenderData context, ListBase *seqbasep, float cfra, int chanshown);
@@ -1964,35 +1963,35 @@ static ImBuf * seq_render_scene_strip_impl(
        ListBase oldmarkers;
        
        /* Old info:
-          Hack! This function can be called from do_render_seq(), in that case
-          the seq->scene can already have a Render initialized with same name,
-          so we have to use a default name. (compositor uses scene name to
-          find render).
-          However, when called from within the UI (image preview in sequencer)
-          we do want to use scene Render, that way the render result is defined
-          for display in render/imagewindow
-          
-          Hmm, don't see, why we can't do that all the time,
-          and since G.rendering is uhm, gone... (Peter)
-       */
+        * Hack! This function can be called from do_render_seq(), in that case
+        * the seq->scene can already have a Render initialized with same name,
+        * so we have to use a default name. (compositor uses scene name to
+        * find render).
+        * However, when called from within the UI (image preview in sequencer)
+        * we do want to use scene Render, that way the render result is defined
+        * for display in render/imagewindow
+        *
+        * Hmm, don't see, why we can't do that all the time,
+        * and since G.rendering is uhm, gone... (Peter)
+        */
 
        /* New info:
-          Using the same name for the renders works just fine as the do_render_seq()
-          render is not used while the scene strips are rendered.
-          
-          However rendering from UI (through sequencer_preview_area_draw) can crash in
-          very many cases since other renders (material preview, an actual render etc.)
-          can be started while this sequence preview render is running. The only proper
-          solution is to make the sequencer preview render a proper job, which can be
-          stopped when needed. This would also give a nice progress bar for the preview
-          space so that users know there's something happening.
-
-          As a result the active scene now only uses OpenGL rendering for the sequencer
-          preview. This is far from nice, but is the only way to prevent crashes at this
-          time. 
-
-          -jahka
-       */
+        * Using the same name for the renders works just fine as the do_render_seq()
+        * render is not used while the scene strips are rendered.
+        *
+        * However rendering from UI (through sequencer_preview_area_draw) can crash in
+        * very many cases since other renders (material preview, an actual render etc.)
+        * can be started while this sequence preview render is running. The only proper
+        * solution is to make the sequencer preview render a proper job, which can be
+        * stopped when needed. This would also give a nice progress bar for the preview
+        * space so that users know there's something happening.
+        *
+        * As a result the active scene now only uses OpenGL rendering for the sequencer
+        * preview. This is far from nice, but is the only way to prevent crashes at this
+        * time.
+        *
+        * -jahka
+        */
 
        int rendering = G.rendering;
        int doseq;
@@ -2120,7 +2119,7 @@ static ImBuf * seq_render_strip(SeqRenderData context, Sequence * seq, float cfr
        ibuf = seq_stripelem_cache_get(context, seq, cfra, SEQ_STRIPELEM_IBUF);
 
        /* currently, we cache preprocessed images in SEQ_STRIPELEM_IBUF,
-          but not(!) on SEQ_STRIPELEM_IBUF_ENDSTILL and ..._STARTSTILL */
+        * but not(!) on SEQ_STRIPELEM_IBUF_ENDSTILL and ..._STARTSTILL */
        if (ibuf)
                use_preprocess = FALSE;
 
@@ -2263,15 +2262,15 @@ static ImBuf * seq_render_strip(SeqRenderData context, Sequence * seq, float cfr
 }
 
 /* **********************************************************************
  strip stack rendering functions
  ********************************************************************** */
* strip stack rendering functions
* ********************************************************************** */
 
 static int seq_must_swap_input_in_blend_mode(Sequence * seq)
 {
        int swap_input = FALSE;
 
        /* bad hack, to fix crazy input ordering of 
-          those two effects */
+        * those two effects */
 
        if (ELEM3(seq->blend_mode, SEQ_ALPHAOVER, SEQ_ALPHAUNDER, SEQ_OVERDROP)) {
                swap_input = TRUE;
@@ -2808,13 +2807,13 @@ void free_imbuf_seq(Scene *scene, ListBase * seqbase, int check_mem_usage,
        if (check_mem_usage) {
                /* Let the cache limitor take care of this (schlaile) */
                /* While render let's keep all memory available for render 
-                  (ton)
-                  At least if free memory is tight...
-                  This can make a big difference in encoding speed
-                  (it is around 4 times(!) faster, if we do not waste time
-                  on freeing _all_ buffers every time on long timelines...)
-                  (schlaile)
-               */
+                * (ton)
+                * At least if free memory is tight...
+                * This can make a big difference in encoding speed
+                * (it is around 4 times(!) faster, if we do not waste time
+                * on freeing _all_ buffers every time on long timelines...)
+                * (schlaile)
+                */
        
                uintptr_t mem_in_use;
                uintptr_t mmap_in_use;
@@ -2905,11 +2904,11 @@ void update_changed_seq_and_deps(Scene *scene, Sequence *changed_seq, int len_ch
 }
 
 /* seq funcs's for transforming internally
- notice the difference between start/end and left/right.
-
- left and right are the bounds at which the sequence is rendered,
-start and end are from the start and fixed length of the sequence.
-*/
notice the difference between start/end and left/right.
+ *
left and right are the bounds at which the sequence is rendered,
+ * start and end are from the start and fixed length of the sequence.
+ */
 int seq_tx_get_start(Sequence *seq)
 {
        return seq->start;
@@ -2962,7 +2961,7 @@ void seq_tx_set_final_right(Sequence *seq, int val)
 }
 
 /* used so we can do a quick check for single image seq
  since they work a bit differently to normal image seq's (during transform) */
* since they work a bit differently to normal image seq's (during transform) */
 int seq_single_check(Sequence *seq)
 {
        return (seq->len==1 && (
index 664c9389edb621437fbf74cb563beb840b407100..b0075f5c121982b71f62d2b4c0adeb6745deb64c 100644 (file)
@@ -3800,18 +3800,18 @@ static void softbody_update_positions(Object *ob, SoftBody *sb, float (*vertexCo
 
 /* void SB_estimate_transform */
 /* input   Object *ob out (says any object that can do SB like mesh,lattice,curve )
  output  float lloc[3],float lrot[3][3],float lscale[3][3]
  that is:
  a precise position vector denoting the motion of the center of mass
  give a rotation/scale matrix using averaging method, that's why estimate and not calculate
  see: this is kind of reverse engeneering: having to states of a point cloud and recover what happend
  our advantage here we know the identity of the vertex
  there are others methods giving other results.
  lloc,lrot,lscale are allowed to be NULL, just in case you don't need it.
  should be pretty useful for pythoneers :)
  not! velocity .. 2nd order stuff
  vcloud_estimate_transform see
  */
* output  float lloc[3],float lrot[3][3],float lscale[3][3]
* that is:
* a precise position vector denoting the motion of the center of mass
* give a rotation/scale matrix using averaging method, that's why estimate and not calculate
* see: this is kind of reverse engeneering: having to states of a point cloud and recover what happend
* our advantage here we know the identity of the vertex
* there are others methods giving other results.
* lloc,lrot,lscale are allowed to be NULL, just in case you don't need it.
* should be pretty useful for pythoneers :)
* not! velocity .. 2nd order stuff
* vcloud_estimate_transform see
+ */
 
 void SB_estimate_transform(Object *ob,float lloc[3],float lrot[3][3],float lscale[3][3])
 {
index 6cd900c9ed20eca9744706a6ca2aff50a6c57ef2..3f382cc554333d6f3b076a25f4b4d5db1855cb48 100644 (file)
 #include "BPY_extern.h"
 #endif
 
-/***************/ /*
-
-How Texts should work
---
-A text should relate to a file as follows -
-(Text *)->name should be the place where the 
-       file will or has been saved.
-       
-(Text *)->flags has the following bits
-       TXT_ISDIRTY - should always be set if the file in mem. differs from
-                                       the file on disk, or if there is no file on disk.
-       TXT_ISMEM - should always be set if the Text has not been mapped to
-                                       a file, in which case (Text *)->name may be NULL or garbage.                    
-       TXT_ISEXT - should always be set if the Text is not to be written into
-                                       the .blend
-       TXT_ISSCRIPT - should be set if the user has designated the text
-                                       as a script. (NEW: this was unused, but now it is needed by
-                                       space handler script links (see header_view3d.c, for example)
-
-->>> see also: /makesdna/DNA_text_types.h
-
-Display
---
-The st->top determines at what line the top of the text is displayed.
-If the user moves the cursor the st containing that cursor should
-be popped ... other st's retain their own top location.
-
-Markers
---
-The mrk->flags define the behavior and relationships between markers. The
-upper two bytes are used to hold a group ID, the lower two are normal flags. If
-TMARK_EDITALL is set the group ID defines which other markers should be edited.
-
-The mrk->clr field is used to visually group markers where the flags may not
-match. A template system, for example, may allow editing of repeating tokens
-(in one group) but include other marked positions (in another group) all in the
-same template with the same color.
-
-Undo
---
-Undo/Redo works by storing
-events in a queue, and a pointer
-to the current position in the
-queue...
-
-Events are stored using an
-arbitrary op-code system
-to keep track of
-a) the two cursors (normal and selected)
-b) input (visible and control (ie backspace))
-
-input data is stored as its
-ASCII value, the opcodes are
-then selected to not conflict.
-
-opcodes with data in between are
-written at the beginning and end
-of the data to allow undo and redo
-to simply check the code at the current
-undo position
-
-*/ /***************/
+/*
+ * How Texts should work
+ * --
+ * A text should relate to a file as follows -
+ * (Text *)->name should be the place where the
+ *     file will or has been saved.
+ *
+ * (Text *)->flags has the following bits
+ *     TXT_ISDIRTY - should always be set if the file in mem. differs from
+ *                     the file on disk, or if there is no file on disk.
+ *     TXT_ISMEM - should always be set if the Text has not been mapped to
+ *                     a file, in which case (Text *)->name may be NULL or garbage.
+ *     TXT_ISEXT - should always be set if the Text is not to be written into
+ *                     the .blend
+ *     TXT_ISSCRIPT - should be set if the user has designated the text
+ *                     as a script. (NEW: this was unused, but now it is needed by
+ *                     space handler script links (see header_view3d.c, for example)
+ *
+ * ->>> see also: /makesdna/DNA_text_types.h
+ *
+ * Display
+ * --
+ * The st->top determines at what line the top of the text is displayed.
+ * If the user moves the cursor the st containing that cursor should
+ * be popped ... other st's retain their own top location.
+ *
+ * Markers
+ * --
+ * The mrk->flags define the behavior and relationships between markers. The
+ * upper two bytes are used to hold a group ID, the lower two are normal flags. If
+ * TMARK_EDITALL is set the group ID defines which other markers should be edited.
+ *
+ * The mrk->clr field is used to visually group markers where the flags may not
+ * match. A template system, for example, may allow editing of repeating tokens
+ * (in one group) but include other marked positions (in another group) all in the
+ * same template with the same color.
+ *
+ * Undo
+ * --
+ * Undo/Redo works by storing
+ * events in a queue, and a pointer
+ * to the current position in the
+ * queue...
+ *
+ * Events are stored using an
+ * arbitrary op-code system
+ * to keep track of
+ * a) the two cursors (normal and selected)
+ * b) input (visible and control (ie backspace))
+ *
+ * input data is stored as its
+ * ASCII value, the opcodes are
+ * then selected to not conflict.
+ *
+ * opcodes with data in between are
+ * written at the beginning and end
+ * of the data to allow undo and redo
+ * to simply check the code at the current
+ * undo position
+ *
+ */
 
 /***/
 
index 26e8e8afeb710bda8fcb2975cc5cf66fa15ded29..06de3ff05fcaec39a548f0ed625ef48dfcda5ab4 100644 (file)
 /* BLI_assert(), default only to print
  * for aborting need to define WITH_ASSERT_ABORT
  */
-#if !defined NDEBUG
+#ifndef NDEBUG
 #  ifdef WITH_ASSERT_ABORT
 #    define _BLI_DUMMY_ABORT abort
 #  else
index d69ecbe325b3b573b3a961d24fde335ae9d1d66f..ddcc344e9393d80111123a96c00a03e156f52964 100644 (file)
@@ -143,7 +143,6 @@ set(SRC
        BLI_voxel.h
        BLI_winstuff.h
        PIL_time.h
-       intern/dynamiclist.h
 )
 
 if(WITH_BINRELOC)
diff --git a/source/blender/blenlib/intern/dynamiclist.h b/source/blender/blenlib/intern/dynamiclist.h
deleted file mode 100644 (file)
index 64c4a8f..0000000
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Contributor(s): Jiri Hnidek.
- *
- * Documentation of Two way dynamic list with access array can be found at:
- *
- * http://wiki.blender.org/bin/view.pl/Blenderwiki/DynamicListWithAccessArray
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-/** \file blender/blenlib/intern/dynamiclist.h
- *  \ingroup bli
- */
-
-
-#ifndef __DYNAMICLIST_H__
-#define __DYNAMICLIST_H__
-
-#define PAGE_SIZE 4
-
-struct ListBase;
-
-/*
- * Access array using realloc 
- */
-typedef struct DynamicArray{
-       unsigned int count;             /* count of items in list */
-       unsigned int max_item_index;    /* max available index */
-       unsigned int last_item_index;   /* max used index */
-       void **items;                   /* dynamicaly allocated array of pointers
-                                          pointing at items in list */
-} DynamicArray;
-
-/*
- * Two way dynamic list with access array
- */
-typedef struct DynamicList {
-       struct DynamicArray da;         /* access array */
-       struct ListBase lb;             /* two way linked dynamic list */
-} DynamicList;
-
-#endif
index d0dc51d1a8a01d8ed1f6cc5a5e8bd4093f72e38c..dcf03590808d87c717eb4829a71fcc30726b67f7 100644 (file)
@@ -476,7 +476,7 @@ static void build_leaf(PBVH *bvh, int node_index, BBC *prim_bbc,
 }
 
 /* Return zero if all primitives in the node can be drawn with the
  same material (including flat/smooth shading), non-zerootherwise */
* same material (including flat/smooth shading), non-zerootherwise */
 int leaf_needs_material_split(PBVH *bvh, int offset, int count)
 {
        int i, prim;
index 08440b0e12b887194c2109a08235a1f0e3568e4a..56998cfd9273471ea02311f860e1ad6166ad19c1 100644 (file)
@@ -25,8 +25,8 @@
  */
 
 /** \file blender/blenlib/intern/string_cursor_utf8.c
 *  \ingroup bli
 */
+ *  \ingroup bli
+ */
 
 #include <stdio.h>
 #include <stdlib.h>
index cf235c2f0ca7c684341f2ceef5f2f6e083d3b04d..450dfc7f8d1d740ddc481e262ddd6f2aaf77868c 100644 (file)
@@ -57,9 +57,9 @@ typedef struct ImBuf {
        unsigned int   encodedsize;       /**< Size of data written to encodedbuffer */
        unsigned int   encodedbuffersize; /**< Size of encodedbuffer */
 
-       float *rect_float;              /**< floating point Rect equivalent
-                                                               Linear RGB color space - may need gamma correction to 
-                                                               sRGB when generating 8bit representations */
+       float *rect_float;              /** < floating point Rect equivalent
+                                                        * Linear RGB color space - may need gamma correction to
+                                                        * sRGB when generating 8bit representations */
        int channels;                   /**< amount of channels in rect_float (0 = 4 channel default) */
        float dither;                   /**< random dither value, for conversion from float -> byte rect */
        short profile;                  /** color space/profile preset that the byte rect buffer represents */
index b6bd15fd1c3fa8e9aed300b9436b39b2fff63bbb..aac20a96f08335c5d31cf27f218bbf8be3143cf3 100644 (file)
@@ -42,7 +42,7 @@
  */
 
 #define PLUGIN_INTERN /* This tells the LIBEXPORT macro to compile with
-       dll export set on windows */
+                       * dll export set on windows */
 
 #ifdef WIN32
 #include "blenpluginapi/util.h"
index ed4e231edeab4f082fde57ebbf19b0a2d808af1b..02953f84a2220b20d428a5c37259dc37a44edcd1 100644 (file)
@@ -217,7 +217,7 @@ enum {
        BM_ELEM_HIDDEN  = (1 << 1),
        BM_ELEM_SEAM    = (1 << 2),
        BM_ELEM_SMOOTH  = (1 << 3), /* used for faces and edges, note from the user POV,
-                                  * this is a sharp edge when disabled */
+                                 * this is a sharp edge when disabled */
 
        BM_ELEM_TAG     = (1 << 4), /* internal flag, used for ensuring correct normals
                                  * during multires interpolation, and any other time
index 49a4df0fc9caab1d56b153b212504506098fcfc6..e3993b42f3f7944eef1963c6caf9a904e29ad22d 100644 (file)
@@ -103,16 +103,16 @@ static void compute_poly_normal(float normal[3], float (*verts)[3], int nverts)
                }
 #endif
                /* newell's method
-
-               so thats?:
-               (a[1] - b[1]) * (a[2] + b[2]);
-               a[1] * b[2] - b[1] * a[2] - b[1] * b[2] + a[1] * a[2]
-
-               odd.  half of that is the cross product. . .what's the
-               other half?
-
-               also could be like a[1] * (b[2] + a[2]) - b[1] * (a[2] - b[2])
-               */
+                *
+                * so thats?:
+                * (a[1] - b[1]) * (a[2] + b[2]);
+                * a[1] * b[2] - b[1] * a[2] - b[1] * b[2] + a[1] * a[2]
+                *
+                * odd.  half of that is the cross product. . .what's the
+                * other half?
+                *
+                * also could be like a[1] * (b[2] + a[2]) - b[1] * (a[2] - b[2])
+                */
 
                n[0] += (u[1] - v[1]) * (u[2] + v[2]);
                n[1] += (u[2] - v[2]) * (u[0] + v[0]);
@@ -126,12 +126,12 @@ static void compute_poly_normal(float normal[3], float (*verts)[3], int nverts)
 #if 0
        l = len_v3(n);
        /* fast square root, newton/babylonian method:
-       l2 = l * 0.1;
-
-       l2 = (l / l2 + l2) * 0.5;
-       l2 = (l / l2 + l2) * 0.5;
-       l2 = (l / l2 + l2) * 0.5;
-       */
+        * l2 = l * 0.1;
+        *
+        * l2 = (l / l2 + l2) * 0.5;
+        * l2 = (l / l2 + l2) * 0.5;
+        * l2 = (l / l2 + l2) * 0.5;
+        */
 
        if (l == 0.0) {
                normal[0] = 0.0f;
index 5d0e8d957b33ce0513f3fcdb93b3f530a9331874..d7263e07eb86352ac5dde80690977ebb9a17a985 100644 (file)
@@ -111,14 +111,14 @@ void TransformBase::decompose(float mat[][4], float *loc, float eul[3], float qu
 }
 
 /**
-Translation map.
-Used to translate every COLLADA id to a valid id, no matter what "wrong" letters may be
-included. Look at the IDREF XSD declaration for more.
-Follows strictly the COLLADA XSD declaration which explicitly allows non-english chars,
-like special chars (e.g. micro sign), umlauts and so on.
-The COLLADA spec also allows additional chars for member access ('.'), these
-must obviously be removed too, otherwise they would be heavily misinterpreted.
-*/
+ * Translation map.
+ * Used to translate every COLLADA id to a valid id, no matter what "wrong" letters may be
+ * included. Look at the IDREF XSD declaration for more.
+ * Follows strictly the COLLADA XSD declaration which explicitly allows non-english chars,
+ * like special chars (e.g. micro sign), umlauts and so on.
+ * The COLLADA spec also allows additional chars for member access ('.'), these
+ * must obviously be removed too, otherwise they would be heavily misinterpreted.
+ */
 const unsigned char translate_start_name_map[256] = {
 95,  95,  95,  95,  95,  95,  95,  95,  95,
 95,  95,  95,  95,  95,  95,  95,  95,
index 0c9dd8fc699d9a302fdcb6cc4e715ce46395e70b..e1380e6f1e1a5b9753116fbca8ce53f816254a68 100644 (file)
@@ -2411,7 +2411,7 @@ static void knife_make_face_cuts(knifetool_opdata *kcd, BMFace *f, ListBase *kfe
                if (find_hole_chains(kcd, hole, f, &chain, &sidechain)) {
                        /* chain goes across f and sidechain comes back
                         * from the second last vertex to the second vertex.
-                         */
+                        */
                        knife_make_chain_cut(kcd, f, chain, &fnew);
                        kfe = ((Ref *)sidechain->first)->ref;
                        if (knife_edge_in_face(kcd, kfe, f)) {
index 476f037c1910a7e6655a2f530efced870a732129..6288f39367e00d21ea4047541a13f263a8ed074f 100644 (file)
@@ -1743,7 +1743,7 @@ void ED_screen_animation_timer(bContext *C, int redraws, int refresh, int sync,
                
                sad->ar= CTX_wm_region(C);
                /* if startframe is larger than current frame, we put currentframe on startframe.
-                  note: first frame then is not drawn! (ton) */
+                * note: first frame then is not drawn! (ton) */
                if(scene->r.sfra > scene->r.cfra) {
                        sad->sfra= scene->r.cfra;
                        scene->r.cfra= scene->r.sfra;
index 9aa9b6fe857eed216d7cbf774a2aceafd7409796..093143510787dc20206d54e10e6941ac43d3161f 100644 (file)
@@ -62,20 +62,20 @@ typedef struct GPUBufferMaterial {
 } GPUBufferMaterial;
 
 /* meshes are split up by material since changing materials requires
  GL state changes that can't occur in the middle of drawing an
  array.
-
  some simplifying assumptions are made:
  * all quads are treated as two triangles.
  * no vertex sharing is used; each triangle gets its own copy of the
    vertices it uses (this makes it easy to deal with a vertex used
    by faces with different properties, such as smooth/solid shading,
    different MCols, etc.)
-
  to avoid confusion between the original MVert vertices and the
  arrays of OpenGL vertices, the latter are referred to here and in
  the source as `points'. similarly, the OpenGL triangles generated
  for MFaces are referred to as triangles rather than faces.
* GL state changes that can't occur in the middle of drawing an
* array.
+ *
* some simplifying assumptions are made:
* - all quads are treated as two triangles.
* - no vertex sharing is used; each triangle gets its own copy of the
*   vertices it uses (this makes it easy to deal with a vertex used
*   by faces with different properties, such as smooth/solid shading,
*   different MCols, etc.)
+ *
* to avoid confusion between the original MVert vertices and the
* arrays of OpenGL vertices, the latter are referred to here and in
* the source as `points'. similarly, the OpenGL triangles generated
* for MFaces are referred to as triangles rather than faces.
  */
 typedef struct GPUDrawObject {
        GPUBuffer *points;
@@ -107,7 +107,7 @@ typedef struct GPUDrawObject {
        int totedge;
 
        /* if there was a failure allocating some buffer, use old
-          rendering code */
+        * rendering code */
        int legacy;
 } GPUDrawObject;
 
index 5ec373802a3506e58da59d563bba7d4f38122b97..5f541e2e8e63168ded1a5302c8a1c0b28bf4ac63 100644 (file)
@@ -92,18 +92,18 @@ typedef enum GPUDriverType {
 int GPU_type_matches(GPUDeviceType device, GPUOSType os, GPUDriverType driver);
 
 /* GPU Texture
  - always returns unsigned char RGBA textures
  - if texture with non square dimensions is created, depending on the
       graphics card capabilities the texture may actually be stored in a
       larger texture with power of two dimensions. the actual dimensions
       may be queried with GPU_texture_opengl_width/height. GPU_texture_coord_2f
       calls glTexCoord2f with the coordinates adjusted for this.
  - can use reference counting:
         - reference counter after GPU_texture_create is 1
         - GPU_texture_ref increases by one
         - GPU_texture_free decreases by one, and frees if 0
      - if created with from_blender, will not free the texture
-*/
* - always returns unsigned char RGBA textures
* - if texture with non square dimensions is created, depending on the
*   graphics card capabilities the texture may actually be stored in a
*   larger texture with power of two dimensions. the actual dimensions
*   may be queried with GPU_texture_opengl_width/height. GPU_texture_coord_2f
*   calls glTexCoord2f with the coordinates adjusted for this.
* - can use reference counting:
*     - reference counter after GPU_texture_create is 1
*     - GPU_texture_ref increases by one
*     - GPU_texture_free decreases by one, and frees if 0
*  - if created with from_blender, will not free the texture
+ */
 
 GPUTexture *GPU_texture_create_1D(int w, float *pixels, char err_out[256]);
 GPUTexture *GPU_texture_create_2D(int w, int h, float *pixels, char err_out[256]);
@@ -126,11 +126,11 @@ int GPU_texture_opengl_height(GPUTexture *tex);
 int GPU_texture_opengl_bindcode(GPUTexture *tex);
 
 /* GPU Framebuffer
  - this is a wrapper for an OpenGL framebuffer object (FBO). in practice
       multiple FBO's may be created, to get around limitations on the number
       of attached textures and the dimension requirements.
  - after any of the GPU_framebuffer_* functions, GPU_framebuffer_restore must
       be called before rendering to the window framebuffer again */
* - this is a wrapper for an OpenGL framebuffer object (FBO). in practice
*   multiple FBO's may be created, to get around limitations on the number
*   of attached textures and the dimension requirements.
* - after any of the GPU_framebuffer_* functions, GPU_framebuffer_restore must
*   be called before rendering to the window framebuffer again */
 
 GPUFrameBuffer *GPU_framebuffer_create(void);
 int GPU_framebuffer_texture_attach(GPUFrameBuffer *fb, GPUTexture *tex, char err_out[256]);
@@ -142,8 +142,8 @@ void GPU_framebuffer_free(GPUFrameBuffer *fb);
 void GPU_framebuffer_restore(void);
 
 /* GPU OffScreen
-   - wrapper around framebuffer and texture for simple offscreen drawing 
  - changes size if graphics card can't support it */
+ * - wrapper around framebuffer and texture for simple offscreen drawing
* - changes size if graphics card can't support it */
 
 GPUOffScreen *GPU_offscreen_create(int width, int height, char err_out[256]);
 void GPU_offscreen_free(GPUOffScreen *ofs);
@@ -152,8 +152,8 @@ void GPU_offscreen_unbind(GPUOffScreen *ofs);
 void GPU_offscreen_read_pixels(GPUOffScreen *ofs, int type, void *pixels);
 
 /* GPU Shader
  - only for fragment shaders now
  - must call texture bind before setting a texture as uniform! */
* - only for fragment shaders now
* - must call texture bind before setting a texture as uniform! */
 
 GPUShader *GPU_shader_create(const char *vertexcode, const char *fragcode, const char *libcode); /*GPUShader *lib);*/
 /*GPUShader *GPU_shader_create_lib(const char *code);*/
index f6db4f6e7351ba566a61db99f12c951f852eafe5..07d7568ab9549f5bfb01498dd727be8e136223e1 100644 (file)
@@ -72,8 +72,8 @@ static const char* GPU_DATATYPE_STR[17] = {"", "float", "vec2", "vec3", "vec4",
  * These are stored in a hash for lookup when creating a material. */
 
 static GHash *FUNCTION_HASH= NULL;
-/*static char *FUNCTION_PROTOTYPES= NULL;
-static GPUShader *FUNCTION_LIB= NULL;*/
+/* static char *FUNCTION_PROTOTYPES= NULL;
+ * static GPUShader *FUNCTION_LIB= NULL;*/
 
 static int gpu_str_prefix(const char *str, const char *prefix)
 {
index 85bf65232c1656858cd3d3c50da5c9347eb20a56..db334b8bf19cc0cbdf0c34ff5d2e2f9fe76d779c 100644 (file)
@@ -61,10 +61,10 @@ typedef struct GPUFunction {
 GPUFunction *GPU_lookup_function(const char *name);
 
 /* Pass Generation
-   - Takes a list of nodes and a desired output, and makes a pass. This
       will take ownership of the nodes and free them early if unused or
       at the end if used.
-*/
*  - Takes a list of nodes and a desired output, and makes a pass. This
*    will take ownership of the nodes and free them early if unused or
*    at the end if used.
+ */
 
 typedef enum GPUDataSource {
        GPU_SOURCE_VEC_UNIFORM,
index 526f293d0b9ad4c1094aaaee12cea8126efd4692..a5d6c374a423952cfa7f8b358fc4ead04a209b84 100644 (file)
@@ -193,9 +193,11 @@ static int is_pow2_limit(int num)
 {
        /* take texture clamping into account */
 
-       /* XXX: texturepaint not global!
+       /* XXX: texturepaint not global! */
+#if 0
        if (G.f & G_TEXTUREPAINT)
                return 1;*/
+#endif
 
        if (U.glreslimit != 0 && num > U.glreslimit)
                return 0;
@@ -205,10 +207,12 @@ static int is_pow2_limit(int num)
 
 static int smaller_pow2_limit(int num)
 {
-       /* XXX: texturepaint not global!
+       /* XXX: texturepaint not global! */
+#if 0
        if (G.f & G_TEXTUREPAINT)
                return 1;*/
-       
+#endif
+
        /* take texture clamping into account */
        if (U.glreslimit != 0 && num > U.glreslimit)
                return U.glreslimit;
@@ -467,7 +471,7 @@ int GPU_verify_image(Image *ima, ImageUser *iuser, int tftile, int compare, int
        if(ibuf->rect_float) {
                if(U.use_16bit_textures) {
                        /* use high precision textures. This is relatively harmless because OpenGL gives us
-                          a high precision format only if it is available */
+                        * a high precision format only if it is available */
                        use_high_bit_depth = TRUE;
                }
 
@@ -593,7 +597,7 @@ int GPU_verify_image(Image *ima, ImageUser *iuser, int tftile, int compare, int
        }
 
        /* scale if not a power of two. this is not strictly necessary for newer 
-          GPUs (OpenGL version >= 2.0) since they support non-power-of-two-textures */
+        * GPUs (OpenGL version >= 2.0) since they support non-power-of-two-textures */
        if (!is_pow2_limit(rectw) || !is_pow2_limit(recth)) {
                rectw= smaller_pow2_limit(rectw);
                recth= smaller_pow2_limit(recth);
@@ -714,9 +718,9 @@ int GPU_set_tpage(MTFace *tface, int mipmap, int alphablend)
 }
 
 /* these two functions are called on entering and exiting texture paint mode,
  temporary disabling/enabling mipmapping on all images for quick texture
  updates with glTexSubImage2D. images that didn't change don't have to be
  re-uploaded to OpenGL */
* temporary disabling/enabling mipmapping on all images for quick texture
* updates with glTexSubImage2D. images that didn't change don't have to be
* re-uploaded to OpenGL */
 void GPU_paint_set_mipmap(int mipmap)
 {
        Image* ima;
@@ -1086,10 +1090,10 @@ void GPU_begin_object_materials(View3D *v3d, RegionView3D *rv3d, Scene *scene, O
        GMS.gviewinv= rv3d->viewinv;
 
        /* alpha pass setup. there's various cases to handle here:
-          * object transparency on: only solid materials draw in the first pass,
-          and only transparent in the second 'alpha' pass.
-          * object transparency off: for glsl we draw both in a single pass, and
-          for solid we don't use transparency at all. */
+        * - object transparency on: only solid materials draw in the first pass,
+        * and only transparent in the second 'alpha' pass.
+        * - object transparency off: for glsl we draw both in a single pass, and
+        * for solid we don't use transparency at all. */
        GMS.use_alpha_pass = (do_alpha_after != NULL);
        GMS.is_alpha_pass = (v3d && v3d->transp);
        if(GMS.use_alpha_pass)
@@ -1236,7 +1240,7 @@ int GPU_enable_material(int nr, void *attribs)
                        GMS.gboundmat= mat;
 
                        /* for glsl use alpha blend mode, unless it's set to solid and
-                          we are already drawing in an alpha pass */
+                        * we are already drawing in an alpha pass */
                        if(mat->game.alpha_blend != GPU_BLEND_SOLID)
                                alphablend= mat->game.alpha_blend;
 
@@ -1525,8 +1529,8 @@ void GPU_state_init(void)
        glDisable(GL_CULL_FACE);
 
        /* calling this makes drawing very slow when AA is not set up in ghost
-          on Linux/NVIDIA.
-       glDisable(GL_MULTISAMPLE); */
+        * on Linux/NVIDIA. */
+       // glDisable(GL_MULTISAMPLE);
 }
 
 /* debugging aid */
index ea47e67c1e6ebd08a168180924ff9dc76f06b216..e1d6f64f661221d70f18c6d6629d9420bb1a6dbd 100644 (file)
 /* Extensions support */
 
 /* extensions used:
      - texture border clamp: 1.3 core
      - fragement shader: 2.0 core
      - framebuffer object: ext specification
      - multitexture 1.3 core
      - arb non power of two: 2.0 core
      - pixel buffer objects? 2.1 core
      - arb draw buffers? 2.0 core
-*/
* - texture border clamp: 1.3 core
* - fragement shader: 2.0 core
* - framebuffer object: ext specification
* - multitexture 1.3 core
* - arb non power of two: 2.0 core
* - pixel buffer objects? 2.1 core
* - arb draw buffers? 2.0 core
+ */
 
 static struct GPUGlobal {
        GLint maxtextures;
@@ -850,7 +850,7 @@ struct GPUOffScreen {
        GPUTexture *depth;
 
        /* requested width/height, may be smaller than actual texture size due
-          to missing non-power of two support, so we compensate for that */
+        * to missing non-power of two support, so we compensate for that */
        int w, h;
 };
 
@@ -1021,8 +1021,10 @@ GPUShader *GPU_shader_create(const char *vertexcode, const char *fragcode, /*GPU
                }
        }
 
-       /*if(lib && lib->lib)
-               glAttachObjectARB(shader->object, lib->lib);*/
+#if 0
+       if(lib && lib->lib)
+               glAttachObjectARB(shader->object, lib->lib);
+#endif
 
        glLinkProgramARB(shader->object);
        glGetObjectParameterivARB(shader->object, GL_OBJECT_LINK_STATUS_ARB, &status);
index c59af3cc7fbf8657242cd1562d8b5408b291f974..89b3a7d5f3f1e94276bda0863a5ee0ea43db1c3b 100644 (file)
@@ -672,9 +672,10 @@ static void shade_one_light(GPUShadeInput *shi, GPUShadeResult *shr, GPULamp *la
        i = is;
        GPU_link(mat, "shade_visifac", i, visifac, shi->refl, &i);
 
-
-       /*if(ma->mode & MA_TANGENT_VN)
-               GPU_link(mat, "shade_tangent_v_spec", GPU_attribute(CD_TANGENT, ""), &vn);*/
+#if 0
+       if(ma->mode & MA_TANGENT_VN)
+               GPU_link(mat, "shade_tangent_v_spec", GPU_attribute(CD_TANGENT, ""), &vn);
+#endif
 
        /* this replaces if(i > 0.0) conditional until that is supported */
        // done in shade_visifac now, GPU_link(mat, "mtex_value_clamp_positive", i, &i);
@@ -1461,8 +1462,8 @@ GPUMaterial *GPU_material_from_blender(Scene *scene, Material *ma)
        GPU_material_construct_end(mat);
 
        /* note that even if building the shader fails in some way, we still keep
-          it to avoid trying to compile again and again, and simple do not use
-          the actual shader on drawing */
+        * it to avoid trying to compile again and again, and simple do not use
+        * the actual shader on drawing */
 
        link = MEM_callocN(sizeof(LinkData), "GPUMaterialLink");
        link->data = mat;
index 34656daaa194df418b652498924ab50b90574e32..7a96edeaf5f0b6d9609c4ce0c0e242a1cddc1bdf 100644 (file)
@@ -230,7 +230,7 @@ static void where_is_ik_bone(bPoseChannel *pchan, float ik_mat[][3])   // nr = t
 
 
 /* called from within the core where_is_pose loop, all animsystems and constraints
-were executed & assigned. Now as last we do an IK pass */
+ * were executed & assigned. Now as last we do an IK pass */
 static void execute_posetree(struct Scene *scene, Object *ob, PoseTree *tree)
 {
        float R_parmat[3][3], identity[3][3];
@@ -349,8 +349,8 @@ static void execute_posetree(struct Scene *scene, Object *ob, PoseTree *tree)
        pchan= tree->pchan[0];
        if (pchan->parent)
                /* transform goal by parent mat, so this rotation is not part of the
-                  segment's basis. otherwise rotation limits do not work on the
-                  local transform of the segment itself. */
+                * segment's basis. otherwise rotation limits do not work on the
+                * local transform of the segment itself. */
                copy_m4_m4(rootmat, pchan->parent->pose_mat);
        else
                unit_m4(rootmat);
@@ -539,7 +539,7 @@ void iksolver_execute_tree(struct Scene *scene, struct Object *ob,  struct bPose
                execute_posetree(scene, ob, tree);
                
                /* 6. apply the differences to the channels, 
-                         we need to calculate the original differences first */
+                *    we need to calculate the original differences first */
                for(a=0; a<tree->totchannel; a++) {
                        make_dmats(tree->pchan[a]);
                }
index 42a3aace7750b32e3de92a2d924a065ec5de89ca..5385366f0755b9eb051d2d0e69c25cb3ddd13a4b 100644 (file)
@@ -890,33 +890,32 @@ static int convert_channels(IK_Scene *ikscene, PoseTree *tree)
                        flag |= IK_TRANSY;
                }
                /*
-               Logic to create the segments:
-               RX,RY,RZ = rotational joints with no length
-               RY(tip) = rotational joints with a fixed length arm = (0,length,0)
-               TY = translational joint on Y axis
-               F(pos) = fixed joint with an arm at position pos 
-               Conversion rule of the above flags:
-               -   ==> F(tip)
-               X   ==> RX(tip)
-               Y   ==> RY(tip)
-               Z   ==> RZ(tip)
-               XY  ==> RX+RY(tip)
-               XZ  ==> RX+RZ(tip)
-               YZ  ==> RZ+RY(tip)
-               XYZ ==> full spherical unless there are limits, in which case RX+RZ+RY(tip)
-               In case of stretch, tip=(0,0,0) and there is an additional TY joint
-               The frame at last of these joints represents the tail of the bone. 
-               The head is computed by a reverse translation on Y axis of the bone length
-               or in case of TY joint, by the frame at previous joint.
-               In case of separation of bones, there is an additional F(head) joint
-
-               Computing rest pose and length is complicated: the solver works in world space
-               Here is the logic:
-               rest position is computed only from bone->bone_mat.
-               bone length is computed from bone->length multiplied by the scaling factor of
-               the armature. Non-uniform scaling will give bad result!
-
-               */
+                * Logic to create the segments:
+                * RX,RY,RZ = rotational joints with no length
+                * RY(tip) = rotational joints with a fixed length arm = (0,length,0)
+                * TY = translational joint on Y axis
+                * F(pos) = fixed joint with an arm at position pos
+                * Conversion rule of the above flags:
+                * -   ==> F(tip)
+                * X   ==> RX(tip)
+                * Y   ==> RY(tip)
+                * Z   ==> RZ(tip)
+                * XY  ==> RX+RY(tip)
+                * XZ  ==> RX+RZ(tip)
+                * YZ  ==> RZ+RY(tip)
+                * XYZ ==> full spherical unless there are limits, in which case RX+RZ+RY(tip)
+                * In case of stretch, tip=(0,0,0) and there is an additional TY joint
+                * The frame at last of these joints represents the tail of the bone.
+                * The head is computed by a reverse translation on Y axis of the bone length
+                * or in case of TY joint, by the frame at previous joint.
+                * In case of separation of bones, there is an additional F(head) joint
+                *
+                * Computing rest pose and length is complicated: the solver works in world space
+                * Here is the logic:
+                * rest position is computed only from bone->bone_mat.
+                * bone length is computed from bone->length multiplied by the scaling factor of
+                * the armature. Non-uniform scaling will give bad result!
+                */
                switch (flag & (IK_XDOF|IK_YDOF|IK_ZDOF))
                {
                default:
index 1e0cdf10dba46242cc8183e2ca642f59ecf060a4..a68bbb97b62df9ea30bebce5dddfd55a588166dc 100644 (file)
@@ -185,18 +185,17 @@ void IMB_rectblend(struct ImBuf *dbuf, struct ImBuf *sbuf, int destx,
 
 typedef enum IMB_Timecode_Type {
        IMB_TC_NONE       = 0, /* don't use timecode files at all */
-       IMB_TC_RECORD_RUN = 1, /* use images in the order as they are recorded 
-                                 (currently, this is the only one implemented
-                                 and is a sane default)
-                              */
+
+       IMB_TC_RECORD_RUN = 1, /* use images in the order as they are recorded
+                               * (currently, this is the only one implemented
+                               * and is a sane default) */
+
        IMB_TC_FREE_RUN   = 2, /* use global timestamp written by recording
-                                 device (prosumer camcorders e.g. can do
-                                 that) */
-       IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN = 4, 
-                               /* interpolate a global timestamp using the
-                                 record date and time written by recording
-                                 device (*every* consumer camcorder can do
-                                 that :) )*/
+                            * device (prosumer camcorders e.g. can do that) */
+       IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN = 4, /* interpolate a global timestamp using the
+                                                   * record date and time written by recording
+                                                   * device (*every* consumer camcorder can do
+                                                   * that :) )*/
        IMB_TC_RECORD_RUN_NO_GAPS = 8,
        IMB_TC_MAX_SLOT   = 4
 } IMB_Timecode_Type;
@@ -367,8 +366,8 @@ void IMB_interlace(struct ImBuf *ibuf);
 
 /* create char buffer, color corrected if necessary, for ImBufs that lack one */ 
 void IMB_rect_from_float(struct ImBuf *ibuf);
-/* create char buffer for part of the image, color corrected if necessary,
-   Changed part will be stored in buffer. This is expected to be used for texture painting updates */ 
+/* Create char buffer for part of the image, color corrected if necessary,
+ * Changed part will be stored in buffer. This is expected to be used for texture painting updates */
 void IMB_partial_rect_from_float(struct ImBuf *ibuf, float *buffer, int x, int y, int w, int h);
 void IMB_float_from_rect(struct ImBuf *ibuf);
 void IMB_float_from_rect_simple(struct ImBuf *ibuf); /* no profile conversion */
index c2b42db447df2a17e293351268ef5c5de34451fc..076f518585b9d629a9b83779f34feac930c995a9 100644 (file)
@@ -84,8 +84,8 @@ typedef struct ImBuf {
        /* pixels */
        unsigned int *rect;             /* pixel values stored here */
        float *rect_float;              /* floating point Rect equivalent
-                                                       Linear RGB color space - may need gamma correction to 
-                                                       sRGB when generating 8bit representations */
+                                * Linear RGB color space - may need gamma correction to
+                                * sRGB when generating 8bit representations */
 
        /* resolution - pixels per meter */
        double ppm[2];
index 3fa98a04d8d324b683c52d34ad1e774ecea95002..f6927d4f31d6942aa99fef20d9fcea1df3abdf78 100644 (file)
@@ -36,8 +36,8 @@
 #include "BLI_ghash.h"
 
 /* Cache system for movie data - now supports stoting ImBufs only
  Supposed to provide unified cache system for movie clips, sequencer and
  other movie-related areas */
* Supposed to provide unified cache system for movie clips, sequencer and
* other movie-related areas */
 
 struct ImBuf;
 struct MovieCache;
index 6546840ea85e804327bc0918a45a0056d3b41932..dc16b4d7e36611001f863eef2a83a89ebb250ebd 100644 (file)
 #include <stdio.h>
 #include "BKE_utildefines.h"
 #include "IMB_anim.h"
-
 /*
-  separate animation index files to solve the following problems:
-
-  a) different timecodes within one file (like DTS/PTS, Timecode-Track, 
-     "implicit" timecodes within DV-files and HDV-files etc.)
-  b) seeking difficulties within ffmpeg for files with timestamp holes
-  c) broken files that miss several frames / have varying framerates
-  d) use proxies accordingly
-
-  ... we need index files, that provide us with 
-  
-  the binary(!) position, where we have to seek into the file *and*
-  the continuous frame number (ignoring the holes) starting from the 
-  beginning of the file, so that we know, which proxy frame to serve.
-
-  This index has to be only built once for a file and is written into
-  the BL_proxy directory structure for later reuse in different blender files.
-
-*/
+ * separate animation index files to solve the following problems:
+ *
+ * a) different timecodes within one file (like DTS/PTS, Timecode-Track,
+ *    "implicit" timecodes within DV-files and HDV-files etc.)
+ * b) seeking difficulties within ffmpeg for files with timestamp holes
+ * c) broken files that miss several frames / have varying framerates
+ * d) use proxies accordingly
+ *
+ * ... we need index files, that provide us with
+ *
+ * the binary(!) position, where we have to seek into the file *and*
+ * the continuous frame number (ignoring the holes) starting from the
+ * beginning of the file, so that we know, which proxy frame to serve.
+ *
+ * This index has to be only built once for a file and is written into
+ * the BL_proxy directory structure for later reuse in different blender files.
+ */
 
 typedef struct anim_index_entry {
        int frameno;
index 8211896b185c5923ce6c750778126d90c2daf19c..336a5f95082ffb61bc387db2ca3d93d27c58bde9 100644 (file)
@@ -42,13 +42,13 @@ typedef struct ImMetaData {
        int len;
 } ImMetaData;
 
-/** The metadata is a list of key/value pairs (both char*) that can me 
      saved in the header of several image formats.
-       Apart from some common keys like 
-       'Software' and 'Description' (png standard) we'll use keys within the 
      Blender namespace, so should be called 'Blender::StampInfo' or 'Blender::FrameNum'
-       etc... 
-*/
+/** The metadata is a list of key/value pairs (both char*) that can me
* saved in the header of several image formats.
+ * Apart from some common keys like
+ * 'Software' and 'Description' (png standard) we'll use keys within the
* Blender namespace, so should be called 'Blender::StampInfo' or 'Blender::FrameNum'
+ * etc...
+ */
 
 
 /* free blender ImMetaData struct */
@@ -58,7 +58,7 @@ void IMB_metadata_free(struct ImBuf* img);
  *  \param img - the ImBuf that contains the image data
  *  \param key - the key of the field
  *  \param value - the data in the field, first one found with key is returned, 
                                memory has to be allocated by user.
*                 memory has to be allocated by user.
  *  \param len - length of value buffer allocated by user.
  *  \return    - 1 (true) if ImageInfo present and value for the key found, 0 (false) otherwise
  */
index 8722ca8e90afb507686ce0d8e0e3e141bca995ae..2719f2e296bdef28cfda2eebfd095f31b0a98055 100644 (file)
@@ -61,7 +61,7 @@
 #endif
 
 #include "BLI_blenlib.h" /* BLI_remlink BLI_filesize BLI_addtail
-                                                       BLI_countlist BLI_stringdec */
+                          * BLI_countlist BLI_stringdec */
 #include "BLI_utildefines.h"
 #include "BLI_math_base.h"
 
@@ -603,10 +603,10 @@ static int startffmpeg(struct anim * anim)
 }
 
 /* postprocess the image in anim->pFrame and do color conversion
  and deinterlacing stuff.
-
  Output is anim->last_frame
-*/
* and deinterlacing stuff.
+ *
* Output is anim->last_frame
+ */
 
 static void ffmpeg_postprocess(struct anim * anim)
 {
@@ -621,7 +621,7 @@ static void ffmpeg_postprocess(struct anim * anim)
        }
 
        /* This means the data wasnt read properly, 
-          this check stops crashing */
+        * this check stops crashing */
        if (input->data[0]==0 && input->data[1]==0 
            && input->data[2]==0 && input->data[3]==0){
                fprintf(stderr, "ffmpeg_fetchibuf: "
index 77fc6bdf856db01e333cceab5f80f211325d0456..1b6184c8b58502dfcf14caa45692940d1d77f085 100644 (file)
@@ -40,9 +40,9 @@
 #include "IMB_filetype.h"
 
 /* some code copied from article on microsoft.com, copied
-  here for enhanced BMP support in the future
-  http://www.microsoft.com/msj/defaultframe.asp?page=/msj/0197/mfcp1/mfcp1.htm&nav=/msj/0197/newnav.htm
-*/
* here for enhanced BMP support in the future
* http://www.microsoft.com/msj/defaultframe.asp?page=/msj/0197/mfcp1/mfcp1.htm&nav=/msj/0197/newnav.htm
+ */
 
 typedef struct BMPINFOHEADER{
        unsigned int    biSize;
@@ -129,10 +129,13 @@ struct ImBuf *imb_bmp_decode(unsigned char *mem, size_t size, int flags)
        y = LITTLE_LONG(bmi.biHeight);
        depth = LITTLE_SHORT(bmi.biBitCount);
 
-       /* printf("skip: %d, x: %d y: %d, depth: %d (%x)\n", skip, x, y, 
-               depth, bmi.biBitCount); */
-       /* printf("skip: %d, x: %d y: %d, depth: %d (%x)\n", skip, x, y, 
-               depth, bmi.biBitCount); */
+#if 0
+       printf("skip: %d, x: %d y: %d, depth: %d (%x)\n", skip, x, y,
+              depth, bmi.biBitCount);
+       printf("skip: %d, x: %d y: %d, depth: %d (%x)\n", skip, x, y,
+              depth, bmi.biBitCount);
+#endif
+
        if (flags & IB_test) {
                ibuf = IMB_allocImBuf(x, y, depth, 0);
        } else {
index 7213979b500a32cb71fe526b27e05883704ef43f..3bac570da4e5e1104d811101975f63a0d36289cf 100644 (file)
 #include "imbuf.h"
 
 /* We use a two level cache here. A per-thread cache with limited number of
  tiles. This can be accessed without locking and so is hoped to lead to most
  tile access being lock-free. The global cache is shared between all threads
  and requires slow locking to access, and contains all tiles.
-   
  The per-thread cache should be big enough that one might hope to not fall
  back to the global cache every pixel, but not to big to keep too many tiles
  locked and using memory. */
* tiles. This can be accessed without locking and so is hoped to lead to most
* tile access being lock-free. The global cache is shared between all threads
* and requires slow locking to access, and contains all tiles.
+ *
* The per-thread cache should be big enough that one might hope to not fall
* back to the global cache every pixel, but not to big to keep too many tiles
* locked and using memory. */
 
 #define IB_THREAD_CACHE_SIZE   100
 
@@ -207,7 +207,7 @@ void imb_tile_cache_init(void)
        BLI_mutex_init(&GLOBAL_CACHE.mutex);
 
        /* initialize for one thread, for places that access textures
-          outside of rendering (displace modifier, painting, ..) */
+        * outside of rendering (displace modifier, painting, ..) */
        IMB_tile_cache_params(0, 0);
 
        GLOBAL_CACHE.initialized = 1;
@@ -286,8 +286,8 @@ static ImGlobalTile *imb_global_cache_get_tile(ImBuf *ibuf, int tx, int ty, ImGl
        
        if(gtile) {
                /* found tile. however it may be in the process of being loaded
-                  by another thread, in that case we do stupid busy loop waiting
-                  for the other thread to load the tile */
+                * by another thread, in that case we do stupid busy loop waiting
+                * for the other thread to load the tile */
                gtile->refcount++;
 
                BLI_mutex_unlock(&GLOBAL_CACHE.mutex);
@@ -428,7 +428,7 @@ void IMB_tiles_to_rect(ImBuf *ibuf)
                for(ty=0; ty<mipbuf->ytiles; ty++) {
                        for(tx=0; tx<mipbuf->xtiles; tx++) {
                                /* acquire tile through cache, this assumes cache is initialized,
-                                  which it is always now but it's a weak assumption ... */
+                                * which it is always now but it's a weak assumption ... */
                                gtile= imb_global_cache_get_tile(mipbuf, tx, ty, NULL);
 
                                /* setup pointers */
index d3a32774efd5159e9120e28486536ee268383bb5..289dd0357a44fbf00ac918999c638829d8ef221d 100644 (file)
@@ -68,8 +68,8 @@ int logimage_fread(void *buffer, unsigned int size, unsigned int count, void *lo
        if (file->file) return fread(buffer, size, count, file->file);
        else { /*we're reading from memory*/
                int i;
-               /*we convert ot uchar just on the off chance some platform can't handle
-                 pointer arithmetic with type (void*). */
+               /* we convert ot uchar just on the off chance some platform can't handle
+                * pointer arithmetic with type (void*). */
                unsigned char *buf = (unsigned char *) buffer; 
                
                for (i=0; i<count; i++) {
index 9c2220567aaa9a7b5b23e4ba440edb928b59d7bf..5dcf3011c7671a54a6ffeeaadd1e69a61bd6684b 100644 (file)
@@ -55,12 +55,12 @@ public:
        ~Image();
        
        void allocate(uint w, uint h);
-       /*
+#if 0
        bool load(const char * name);
        
        void wrap(void * data, uint w, uint h);
        void unwrap();
-       */
+#endif
        
        uint width() const;
        uint height() const;
index 29da7973654bf10e94a1de1720a137042e8f8273..0d8211264923ece6b73d9de3e937763ad1de8460 100644 (file)
@@ -372,11 +372,14 @@ void IMB_filter_extend(struct ImBuf *ibuf, char *mask, int filter)
 
        /* build a weights buffer */
        n= 1;
-       /*k= 0;
+
+#if 0
+       k= 0;
        for(i = -n; i <= n; i++)
                for(j = -n; j <= n; j++)
                        weight[k++] = sqrt((float) i * i + j * j);
-                       */
+#endif
+
        weight[0]=1; weight[1]=2; weight[2]=1;
        weight[3]=2; weight[4]=0; weight[5]=2;
        weight[6]=1; weight[7]=2; weight[8]=1;
index cd3fc654d8eac963637d766c62b0e1e31f3a0992..0462c998e44352a069842816c280b16c6cd311d3 100644 (file)
@@ -49,7 +49,7 @@
 #include "math.h"
 
 /* This define should be relocated to a global header some where  Kent Mein 
-I stole it from util.h in the plugins api */
+ * I stole it from util.h in the plugins api */
 #define MAX2(x,y)                ( (x)>(y) ? (x) : (y) )
 
 /* Only this one is used liberally here, and in imbuf */
@@ -100,16 +100,15 @@ static void pixel_from_buffer(struct ImBuf *ibuf, unsigned char **outI, float **
 }
 
 /**************************************************************************
-*                            INTERPOLATIONS 
-*
-* Reference and docs:
-* http://wiki.blender.org/index.php/User:Damiles#Interpolations_Algorithms
-***************************************************************************/
-
-/* BICUBIC Interpolation functions */
-/*  More info: http://wiki.blender.org/index.php/User:Damiles#Bicubic_pixel_interpolation
-*/
-/* function assumes out to be zero'ed, only does RGBA */
+ *                            INTERPOLATIONS
+ *
+ * Reference and docs:
+ * http://wiki.blender.org/index.php/User:Damiles#Interpolations_Algorithms
+ ***************************************************************************/
+
+/* BICUBIC Interpolation functions
+ *  More info: http://wiki.blender.org/index.php/User:Damiles#Bicubic_pixel_interpolation
+ * function assumes out to be zero'ed, only does RGBA */
 
 static float P(float k)
 {
index b219d4b592e3ec82f75127165a4bd83d5e53779d..c2bdb44be10b92ff3c2c47394cfc4168e54fe8de 100644 (file)
@@ -68,24 +68,24 @@ int imb_is_a_jp2(unsigned char *buf)
 
 
 /**
-sample error callback expecting a FILE* client object
-*/
+ * sample error callback expecting a FILE* client object
+ */
 static void error_callback(const char *msg, void *client_data)
 {
        FILE *stream = (FILE*)client_data;
        fprintf(stream, "[ERROR] %s", msg);
 }
 /**
-sample warning callback expecting a FILE* client object
-*/
+ * sample warning callback expecting a FILE* client object
+ */
 static void warning_callback(const char *msg, void *client_data)
 {
        FILE *stream = (FILE*)client_data;
        fprintf(stream, "[WARNING] %s", msg);
 }
 /**
-sample debug callback expecting no client object
-*/
+ * sample debug callback expecting no client object
+ */
 static void info_callback(const char *msg, void *client_data)
 {
        (void)client_data;
@@ -292,11 +292,11 @@ struct ImBuf *imb_jp2_decode(unsigned char *mem, size_t size, int flags)
 
 
 /*
-2048x1080 (2K) at 24 fps or 48 fps, or 4096x2160 (4K) at 24 fps; 3x12 bits per pixel, XYZ color space
-
      * In 2K, for Scope (2.39:1) presentation 2048x858 pixels of the imager is used
      * In 2K, for Flat (1.85:1) presentation 1998x1080 pixels of the imager is used
-*/
+ * 2048x1080 (2K) at 24 fps or 48 fps, or 4096x2160 (4K) at 24 fps; 3x12 bits per pixel, XYZ color space
+ *
* - In 2K, for Scope (2.39:1) presentation 2048x858 pixels of the imager is used
* - In 2K, for Flat (1.85:1) presentation 1998x1080 pixels of the imager is used
+ */
 
 /* ****************************** COPIED FROM image_to_j2k.c */
 
@@ -679,9 +679,9 @@ int imb_savejp2(struct ImBuf *ibuf, const char *name, int flags)
        (void)flags; /* unused */
        
        /*
-       configure the event callbacks (not required)
-       setting of each callback is optionnal
-       */
+        * configure the event callbacks (not required)
+        * setting of each callback is optionnal
+        */
        memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
        event_mgr.error_handler = error_callback;
        event_mgr.warning_handler = warning_callback;
@@ -692,7 +692,7 @@ int imb_savejp2(struct ImBuf *ibuf, const char *name, int flags)
        
        /* compression ratio */
        /* invert range, from 10-100, 100-1
-       * where jpeg see's 1 and highest quality (lossless) and 100 is very low quality*/
+        * where jpeg see's 1 and highest quality (lossless) and 100 is very low quality*/
        parameters.tcp_rates[0]= ((100-quality)/90.0f*99.0f) + 1;
 
        
index ca30628c62f2a424ee3a0d25f6e5cc590f332525..2aab497649a0996c1a10a368876d997ec8bb4c3f 100644 (file)
@@ -69,11 +69,11 @@ static ImBuf * ibJpegImageFromCinfo(struct jpeg_decompress_struct * cinfo, int f
  *
  * 1. jpeg - standard printing, u & v at quarter of resulution
  * 2. jvid - standaard video, u & v half resolution, frame not interlaced
-
-type 3 is unsupported as of jul 05 2000 Frank.
-
+ *
+ * type 3 is unsupported as of jul 05 2000 Frank.
+ *
  * 3. jstr - as 2, but written in 2 separate fields
-
+ *
  * 4. jmax - no scaling in the components
  */
 
@@ -142,8 +142,8 @@ static boolean fill_input_buffer(j_decompress_ptr cinfo)
        my_src_ptr src = (my_src_ptr) cinfo->src;
 
        /* Since we have given all we have got already
-       * we simply fake an end of file
-       */
+        * we simply fake an end of file
+        */
 
        src->pub.next_input_byte = src->terminal;
        src->pub.bytes_in_buffer = 2;
index e076dcfa2864f2584dd85bcad24785461acfcfbe..bd79a6ea48b08c2c780539347669c5d95736eb5f 100644 (file)
@@ -1,8 +1,4 @@
-/** \file blender/imbuf/intern/openexr/openexr_api.cpp
- *  \ingroup openexr
- */
 /*
-*
  * ***** BEGIN GPLLICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/imbuf/intern/openexr/openexr_api.cpp
+ *  \ingroup openexr
+ */
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <stddef.h>
@@ -384,11 +384,11 @@ int imb_save_openexr(struct ImBuf *ibuf, const char *name, int flags)
 /* ********************* Nicer API, MultiLayer and with Tile file support ************************************ */
 
 /* naming rules:
  - parse name from right to left
  - last character is channel ID, 1 char like 'A' 'R' 'G' 'B' 'X' 'Y' 'Z' 'W' 'U' 'V'
  - separated with a dot; the Pass name (like "Depth", "Color", "Diffuse" or "Combined")
  - separated with a dot: the Layer name (like "Lamp1" or "Walls" or "Characters")
-*/
* - parse name from right to left
* - last character is channel ID, 1 char like 'A' 'R' 'G' 'B' 'X' 'Y' 'Z' 'W' 'U' 'V'
* - separated with a dot; the Pass name (like "Depth", "Color", "Diffuse" or "Combined")
* - separated with a dot: the Layer name (like "Lamp1" or "Walls" or "Characters")
+ */
 
 static ListBase exrhandles= {NULL, NULL};
 
index 0d51461c2e8a3d17797e153df0a23e11dc6c397b..e03583617134b0f4dbe8610783362b187c020253 100644 (file)
@@ -39,7 +39,7 @@ extern "C" {
   
 #include <stdio.h>
   
-  /**
+/**
  * Test presence of OpenEXR file.
  * \param mem pointer to loaded OpenEXR bitstream
  */
index cb18ddd219b5382f6df9cba557b85bbce35e50fb..88d8b09675bcf81ec8ee5ec4013ed0dbca19885d 100644 (file)
@@ -36,7 +36,7 @@
 /* experiment with more advanced exr api */
 
 /* Note: as for now openexr only supports 32 chars in channel names.
  This api also supports max 8 channels per pass now. easy to fix! */
* This api also supports max 8 channels per pass now. easy to fix! */
 #define EXR_LAY_MAXNAME                19
 #define EXR_PASS_MAXNAME       11
 #define EXR_TOT_MAXNAME                32
index 29b12a2984be66c15c14faa03bed924a3a7c6149..e896fc58cf3077f7fe6a1989e314bd90b9e3f743 100644 (file)
@@ -1,8 +1,4 @@
-/** \file blender/imbuf/intern/openexr/openexr_stub.cpp
- *  \ingroup openexr
- */
 /*
-*
  * ***** BEGIN GPLLICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
@@ -29,6 +25,9 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/imbuf/intern/openexr/openexr_stub.cpp
+ *  \ingroup openexr
+ */
 
 #include "openexr_api.h"
 #include "openexr_multi.h"
index 74047ae74f5313e18f5ddff1b5734bbfc8ab8ebd..84f3e18591dad7851f3c510bd136ece19a1583e9 100644 (file)
@@ -205,15 +205,15 @@ int imb_savepng(struct ImBuf *ibuf, const char *name, int flags)
                png_init_io(png_ptr, fp);
        }
 
-       /*
+#if 0
        png_set_filter(png_ptr, 0,
-               PNG_FILTER_NONE  | PNG_FILTER_VALUE_NONE |
-               PNG_FILTER_SUB   | PNG_FILTER_VALUE_SUB  |
-               PNG_FILTER_UP    | PNG_FILTER_VALUE_UP   |
-               PNG_FILTER_AVG   | PNG_FILTER_VALUE_AVG  |
-               PNG_FILTER_PAETH | PNG_FILTER_VALUE_PAETH|
-               PNG_ALL_FILTERS);
-       */
+                      PNG_FILTER_NONE  | PNG_FILTER_VALUE_NONE |
+                      PNG_FILTER_SUB   | PNG_FILTER_VALUE_SUB  |
+                      PNG_FILTER_UP    | PNG_FILTER_VALUE_UP   |
+                      PNG_FILTER_AVG   | PNG_FILTER_VALUE_AVG  |
+                      PNG_FILTER_PAETH | PNG_FILTER_VALUE_PAETH|
+                      PNG_ALL_FILTERS);
+#endif
 
        png_set_compression_level(png_ptr, compression);
 
index 23db6b47b9d475a6ea04722d67cf7cf2ce888b96..9265da8d8dc8bd23654159f4de796fdacfc3f9d4 100644 (file)
  */
 
 /* ----------------------------------------------------------------------
-  Radiance High Dynamic Range image file IO
-  For description and code for reading/writing of radiance hdr files 
      by Greg Ward, refer to:
-  http://radsite.lbl.gov/radiance/refer/Notes/picture_format.html
-----------------------------------------------------------------------
-*/
* Radiance High Dynamic Range image file IO
+ * For description and code for reading/writing of radiance hdr files
* by Greg Ward, refer to:
* http://radsite.lbl.gov/radiance/refer/Notes/picture_format.html
+ * ----------------------------------------------------------------------
+ */
 
 #ifdef WIN32
 #  include <io.h>
index 97b94ae7b279cb67534d543b99c0b1afa085edf1..492d0af2ac8a801589f79990ec39d79545f56970 100644 (file)
@@ -47,8 +47,8 @@
 static void blend_color_mix(char *cp, char *cp1, char *cp2, int fac)
 {
        /* this and other blending modes previously used >>8 instead of /255. both
-          are not equivalent (>>8 is /256), and the former results in rounding
-          errors that can turn colors black fast after repeated blending */
+        * are not equivalent (>>8 is /256), and the former results in rounding
+        * errors that can turn colors black fast after repeated blending */
        int mfac= 255-fac;
 
        cp[0]= (mfac*cp1[0]+fac*cp2[0])/255;
@@ -93,7 +93,7 @@ static void blend_color_mul(char *cp, char *cp1, char *cp2, int fac)
 static void blend_color_lighten(char *cp, char *cp1, char *cp2, int fac)
 {
        /* See if are lighter, if so mix, else dont do anything.
-       if the paint col is darker then the original, then ignore */
+        * if the paint col is darker then the original, then ignore */
        if (cp1[0]+cp1[1]+cp1[2] > cp2[0]+cp2[1]+cp2[2]) {
                cp[0]= cp1[0];
                cp[1]= cp1[1];
@@ -106,7 +106,7 @@ static void blend_color_lighten(char *cp, char *cp1, char *cp2, int fac)
 static void blend_color_darken(char *cp, char *cp1, char *cp2, int fac)
 {
        /* See if were darker, if so mix, else dont do anything.
-       if the paint col is brighter then the original, then ignore */
+        * if the paint col is brighter then the original, then ignore */
        if (cp1[0]+cp1[1]+cp1[2] < cp2[0]+cp2[1]+cp2[2]) {
                cp[0]= cp1[0];
                cp[1]= cp1[1];
@@ -202,7 +202,7 @@ static void blend_color_mul_float(float *cp, float *cp1, float *cp2, float fac)
 static void blend_color_lighten_float(float *cp, float *cp1, float *cp2, float fac)
 {
        /* See if are lighter, if so mix, else dont do anything.
-       if the pafloat col is darker then the original, then ignore */
+        * if the pafloat col is darker then the original, then ignore */
        if (cp1[0]+cp1[1]+cp1[2] > cp2[0]+cp2[1]+cp2[2]) {
                cp[0]= cp1[0];
                cp[1]= cp1[1];
@@ -215,7 +215,7 @@ static void blend_color_lighten_float(float *cp, float *cp1, float *cp2, float f
 static void blend_color_darken_float(float *cp, float *cp1, float *cp2, float fac)
 {
        /* See if were darker, if so mix, else dont do anything.
-       if the pafloat col is brighter then the original, then ignore */
+        * if the pafloat col is brighter then the original, then ignore */
        if (cp1[0]+cp1[1]+cp1[2] < cp2[0]+cp2[1]+cp2[2]) {
                cp[0]= cp1[0];
                cp[1]= cp1[1];
index c131d38587489f8d95b7ba4108e7e464d25eac25..361faa08b2980cf091949b541e917259c67d87ae 100644 (file)
@@ -773,27 +773,27 @@ static void q_scale_float(float* in, float* out, int in_width,
        }
 }
 
-/* q_scale_linear_interpolation (derived from ppmqscale, http://libdv.sf.net)
-
-   q stands for quick _and_ quality :)
-
-   only handles common cases when we either
-
-   scale  both, x and y or
-   shrink both, x and y
-
-   but that is pretty fast:
-   * does only blit once instead of two passes like the old code
-        (fewer cache misses)
-   * uses fixed point integer arithmetic for byte buffers
  * doesn't branch in tight loops
-
-   Should be comparable in speed to the ImBuf ..._fast functions at least 
-   for byte-buffers.
-
-   NOTE: disabled, due to inacceptable inaccuracy and quality loss, see bug #18609 (ton)
-
-*/
+/**
+ * q_scale_linear_interpolation (derived from ppmqscale, http://libdv.sf.net)
+ *
+ * q stands for quick _and_ quality :)
+ *
+ * only handles common cases when we either
+ *
+ * scale  both, x and y or
+ * shrink both, x and y
+ *
+ * but that is pretty fast:
+ * - does only blit once instead of two passes like the old code
+ *   (fewer cache misses)
* - uses fixed point integer arithmetic for byte buffers
+ * - doesn't branch in tight loops
+ *
+ * Should be comparable in speed to the ImBuf ..._fast functions at least
+ * for byte-buffers.
+ *
+ * NOTE: disabled, due to inacceptable inaccuracy and quality loss, see bug #18609 (ton)
+ */
 static int q_scale_linear_interpolation(
        struct ImBuf *ibuf, int newx, int newy)
 {
@@ -1473,7 +1473,7 @@ struct ImBuf *IMB_scaleImBuf(struct ImBuf * ibuf, unsigned int newx, unsigned in
        if (newx == ibuf->x && newy == ibuf->y) { return ibuf; }
 
        /* scaleup / scaledown functions below change ibuf->x and ibuf->y
-          so we first scale the Z-buffer (if any) */
+        * so we first scale the Z-buffer (if any) */
        scalefast_Z_ImBuf(ibuf, newx, newy);
 
        /* try to scale common cases in a fast way */
index afc64e1a528ab9a99dd5b21e42dee943a4f164b5..1e6bc21612895d96272afdc0278b043fd9021559 100644 (file)
@@ -554,7 +554,7 @@ ImBuf *imb_loadtiff(unsigned char *mem, size_t size, int flags)
        }
 
        /* detect if we are reading a tiled/mipmapped texture, in that case
-          we don't read pixels but leave it to the cache to load tiles */
+        * we don't read pixels but leave it to the cache to load tiles */
        if(flags & IB_tilecache) {
                format= NULL;
                TIFFGetField(image, TIFFTAG_PIXAR_TEXTUREFORMAT, &format);
index eb8d06fc9f233cc60214de3fd10018f389691f18..1737f3b79e692781c0ad2251b9daaaf67cb72e04 100644 (file)
@@ -54,15 +54,14 @@ typedef struct IDProperty {
        char type, subtype;
        short flag;
        char name[64];  /* MAX_IDPROP_NAME */
-       int saved; /*saved is used to indicate if this struct has been saved yet.
-                               seemed like a good idea as a pad var was needed anyway :)*/
+       int saved; /* saved is used to indicate if this struct has been saved yet.
+                   * seemed like a good idea as a pad var was needed anyway :)*/
        IDPropertyData data;    /* note, alignment for 64 bits */
        int len; /* array length, also (this is important!) string length + 1.
                  * the idea is to be able to reuse array realloc functions on strings.*/
        /* totallen is total length of allocated array/string, including a buffer.
         * Note that the buffering is mild; the code comes from python's list implementation.*/
-       int totallen; /*strings and arrays are both buffered, though the buffer isn't
-                                       saved.*/
+       int totallen; /*strings and arrays are both buffered, though the buffer isn't saved.*/
 } IDProperty;
 
 #define MAX_IDPROP_NAME        64
index 058c72be639bd8526a3bf984394ab32572c3788a..73aabd7d84b83c5157e6121de106026addf40bf4 100644 (file)
@@ -416,7 +416,7 @@ typedef enum eItasc_Solver {
 /* Groups -------------------------------------- */
 
 /* Action-Channel Group (agrp)
-
+ *
  * These are stored as a list per-Action, and are only used to 
  * group that Action's channels in an Animation Editor. 
  *
index 776231476ba8c7ff5d9d3397e73277a7ea7e32ed..f4e06455c63d96c81fe742d823cbf613d4ea6d55 100644 (file)
@@ -199,7 +199,7 @@ typedef struct bTwoDFilterActuator {
        /* Tells what type of 2D Filter */
        short type;
        /* (flag == 0) means 2D filter is activate and
-          (flag != 0) means 2D filter is inactive */
+        * (flag != 0) means 2D filter is inactive */
        short flag;
        int   int_arg;
        /* a float argument */
index f915b75a77fcff9bd7faa308a7d81f7c9c014b00..b8b1f7d8b703d3894415c11308a3063f3fd5fdbe 100644 (file)
 struct AnimData;
 
 /* this system works on different transformation space levels;
-
-1) Bone Space;         with each Bone having own (0,0,0) origin
-2) Armature Space;  the rest position, in Object space, Bones Spaces are applied hierarchical
-3) Pose Space;         the animation position, in Object space
-4) World Space;                Object matrix applied to Pose or Armature space
-
-*/
+ *
+ * 1) Bone Space;      with each Bone having own (0,0,0) origin
+ * 2) Armature Space;  the rest position, in Object space, Bones Spaces are applied hierarchical
+ * 3) Pose Space;      the animation position, in Object space
+ * 4) World Space;     Object matrix applied to Pose or Armature space
+ *
+ */
 
 typedef struct Bone {
        struct Bone             *next, *prev;   /*      Next/prev elements within this list     */
index cdf20bd726a738eb83373911fac81cc35101d03c..112247f3d6644b85ffa058644c3ed82e00a927b1 100644 (file)
@@ -59,7 +59,7 @@ typedef struct Camera {
        
        /* yafray: dof params */
        /* qdn: yafray var 'YF_dofdist' now enabled for defocus composite node as well.
-                       The name was not changed so that no other files need to be modified */
+        * The name was not changed so that no other files need to be modified */
        float YF_dofdist;
 
        struct Ipo *ipo  DNA_DEPRECATED; /* old animation system, deprecated for 2.5 */
index 79a1d8215436494c47cb62683efa2b4cc4acce22..fd8b08e68c64ab910bde1d37e1698964062872c0 100644 (file)
 #define __DNA_CLOTH_TYPES_H__
 
 /**
-* This struct contains all the global data required to run a simulation.
-* At the time of this writing, this structure contains data appropriate
-* to run a simulation as described in Deformation Constraints in a
-* Mass-Spring Model to Describe Rigid Cloth Behavior by Xavier Provot.
-*
-* I've tried to keep similar, if not exact names for the variables as
-* are presented in the paper.  Where I've changed the concept slightly,
-* as in stepsPerFrame comapred to the time step in the paper, I've used
-* variables with different names to minimize confusion.
-**/
+ * This struct contains all the global data required to run a simulation.
+ * At the time of this writing, this structure contains data appropriate
+ * to run a simulation as described in Deformation Constraints in a
+ * Mass-Spring Model to Describe Rigid Cloth Behavior by Xavier Provot.
+ *
+ * I've tried to keep similar, if not exact names for the variables as
+ * are presented in the paper.  Where I've changed the concept slightly,
+ * as in stepsPerFrame comapred to the time step in the paper, I've used
+ * variables with different names to minimize confusion.
+ */
 
 typedef struct ClothSimSettings
 {
index e311b6dffeaf351debcf9c15f1b09c95e2508fbd..c9d80476fde502af600cef7eae238d72e648e494 100644 (file)
@@ -92,16 +92,16 @@ typedef struct BevPoint {
  */
 /* note: alfa location in struct is abused by Key system */
 /* vec in BezTriple looks like this:
      vec[0][0]=x location of handle 1
      vec[0][1]=y location of handle 1
      vec[0][2]=z location of handle 1 (not used for FCurve Points(2d))
      vec[1][0]=x location of control point
      vec[1][1]=y location of control point
      vec[1][2]=z location of control point
      vec[2][0]=x location of handle 2
      vec[2][1]=y location of handle 2
      vec[2][2]=z location of handle 2 (not used for FCurve Points(2d))
-*/
* - vec[0][0]=x location of handle 1
* - vec[0][1]=y location of handle 1
* - vec[0][2]=z location of handle 1 (not used for FCurve Points(2d))
* - vec[1][0]=x location of control point
* - vec[1][1]=y location of control point
* - vec[1][2]=z location of control point
* - vec[2][0]=x location of handle 2
* - vec[2][1]=y location of handle 2
* - vec[2][2]=z location of handle 2 (not used for FCurve Points(2d))
+ */
 typedef struct BezTriple {
        float vec[3][3];
        float alfa, weight, radius;     /* alfa: tilt in 3D View, weight: used for softbody goal weight, radius: for bevel tapering */
index c1d6ee4aec3ecf2e8f38010f64c533ce5291d8d5..0dd7f37f8b425e8f84ae89e28af876bc952f0927 100644 (file)
  *
  * DNA has no external dependencies (except for a few system
  * includes).
-
+ *
  * \section dnanote NOTE
-
+ *
  * PLEASE READ INSTRUCTIONS ABOUT ADDING VARIABLES IN 'DNA' STRUCTS IN
  *
  * intern/dna_genfile.c
  * (ton)
-
+ *
  */
 
 
index fedc603fde29a6c4c06a0daed3b7508882a2e864..ca1b1bf172506b282acd6a0f9fa6b60760d89807 100644 (file)
@@ -159,7 +159,7 @@ typedef struct DynamicPaintCanvasSettings {
 #define MOD_DPAINT_PART_RAD (1<<0) /* use particle radius */
 #define MOD_DPAINT_USE_MATERIAL (1<<1) /* use object material */
 #define MOD_DPAINT_ABS_ALPHA (1<<2) /* don't increase alpha unless
-                                                                       paint alpha is higher than existing */
+                                     * paint alpha is higher than existing */
 #define MOD_DPAINT_ERASE (1<<3) /* removes paint */
 
 #define MOD_DPAINT_RAMP_ALPHA (1<<4) /* only read falloff ramp alpha */
index 6416f3117dcb4b023e4dab12c3810881ef34a37c..dcd4306600f098601952959015d999ad6c788834 100644 (file)
@@ -136,7 +136,7 @@ typedef struct Material {
        short diff_shader, spec_shader;
        float roughness, refrac;
        /* XXX param[4] needs review and improvement (shader system as whole anyway)
-          This is nasty reused variable for different goals and not easy to RNAify nicely. -jesterKing */
+        * This is nasty reused variable for different goals and not easy to RNAify nicely. -jesterKing */
        float param[4];         /* size, smooth, size, smooth, for toonshader, 0 (fac) and 1 (fresnel) also for fresnel shader */
        float rms;
        float darkness;
index 13186a9e7802096d8fbc547425d2c07b29fd409c..48704fe43d418c0d9525cc6cc5f31e54e4e8e59e 100644 (file)
@@ -77,8 +77,8 @@ typedef struct Mesh {
        struct MLoopCol *mloopcol;
 /* END BMESH ONLY */
 
-       /*mface stores the tessellation (triangulation) of the mesh,
-         real faces are now stored in nface.*/
+       /* mface stores the tessellation (triangulation) of the mesh,
+        * real faces are now stored in nface.*/
        struct MFace *mface;    /* array of mesh object mode faces for tessellation */
        struct MTFace *mtface;  /* store tessellation face UV's and texture here */
        struct TFace *tface;    /* depecrated, use mtface */
@@ -87,7 +87,7 @@ typedef struct Mesh {
        struct MDeformVert *dvert;      /* deformgroup vertices */
 
        /* array of colors for the tesselated faces, must be number of tesselated
-          faces * 4 in length */
+        * faces * 4 in length */
        struct MCol *mcol;              
        struct MSticky *msticky;
        struct Mesh *texcomesh;
@@ -194,27 +194,6 @@ typedef struct TFace {
 /* debug only option */
 #define ME_DRAWEXTRA_INDICES (1 << 13)
 
-/* old global flags:
-#define G_DRAWEDGES            (1 << 18)
-#define G_DRAWFACES            (1 <<  7)
-#define G_DRAWNORMALS  (1 <<  6)
-#define G_DRAW_VNORMALS        (1 << 14)
-
-#define G_ALLEDGES             (1 << 11)
-#define G_HIDDENEDGES   (1 << 21)
-
-#define G_DRAWCREASES  (1 << 19)
-#define G_DRAWSEAMS     (1 << 20)
-#define G_DRAWSHARP     (1 << 28)
-#define G_DRAWBWEIGHTS (1 << 31)
-
-#define G_DRAW_EDGELEN  (1 << 22) 
-#define G_DRAW_FACEAREA (1 << 23)
-#define G_DRAW_EDGEANG  (1 << 24)
-*/
-
-
-
 /* Subsurf Type */
 #define ME_CC_SUBSURF          0
 #define ME_SIMPLE_SUBSURF      1
index be2a676778f7b0797afb445c62cad7d6edb55fb1..4367d259b1f2dfb1e365e0db08ec673c908be5ce 100644 (file)
@@ -75,8 +75,8 @@ typedef struct MCol {
        char a, r, g, b;        
 } MCol;
 
-/*new face structure, replaces MFace, which is now
-  only used for storing tessellations.*/
+/* new face structure, replaces MFace, which is now
* only used for storing tessellations.*/
 typedef struct MPoly {
        /* offset into loop array and number of loops in the face */
        int loopstart;
@@ -85,8 +85,8 @@ typedef struct MPoly {
        char flag, pad;
 } MPoly;
 
-/*the e here is because we want to move away from
-  relying on edge hashes.*/
+/* the e here is because we want to move away from
* relying on edge hashes.*/
 typedef struct MLoop {
        unsigned int v; /*vertex index*/
        unsigned int e; /*edge index*/
index 9c20b8f644bf547b422831f967e70f76cfa07bfa..2912650c77c0586809d05661be7c4a11c5128c84 100644 (file)
@@ -87,8 +87,8 @@ typedef struct MetaBall {
        float wiresize, rendersize; /* display and render res */
        
        /* bias elements to have an offset volume.
-       mother ball changes will effect other objects thresholds,
-       but these may also have their own thresh as an offset */
+        * mother ball changes will effect other objects thresholds,
+        * but these may also have their own thresh as an offset */
        float thresh;
 
        /* used in editmode */
index a848c3edd499a5b11bcd139d41b5b7a372233ebe..f00bd338fd5751ec26e7a9784db5126ab2c657df 100644 (file)
@@ -191,33 +191,33 @@ typedef struct ArrayModifierData {
        /* the object to use for object offset */
        struct Object *offset_ob;
        /* a constant duplicate offset;
-          1 means the duplicates are 1 unit apart
-       */
+        * 1 means the duplicates are 1 unit apart
+        */
        float offset[3];
        /* a scaled factor for duplicate offsets;
-          1 means the duplicates are 1 object-width apart
-       */
+        * 1 means the duplicates are 1 object-width apart
+        */
        float scale[3];
        /* the length over which to distribute the duplicates */
        float length;
        /* the limit below which to merge vertices in adjacent duplicates */
        float merge_dist;
        /* determines how duplicate count is calculated; one of:
-                 MOD_ARR_FIXEDCOUNT -> fixed
-                 MOD_ARR_FITLENGTH  -> calculated to fit a set length
-                 MOD_ARR_FITCURVE   -> calculated to fit the length of a Curve object
-       */
+        * - MOD_ARR_FIXEDCOUNT -> fixed
+        * - MOD_ARR_FITLENGTH  -> calculated to fit a set length
+        * - MOD_ARR_FITCURVE   -> calculated to fit the length of a Curve object
+        */
        int fit_type;
        /* flags specifying how total offset is calculated; binary OR of:
-                MOD_ARR_OFF_CONST    -> total offset += offset
-                MOD_ARR_OFF_RELATIVE -> total offset += relative * object width
-                MOD_ARR_OFF_OBJ      -> total offset += offset_ob's matrix
-          total offset is the sum of the individual enabled offsets
-       */
+        * - MOD_ARR_OFF_CONST    -> total offset += offset
+        * - MOD_ARR_OFF_RELATIVE -> total offset += relative * object width
+        * - MOD_ARR_OFF_OBJ      -> total offset += offset_ob's matrix
+        * total offset is the sum of the individual enabled offsets
+        */
        int offset_type;
        /* general flags:
-                 MOD_ARR_MERGE -> merge vertices in adjacent duplicates
-       */
+        * MOD_ARR_MERGE -> merge vertices in adjacent duplicates
+        */
        int flags;
        /* the number of duplicates to generate for MOD_ARR_FIXEDCOUNT */
        int count;
@@ -1045,7 +1045,7 @@ typedef struct RemeshModifierData {
        ModifierData modifier;
 
        /* floodfill option, controls how small components can be
-          before they are removed */
+        * before they are removed */
        float threshold;
 
        /* ratio between size of model and grid */
index f764042ee5dc806b70c3e4dc31dd377952a1976d..b4e6c07cec303da33e0eb40b19a6b33d5cc28ae0 100644 (file)
@@ -78,8 +78,8 @@ typedef struct MovieClip {
 
        struct MovieTracking tracking;          /* data for SfM tracking */
        void *tracking_context;                         /* context of tracking job
-                                                                                  used to synchronize data like framenumber
-                                                                                  in SpaceClip clip user */
+                                                                                * used to synchronize data like framenumber
+                                                                                * in SpaceClip clip user */
 
        struct MovieClipProxy proxy;            /* proxy to clip data */
        int flag, pad;
index dbb3f6bfc6636136f0cf9aac3d7202e066af317e..6caf0a7d8b277251206e28e489cd26dd3fa67a1e 100644 (file)
@@ -238,7 +238,7 @@ typedef struct bNodeTree {
        
        int type, init;                                 /* set init on fileread */
        int cur_index;                                  /* sockets in groups have unique identifiers, adding new sockets always 
-                                                                          will increase this counter */
+                                                                        * will increase this counter */
        int flag;
        int update;                                             /* update flags */
        
index 6b11fd0766fc98f30687c0c76c0454e487766f50..0e70b5d28e3ceacc5f62093238eeab95206d48ba 100644 (file)
@@ -130,7 +130,7 @@ typedef struct EffectorWeights {
  * - to add new data types update:
  *             * BKE_ptcache_data_size()
  *             * ptcache_file_init_pointers()
-*/
+ */
 #define BPHYS_DATA_INDEX               0
 #define BPHYS_DATA_LOCATION            1
 #define BPHYS_DATA_SMOKE_LOW   1
@@ -276,9 +276,10 @@ typedef struct SoftBody {
        
        /* general options */
        float nodemass;         /* softbody mass of *vertex* */
-       char  namedVG_Mass[64]; /* MAX_VGROUP_NAME */ /* along with it introduce mass painting
-                                                       starting to fix old bug .. nastyness that VG are indexes 
-                                                               rather find them by name tag to find it -> jow20090613 */
+       char  namedVG_Mass[64]; /* MAX_VGROUP_NAME */
+                               /* along with it introduce mass painting
+                                * starting to fix old bug .. nastyness that VG are indexes
+                                * rather find them by name tag to find it -> jow20090613 */
        float grav;                     /* softbody amount of gravitaion to apply */
        float mediafrict;       /* friction to env */
        float rklimit;          /* error limit for ODE solver */
@@ -291,17 +292,19 @@ typedef struct SoftBody {
        float maxgoal;
        float defgoal;          /* default goal for vertices without vgroup */
        short vertgroup;        /* index starting at 1 */
-       char  namedVG_Softgoal[64]; /* MAX_VGROUP_NAME */ /* starting to fix old bug .. nastyness that VG are indexes 
-                                                               rather find them by name tag to find it -> jow20090613 */
+       char  namedVG_Softgoal[64]; /* MAX_VGROUP_NAME */
+                                   /* starting to fix old bug .. nastyness that VG are indexes
+                                    * rather find them by name tag to find it -> jow20090613 */
   
        short fuzzyness;      /* */
        
        /* springs */
        float inspring;         /* softbody inner springs */
        float infrict;          /* softbody inner springs friction */
-       char  namedVG_Spring_K[64]; /* MAX_VGROUP_NAME */ /* along with it introduce Spring_K painting
-                                      starting to fix old bug .. nastyness that VG are indexes
-                                      rather find them by name tag to find it -> jow20090613 */
+       char  namedVG_Spring_K[64]; /* MAX_VGROUP_NAME */
+                                   /* along with it introduce Spring_K painting
+                                    * starting to fix old bug .. nastyness that VG are indexes
+                                    * rather find them by name tag to find it -> jow20090613 */
        
        /* baking */
        int sfra, efra;
index 3d80e9a08d3be111fcea05dc69d219bc50a39183..79ed1186c1a42e94432ee8e387a032581e05b938 100644 (file)
@@ -614,7 +614,7 @@ typedef struct GameData {
        /*
         * bit 3: (gameengine): Activity culling is enabled.
         * bit 5: (gameengine) : enable Bullet DBVT tree for view frustrum culling
-       */
+        */
        int flag;
        short mode, matmode;
        short occlusionRes;             /* resolution of occlusion Z buffer in pixel */
@@ -837,11 +837,12 @@ typedef struct TransformOrientation {
 } TransformOrientation;
 
 /* *************************************************************** */
-/* Unified Paint Settings */
+/* Unified Paint Settings
+ */
 
 /* These settings can override the equivalent fields in the active
  Brush for any paint mode; the flag field controls whether these
  values are used */
* Brush for any paint mode; the flag field controls whether these
* values are used */
 typedef struct UnifiedPaintSettings {
        /* unified radius of brush in pixels */
        int size;
@@ -861,12 +862,12 @@ typedef enum {
        UNIFIED_PAINT_ALPHA = (1<<1),
 
        /* only used if unified size is enabled, mirros the brush flags
-          BRUSH_LOCK_SIZE and BRUSH_SIZE_PRESSURE */
+        * BRUSH_LOCK_SIZE and BRUSH_SIZE_PRESSURE */
        UNIFIED_PAINT_BRUSH_LOCK_SIZE = (1<<2),
        UNIFIED_PAINT_BRUSH_SIZE_PRESSURE   = (1<<3),
 
        /* only used if unified alpha is enabled, mirrors the brush flag
-          BRUSH_ALPHA_PRESSURE */
+        * BRUSH_ALPHA_PRESSURE */
        UNIFIED_PAINT_BRUSH_ALPHA_PRESSURE  = (1<<4)
 } UnifiedPaintSettingsFlags;
 
@@ -995,7 +996,7 @@ typedef struct ToolSettings {
        int uv_sculpt_tool;
        int uv_relax_method;
        /* XXX: these sculpt_paint_* fields are deprecated, use the
-          unified_paint_settings field instead! */
+        * unified_paint_settings field instead! */
        short sculpt_paint_settings DNA_DEPRECATED;     short pad1;
        int sculpt_paint_unified_size DNA_DEPRECATED;
        float sculpt_paint_unified_unprojected_radius DNA_DEPRECATED;
index 97b65235a29db3c789a2879853ccf22abd7ff4c6..ec02db192fd28a343e5b025f1308cd3cff7851bc 100644 (file)
@@ -48,14 +48,14 @@ typedef struct SDNA {
        short *typelens;        /* type lengths */
 
        int nr_structs;         /* number of struct types */
-       short **structs;        /* sp= structs[a] is the address of a struct definintion
-                                                  sp[0] is struct type number, sp[1] amount of members
-
-                                                  (sp[2], sp[3]), (sp[4], sp[5]), .. are the member
-                                                  type and name numbers respectively */
+       short **structs;        /* sp = structs[a] is the address of a struct definintion
+                            * sp[0] is struct type number, sp[1] amount of members
+                            *
+                            * (sp[2], sp[3]), (sp[4], sp[5]), .. are the member
+                            * type and name numbers respectively */
 
        struct GHash *structs_map; /* ghash for faster lookups,
-                                                                 requires WITH_DNA_GHASH to be used for now */
+                                   * requires WITH_DNA_GHASH to be used for now */
 
                /* wrong place for this really, its a simple
                 * cache for findstruct_nr.
index 894e1135c0d99aa73fe6b3576fb3e28750117b78..053c0c8f7d3f1dba47fad04d7718baf7f8476dd9 100644 (file)
@@ -109,8 +109,7 @@ typedef struct SmokeDomainSettings {
 
 /* flags */
 #define MOD_SMOKE_FLOW_ABSOLUTE (1<<1) /*old style emission*/
-#define MOD_SMOKE_FLOW_INITVELOCITY (1<<2) /* passes particles speed to
-                                                                                the smoke*/
+#define MOD_SMOKE_FLOW_INITVELOCITY (1<<2) /* passes particles speed to the smoke */
 
 
 typedef struct SmokeFlowSettings {
@@ -128,11 +127,10 @@ typedef struct SmokeFlowSettings {
        int flags; /* absolute emission etc*/
 } SmokeFlowSettings;
 
-/*
-       struct BVHTreeFromMesh *bvh;
-       float mat[4][4];
-       float mat_old[4][4];
-       */
+
+// struct BVHTreeFromMesh *bvh;
+// float mat[4][4];
+// float mat_old[4][4];
 
 /* collision objects (filled with smoke) */
 typedef struct SmokeCollSettings {
index 1fab63f9d63a916cec86b1e75232caea445578af..67683979e2ed25701b37f3c0c5cd27f6499ba70c 100644 (file)
@@ -75,8 +75,8 @@ typedef struct bSound {
        int flags;
        int pad;
 
-/**    currently       int type;
-       struct bSound *child_sound;*/
+/    currently       int type;
+//     struct bSound *child_sound;*/
 
        /**
         * The audaspace handle for cache.
@@ -94,17 +94,19 @@ typedef struct bSound {
         */
        void *playback_handle;
 
-/**    XXX unused currently    // SOUND_TYPE_LIMITER
-       float start, end;*/
+/    XXX unused currently    // SOUND_TYPE_LIMITER
+//     float start, end;*/
 } bSound;
 
-/* XXX unused currently
+/* XXX unused currently */
+#if 0
 typedef enum eSound_Type {
        SOUND_TYPE_INVALID = -1,
        SOUND_TYPE_FILE = 0,
        SOUND_TYPE_BUFFER,
        SOUND_TYPE_LIMITER
-} eSound_Type;*/
+} eSound_Type;
+#endif
 
 /* spacesound->flag */
 #define SND_DRAWFRAMES 1
index 7b633523ef8cf26fe17339d6cca6d30e48d16a9c..128c1422ed64a44c02127df2396561cc0678ee8a 100644 (file)
@@ -215,10 +215,10 @@ typedef struct SpaceFile {
        ListBase *folders_next; /* holds the list of next directories (pushed from previous) to show */
 
        /* operator that is invoking fileselect 
-          op->exec() will be called on the 'Load' button.
-          if operator provides op->cancel(), then this will be invoked
-          on the cancel button.
-       */
+        * op->exec() will be called on the 'Load' button.
+        * if operator provides op->cancel(), then this will be invoked
+        * on the cancel button.
+        */
        struct wmOperator *op; 
 
        struct wmTimer *smoothscroll_timer;
@@ -516,8 +516,8 @@ typedef struct SpaceClip {
        /* current stabilization data */
        float loc[2], scale, angle;     /* pre-composed stabilization data */
        int pad;
-       float stabmat[4][4], unistabmat[4][4];          /* current stabilization matrix and the same matrix in unified space,
-                                                                                                  defined when drawing and used for mouse position calculation */
+       float stabmat[4][4], unistabmat[4][4];  /* current stabilization matrix and the same matrix in unified space,
+                                                * defined when drawing and used for mouse position calculation */
 
        /* movie postprocessing */
        int postproc_flag;
index e72b7dcfa72ebd8322d9541067c445c7ee9ee996..2243eb357fc55b90b8e7e88bbdaa2c927b0befca 100644 (file)
@@ -619,11 +619,11 @@ extern UserDef U; /* from blenkernel blender.c */
 /* orbit navigation modes
  * only two options, so it's sort of a hybrid bool/enum
  * if ((U.ndof_flag & NDOF_ORBIT_MODE) == NDOF_OM_OBJECT)... */
-/*
-#define NDOF_ORBIT_MODE     (1 << 6)
-#define NDOF_OM_TARGETCAMERA 0
-#define NDOF_OM_OBJECT      NDOF_ORBIT_MODE
-*/
+
+// #define NDOF_ORBIT_MODE     (1 << 6)
+// #define NDOF_OM_TARGETCAMERA 0
+// #define NDOF_OM_OBJECT      NDOF_ORBIT_MODE
+
 /* actually... users probably don't care about what the mode
  * is called, just that it feels right */
 /* zoom is up/down if this flag is set (otherwise forward/backward) */
index a332c77c402fb887a94c46310d9f07091f70d85b..2148bc96c04d6402c3d4160859f0350e2af54c6b 100644 (file)
 
 
 /* gcc 4.1 on mingw was complaining that __int64 was already defined
-actually is saw the line below as typedef long long long long... 
-Anyhow, since its already defined, its safe to do an ifndef here- Campbell */
+ * actually is saw the line below as typedef long long long long...
+ * Anyhow, since its already defined, its safe to do an ifndef here- Campbell */
 #ifdef FREE_WINDOWS
-#ifndef __int64
+#  ifndef __int64
 typedef long long __int64;
-#endif
+#  endif
 #endif
 
 /*
  * - please note: no builtin security to detect input of double structs
  * - if you want a struct not to be in DNA file: add two hash marks above it (#<enter>#<enter>)
-
-Structure DNA data is added to each blender file and to each executable, this to detect
-in .blend files new veriables in structs, changed array sizes, etc. It's also used for
-converting endian and pointer size (32-64 bits)
-As an extra, Python uses a call to detect run-time the contents of a blender struct.
-
-Create a structDNA: only needed when one of the input include (.h) files change.
-File Syntax:
      SDNA (4 bytes) (magic number)
      NAME (4 bytes)
      <nr> (4 bytes) amount of names (int)
-       <string> 
      <string>
      ...
      ...
      TYPE (4 bytes)
      <nr> amount of types (int)
      <string>
      <string>
      ...
      ...
      TLEN (4 bytes)
      <len> (short) the lengths of types
      <len>
      ...
      ...
      STRC (4 bytes)
      <nr> amount of structs (int)
      <typenr><nr_of_elems> <typenr><namenr> <typenr><namenr> ...
-       
-!!Remember to read/write integer and short aligned!!
-
- While writing a file, the names of a struct is indicated with a type number,
- to be found with: type= findstruct_nr(SDNA *, char *)
- The value of 'type' corresponds with the the index within the structs array
-
- For the moment: the complete DNA file is included in a .blend file. For
- the future we can think of smarter methods, like only included the used
- structs. Only needed to keep a file short though...
-
-ALLOWED AND TESTED CHANGES IN STRUCTS:
- - type change (a char to float will be divided by 255)
- - location within a struct (everthing can be randomly mixed up)
- - struct within struct (within struct etc), this is recursive
- - adding new elements, will be default initialized zero
- - remving elements
- - change of array sizes
- - change of a pointer type: when the name doesn't change the contents is copied
-
-NOT YET:
- - array (vec[3]) to float struct (vec3f)
-
-DONE:
- - endian compatibility
- - pointer conversion (32-64 bits)
-
-IMPORTANT:
- - do not use #defines in structs for array lengths, this cannot be read by the dna functions
- - do not use uint, but unsigned int instead, ushort and ulong are allowed
- - only use a long in Blender if you want this to be the size of a pointer. so it is
-   32 bits or 64 bits, dependent at the cpu architecture
- - chars are always unsigned
- - aligment of variables has to be done in such a way, that any system does
-   not create 'padding' (gaps) in structures. So make sure that:
-   - short: 2 aligned
-   - int: 4 aligned
-   - float: 4 aligned
-   - double: 8 aligned
-   - long: 8 aligned
-   - struct: 8 aligned
- - the sdna functions have several error prints builtin, always check blender running from a console.
-*/
+ *
+ * Structure DNA data is added to each blender file and to each executable, this to detect
+ * in .blend files new veriables in structs, changed array sizes, etc. It's also used for
+ * converting endian and pointer size (32-64 bits)
+ * As an extra, Python uses a call to detect run-time the contents of a blender struct.
+ *
+ * Create a structDNA: only needed when one of the input include (.h) files change.
+ * File Syntax:
*     SDNA (4 bytes) (magic number)
*     NAME (4 bytes)
*     <nr> (4 bytes) amount of names (int)
+ *     <string>
*     <string>
*     ...
*     ...
*     TYPE (4 bytes)
*     <nr> amount of types (int)
*     <string>
*     <string>
*     ...
*     ...
*     TLEN (4 bytes)
*     <len> (short) the lengths of types
*     <len>
*     ...
*     ...
*     STRC (4 bytes)
*     <nr> amount of structs (int)
*     <typenr><nr_of_elems> <typenr><namenr> <typenr><namenr> ...
+ *
+ * !!Remember to read/write integer and short aligned!!
+ *
*  While writing a file, the names of a struct is indicated with a type number,
*  to be found with: type= findstruct_nr(SDNA *, char *)
*  The value of 'type' corresponds with the the index within the structs array
+ *
*  For the moment: the complete DNA file is included in a .blend file. For
*  the future we can think of smarter methods, like only included the used
*  structs. Only needed to keep a file short though...
+ *
+ * ALLOWED AND TESTED CHANGES IN STRUCTS:
*  - type change (a char to float will be divided by 255)
*  - location within a struct (everthing can be randomly mixed up)
*  - struct within struct (within struct etc), this is recursive
*  - adding new elements, will be default initialized zero
*  - remving elements
*  - change of array sizes
*  - change of a pointer type: when the name doesn't change the contents is copied
+ *
+ * NOT YET:
*  - array (vec[3]) to float struct (vec3f)
+ *
+ * DONE:
*  - endian compatibility
*  - pointer conversion (32-64 bits)
+ *
+ * IMPORTANT:
*  - do not use #defines in structs for array lengths, this cannot be read by the dna functions
*  - do not use uint, but unsigned int instead, ushort and ulong are allowed
*  - only use a long in Blender if you want this to be the size of a pointer. so it is
*    32 bits or 64 bits, dependent at the cpu architecture
*  - chars are always unsigned
*  - aligment of variables has to be done in such a way, that any system does
*    not create 'padding' (gaps) in structures. So make sure that:
*    - short: 2 aligned
*    - int: 4 aligned
*    - float: 4 aligned
*    - double: 8 aligned
*    - long: 8 aligned
*    - struct: 8 aligned
*  - the sdna functions have several error prints builtin, always check blender running from a console.
+ *
+ */
 
 /* local */
 static int le_int(int temp);
@@ -351,8 +351,8 @@ static void init_structDNA(SDNA *sdna, int do_endian_swap)
                        sdna->names[nr]= cp;
 
                        /* "float gravity [3]" was parsed wrong giving both "gravity" and
-                          "[3]"  members. we rename "[3]", and later set the type of
-                          "gravity" to "void" so the offsets work out correct */
+                        * "[3]"  members. we rename "[3]", and later set the type of
+                        * "gravity" to "void" so the offsets work out correct */
                        if(*cp == '[' && strcmp(cp, "[3]")==0) {
                                if(nr && strcmp(sdna->names[nr-1], "Cvi") == 0) {
                                        sdna->names[nr]= "gravity[3]";
@@ -644,14 +644,14 @@ char *DNA_struct_get_compareflags(SDNA *sdna, SDNA *newsdna)
                if(compflags[a]==2) recurs_test_compflags(sdna, compflags, a);
        }
        
-/*
+#if 0
        for(a=0; a<sdna->nr_structs; a++) {
                if(compflags[a]==2) {
                        spold= sdna->structs[a];
                        printf("changed: %s\n", sdna->types[ spold[0] ]);
                }
        }
-*/
+#endif
 
        return compflags;
 }
@@ -843,14 +843,14 @@ static void reconstruct_elem(SDNA *newsdna, SDNA *oldsdna,
                              char *type, const char *name, char *curdata, short *old, char *olddata)
 {
        /* rules: test for NAME:
-                       - name equal:
-                               - cast type
-                       - name partially equal (array differs)
-                               - type equal: memcpy
-                               - types casten
-          (nzc 2-4-2001 I want the 'unsigned' bit to be parsed as well. Where
-          can I force this?)
-       */      
+        *              - name equal:
+        *                      - cast type
+        *              - name partially equal (array differs)
+        *                      - type equal: memcpy
+        *                      - types casten
+        * (nzc 2-4-2001 I want the 'unsigned' bit to be parsed as well. Where
+        * can I force this?)
+        */
        int a, elemcount, len, array, oldsize, cursize, mul;
        char *otype;
        const char *oname, *cp;
index 77f3e8084dd483d59052b5d15e902d3dbd1a53df..42fe26d87a9d08da985e27174856783dba997401 100644 (file)
@@ -146,9 +146,9 @@ static char **types, *typedata;             /* at address types[a] is string a */
 static short *typelens;                                /* at typelens[a] is de length of type a */
 static short *alphalens;                       /* contains sizes as they are calculated on the DEC Alpha (64 bits), infact any 64bit system */
 static short **structs, *structdata;/* at sp= structs[a] is the first address of a struct definition
-                                       sp[0] is type number
-                                       sp[1] is amount of elements
-                                       sp[2] sp[3] is typenr,  namenr (etc) */
+                                     * sp[0] is type number
+                                     * sp[1] is amount of elements
+                                     * sp[2] sp[3] is typenr,  namenr (etc) */
 /**
  * Variable to control debug output of makesdna.
  * debugSDNA:
@@ -289,9 +289,9 @@ static int add_name(const char *str)
 
        if (str[0] == '(' && str[1] == '*') {
                /* we handle function pointer and special array cases here, e.g.
-                  void (*function)(...) and float (*array)[..]. the array case
-                  name is still converted to (array*)() though because it is that
-                  way in old dna too, and works correct with elementsize() */
+                * void (*function)(...) and float (*array)[..]. the array case
+                * name is still converted to (array*)() though because it is that
+                * way in old dna too, and works correct with elementsize() */
                int isfuncptr = (strchr(str+1, '(')) != NULL;
 
                if (debugSDNA > 3) printf("\t\t\t\t*** Function pointer or multidim array pointer found\n");
@@ -539,8 +539,8 @@ static void *read_file_data(char *filename, int *len_r)
 static int convert_include(char *filename)
 {
        /* read include file, skip structs with a '#' before it.
-          store all data in temporal arrays.
-       */
+        * store all data in temporal arrays.
+        */
        int filelen, count, overslaan, slen, type, name, strct;
        short *structpoin, *sp;
        char *maindata, *mainend, *md, *md1;
index 95f988b470b2a326bd88824f643c0c7af433397f..d6c3422c8d4e46419b2e3023ea171f45193559f9 100644 (file)
@@ -100,10 +100,10 @@ PropertyRNA *RNA_def_float_rotation(StructOrFunctionRNA *cont, const char *ident
        float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax);
 PropertyRNA *RNA_def_float_array(StructOrFunctionRNA *cont, const char *identifier, int len, const float *default_value,
        float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax);
-       /*
-PropertyRNA *RNA_def_float_dynamic_array(StructOrFunctionRNA *cont, const char *identifier, float hardmin, float hardmax,
-       const char *ui_name, const char *ui_description, float softmin, float softmax, unsigned int dimension, unsigned short dim_size[]);
-       */
+
+//PropertyRNA *RNA_def_float_dynamic_array(StructOrFunctionRNA *cont, const char *identifier, float hardmin, float hardmax,
+//     const char *ui_name, const char *ui_description, float softmin, float softmax, unsigned int dimension, unsigned short dim_size[]);
+
 PropertyRNA *RNA_def_float_percentage(StructOrFunctionRNA *cont, const char *identifier, float default_value, float hardmin, float hardmax,
        const char *ui_name, const char *ui_description, float softmin, float softmax);
 PropertyRNA *RNA_def_float_factor(StructOrFunctionRNA *cont, const char *identifier, float default_value, float hardmin, float hardmax,
index af45c6d1696f99a0eda613376fb32d837632f53e..8a668f68761be2b8ee04984a05b557c702d232d2 100644 (file)
@@ -191,7 +191,7 @@ typedef enum PropertyFlag {
         * this exposes the flag as multiple options in python and the UI.
         *
         * note: these can't be animated so use with care.
-         */
+        */
        PROP_ENUM_FLAG = 1<<21,
 
        /* need context for update function */
index 418d4e31819dfd384e4e31c1470eabaf6ffed453..2e8090c71f40436398d38b4f72b25b1e58804825 100644 (file)
@@ -1559,12 +1559,14 @@ static void rna_def_property_funcs_impl_cpp(FILE *f, StructRNA *srna, PropertyDe
                        break;
                }
                case PROP_COLLECTION: {
-                       /*CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)dp->prop;
+#if 0
+                       CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)dp->prop;
 
                        if(cprop->type)
                                fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", (const char*)cprop->type, srna->identifier, prop->identifier);
                        else
-                               fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", "UnknownType", srna->identifier, prop->identifier);*/
+                               fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", "UnknownType", srna->identifier, prop->identifier);
+#endif
                        break;
                }
        }
@@ -2529,9 +2531,11 @@ static void rna_generate(BlenderRNA *brna, FILE *f, const char *filename, const
        PropertyDefRNA *dp;
        FunctionDefRNA *dfunc;
        
-       fprintf(f, "\n/* Automatically generated struct definitions for the Data API.\n"
-                                "   Do not edit manually, changes will be overwritten.           */\n\n"
-                                 "#define RNA_RUNTIME\n\n");
+       fprintf(f,
+               "\n"
+               "/* Automatically generated struct definitions for the Data API.\n"
+               " * Do not edit manually, changes will be overwritten.           */\n\n"
+               "#define RNA_RUNTIME\n\n");
 
        fprintf(f, "#include <float.h>\n");
        fprintf(f, "#include <stdio.h>\n");
@@ -2606,8 +2610,9 @@ static void rna_generate_header(BlenderRNA *brna, FILE *f)
        fprintf(f, "\n#ifndef __RNA_BLENDER_H__\n");
        fprintf(f, "#define __RNA_BLENDER_H__\n\n");
 
-       fprintf(f, "/* Automatically generated function declarations for the Data API.\n"
-                                "   Do not edit manually, changes will be overwritten.              */\n\n");
+       fprintf(f,
+               "/* Automatically generated function declarations for the Data API.\n"
+               " * Do not edit manually, changes will be overwritten.              */\n\n");
 
        fprintf(f, "#include \"RNA_types.h\"\n\n");
 
@@ -2768,8 +2773,9 @@ static void rna_generate_header_cpp(BlenderRNA *brna, FILE *f)
        fprintf(f, "\n#ifndef __RNA_BLENDER_CPP_H__\n");
        fprintf(f, "#define __RNA_BLENDER_CPP_H__\n\n");
 
-       fprintf(f, "/* Automatically generated classes for the Data API.\n"
-                                "   Do not edit manually, changes will be overwritten. */\n\n");
+       fprintf(f,
+               "/* Automatically generated classes for the Data API.\n"
+               " * Do not edit manually, changes will be overwritten. */\n\n");
        
        fprintf(f, "#include \"RNA_blender.h\"\n");
        fprintf(f, "#include \"RNA_types.h\"\n");
index 6ca66f1d11689ad63b67ce8a1fb4c6a9f18e8942..bb541471a19e54cf89dd5e5b1caffb328795e8f5 100644 (file)
@@ -262,11 +262,13 @@ ID *rna_ID_copy(ID *id)
 static void rna_ID_update_tag(ID *id, ReportList *reports, int flag)
 {
        /* XXX, new function for this! */
-       /*if (ob->type == OB_FONT) {
+#if 0
+       if (ob->type == OB_FONT) {
                Curve *cu = ob->data;
                freedisplist(&cu->disp);
                BKE_text_to_curve(sce, ob, CU_LEFT);
-       }*/
+       }
+#endif
 
        if (flag == 0) {
                /* pass */
@@ -281,12 +283,14 @@ static void rna_ID_update_tag(ID *id, ReportList *reports, int flag)
                        }
                        break;
                /* Could add particle updates later */
-/*             case ID_PA:
+#if 0
+               case ID_PA:
                        if(flag & ~(OB_RECALC_ALL|PSYS_RECALC)) {
                                BKE_report(reports, RPT_ERROR, "'refresh' incompatible with ParticleSettings ID type");
                                return;
                        }
-                       break; */
+                       break;
+#endif
                default:
                        BKE_report(reports, RPT_ERROR, "This ID type is not compatible with any 'refresh' options");
                        return;
index bf9a21a87c67c6d16d06a2a1a898f4b5cb2d409c..2ccd7d293d3cb42c06e6fe8040556a24ed01e119 100644 (file)
@@ -1447,7 +1447,7 @@ static void rna_property_update(bContext *C, Main *bmain, Scene *scene, PointerR
        if (is_rna) {
                if (prop->update) {
                        /* ideally no context would be needed for update, but there's some
-                          parts of the code that need it still, so we have this exception */
+                        * parts of the code that need it still, so we have this exception */
                        if (prop->flag & PROP_CONTEXT_UPDATE) {
                                if (C) {
                                        if (prop->flag & PROP_CONTEXT_PROPERTY_UPDATE) {
@@ -2521,7 +2521,7 @@ PointerRNA RNA_property_pointer_get(PointerRNA *ptr, PropertyRNA *prop)
        }
        else if (prop->flag & PROP_IDPROPERTY) {
                /* XXX temporary hack to add it automatically, reading should
-                  never do any write ops, to ensure thread safety etc .. */
+                * never do any write ops, to ensure thread safety etc .. */
                RNA_property_pointer_add(ptr, prop);
                return RNA_property_pointer_get(ptr, prop);
        }
index a27ee0af8282415dd4d494efdf6d6f088c0c5ac0..202418205f36249111e8437b57bc5ec1ab0a1fce 100644 (file)
@@ -2694,7 +2694,7 @@ int rna_parameter_size(PropertyRNA *parm)
 }
 
 /* this function returns the size of the memory allocated for the parameter,
  useful for instance for memory alignment or for storing additional information */
* useful for instance for memory alignment or for storing additional information */
 int rna_parameter_size_alloc(PropertyRNA *parm)
 {
        int size = rna_parameter_size(parm);
index fafa3a72174b26c449dc042a72613fb508f99767..e9e7f58b6380f7512690b32ac10d6f37bdb844d0 100644 (file)
@@ -68,8 +68,8 @@ static char *rna_DynamicPaintSurface_path(PointerRNA *ptr)
 
 
 /*
-     Surfaces
-*/
+ *     Surfaces
+ */
 
 static void rna_DynamicPaint_redoModifier(Main *bmain, Scene *scene, PointerRNA *ptr)
 {
@@ -102,7 +102,7 @@ static void rna_DynamicPaintSurface_changePreview(Main *bmain, Scene *scene, Poi
        DynamicPaintSurface *surface = act_surface->canvas->surfaces.first;
 
        /* since only one color surface can show preview at time
-       *  disable preview on other surfaces*/
+        *  disable preview on other surfaces*/
        for (; surface; surface = surface->next) {
                if (surface != act_surface)
                        surface->flags &= ~MOD_DPAINT_PREVIEW;
@@ -316,7 +316,7 @@ static void rna_def_canvas_surface(BlenderRNA *brna)
                        {0, NULL, 0, NULL, NULL}};
 
        /*  Effect type
-       *   Only used by ui to view per effect settings */
+        *   Only used by ui to view per effect settings */
        static EnumPropertyItem prop_dynamicpaint_effecttype[] = {
                        {1, "SPREAD", 0, "Spread", ""},
                        {2, "DRIP", 0, "Drip", ""},
@@ -383,8 +383,8 @@ static void rna_def_canvas_surface(BlenderRNA *brna)
 
 
        /*
-       *   Paint, wet and displace
-       */
+        *   Paint, wet and displace
+        */
 
        prop = RNA_def_property(srna, "use_dissolve", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_DPAINT_DISSOLVE);
@@ -406,8 +406,8 @@ static void rna_def_canvas_surface(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Dry Speed", "Approximately in how many frames should drying happen");
        
        /*
-       *   Simulation settings
-       */
+        *   Simulation settings
+        */
        prop = RNA_def_property(srna, "image_resolution", PROP_INT, PROP_NONE);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_range(prop, 16.0, 4096.0);
@@ -462,8 +462,8 @@ static void rna_def_canvas_surface(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_OBJECT|ND_MODIFIER, "rna_DynamicPaint_redoModifier");
 
        /*
-             Initial Color
-       */
+        *      Initial Color
+        */
 
        prop = RNA_def_property(srna, "init_color_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
@@ -487,8 +487,8 @@ static void rna_def_canvas_surface(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING_DRAW|ND_MODIFIER, "rna_DynamicPaintSurface_reset");
 
        /*
-       *   Effect Settings
-       */
+        *   Effect Settings
+        */
        prop = RNA_def_property(srna, "effect_ui", PROP_ENUM, PROP_NONE);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_enum_items(prop, prop_dynamicpaint_effecttype);
@@ -562,8 +562,8 @@ static void rna_def_canvas_surface(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Acceleration", "How much surface acceleration affects dripping");
 
        /*
-       *   Output settings
-       */
+        *   Output settings
+        */
        prop = RNA_def_property(srna, "use_premultiply", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_DPAINT_MULALPHA);
@@ -691,8 +691,8 @@ static void rna_def_dynamic_paint_canvas_settings(BlenderRNA *brna)
        RNA_def_struct_path_func(srna, "rna_DynamicPaintCanvasSettings_path");
 
        /*
-             Surface Slots
-       */
+        *      Surface Slots
+        */
        prop = RNA_def_property(srna, "canvas_surfaces", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_collection_funcs(prop, "rna_DynamicPaint_surfaces_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", NULL, NULL, NULL, NULL);
        RNA_def_property_struct_type(prop, "DynamicPaintSurface");
@@ -739,8 +739,8 @@ static void rna_def_dynamic_paint_brush_settings(BlenderRNA *brna)
        RNA_def_struct_path_func(srna, "rna_DynamicPaintBrushSettings_path");
 
        /*
-       *   Paint
-       */
+        *   Paint
+        */
        prop = RNA_def_property(srna, "paint_color", PROP_FLOAT, PROP_COLOR_GAMMA);
        RNA_def_property_float_sdna(prop, NULL, "r");
        RNA_def_property_array(prop, 3);
@@ -878,8 +878,8 @@ static void rna_def_dynamic_paint_brush_settings(BlenderRNA *brna)
        
 
        /*
-       *   Particle
-       */
+        *   Particle
+        */
        prop = RNA_def_property(srna, "particle_system", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "psys");
        RNA_def_property_struct_type(prop, "ParticleSystem");
@@ -909,8 +909,8 @@ static void rna_def_dynamic_paint_brush_settings(BlenderRNA *brna)
        
 
        /*
-       * Color ramps
-       */
+        * Color ramps
+        */
        prop = RNA_def_property(srna, "paint_ramp", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "paint_ramp");
        RNA_def_property_struct_type(prop, "ColorRamp");
index 21cc97bd1c00dc6a04e54cbfa8c6151123774f70..fa8f9bf9d35c120e7f291f394dff847b7d743f4b 100644 (file)
@@ -253,13 +253,13 @@ static void rna_def_gpencil_layer(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
 
        /* expose as layers.active */
-       /*
+#if 0
        prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ACTIVE);
        RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencilLayer_active_set");
        RNA_def_property_ui_text(prop, "Active", "Set active layer for editing");
        RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
-       */
+#endif
 
        prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_SELECT);
index 54d258e2e729667abfb816a48dbdc54746a523aa..9e7ea1379d96a5cc34b292746496943122e4bfbd 100644 (file)
@@ -494,11 +494,13 @@ static void rna_def_keydata(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Handle 2 Location", "");
        RNA_def_property_update(prop, 0, "rna_Key_update_data");
 
-       /* appears to be unused currently
+       /* appears to be unused currently */
+#if 0
        prop= RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_tilt_get", "rna_ShapeKeyBezierPoint_tilt_set", NULL);
        RNA_def_property_ui_text(prop, "Tilt", "");
-       RNA_def_property_update(prop, 0, "rna_Key_update_data"); */
+       RNA_def_property_update(prop, 0, "rna_Key_update_data");
+#endif
 }
 
 static void rna_def_keyblock(BlenderRNA *brna)
index 51fd52360e4286075351817dab1aba0c99e44765..f33cf1a3993273dad43869281a5ed8949b8f40d8 100644 (file)
@@ -104,8 +104,8 @@ Mesh *rna_Object_to_mesh(Object *ob, ReportList *reports, Scene *sce, int apply_
                copycu = tmpobj->data = copy_curve( (Curve *) ob->data );
 
                /* temporarily set edit so we get updates from edit mode, but
-                  also because for text datablocks copying it while in edit
-                  mode gives invalid data structures */
+                * also because for text datablocks copying it while in edit
+                * mode gives invalid data structures */
                copycu->editfont = tmpcu->editfont;
                copycu->editnurb = tmpcu->editnurb;
 
@@ -279,8 +279,8 @@ static void dupli_render_particle_set(Scene *scene, Object *ob, int level, int e
 
                if (level == 0 && enable) {
                        /* this is to make sure we get render level duplis in groups:
-                       * the derivedmesh must be created before init_render_mesh,
-                       * since object_duplilist does dupliparticles before that */
+                        * the derivedmesh must be created before init_render_mesh,
+                        * since object_duplilist does dupliparticles before that */
                        dm = mesh_create_derived_render(scene, ob, CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL);
                        dm->release(dm);
 
index f48224884ba505e4eec63f5d4151a40be5412458..eea11aed803fdd1c8970c47d1eba78b06b58fb4f 100644 (file)
@@ -179,7 +179,7 @@ static int rna_Brush_mode_poll(PointerRNA *ptr, PointerRNA value)
        int mode = 0;
 
        /* check the origin of the Paint struct to see which paint
-          mode to select from */
+        * mode to select from */
 
        if (ptr->data == &ts->imapaint)
                mode = OB_MODE_TEXTURE_PAINT;
index 779a5720645dd05b3ee12b38568f410b30ce0ab8..d89af94d4475bf5823cb7dab484ec11d1477da9a 100644 (file)
@@ -2644,7 +2644,7 @@ static void rna_def_space_filebrowser(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Active Operator", "");
 
        /* keep this for compatibility with existing presets,
-          not exposed in c++ api because of keyword conflict */
+        * not exposed in c++ api because of keyword conflict */
        prop = RNA_def_property(srna, "operator", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "op");
        RNA_def_property_ui_text(prop, "Active Operator", "");
index cd9eec5abb6251199a3e08cb71bc4569601e8e4b..18d599ca283c71966ab1c5ba186f7d28ec8d3f69 100644 (file)
@@ -540,7 +540,7 @@ static void rna_Window_screen_update(bContext *C, PointerRNA *ptr)
        wmWindow *win = (wmWindow*)ptr->data;
 
        /* exception: can't set screens inside of area/region handers, and must
-          use context so notifier gets to the right window */
+        * use context so notifier gets to the right window */
        if (win->newscreen) {
                WM_event_add_notifier(C, NC_SCREEN|ND_SCREENBROWSE, win->newscreen);
                win->newscreen = NULL;
index 9eeffcc1488d2bc4f4d4bc8226d8b5c58e202772..2fbec392b1eb4657dacdc04a930e9322b07d8170 100644 (file)
@@ -66,8 +66,8 @@ static void initData(ModifierData *md)
        ArrayModifierData *amd = (ArrayModifierData*) md;
 
        /* default to 2 duplicates distributed along the x-axis by an
-       offset of 1 object-width
-       */
+        * offset of 1 object-width
+        */
        amd->start_cap = amd->end_cap = amd->curve_ob = amd->offset_ob = NULL;
        amd->count = 2;
        amd->offset[0] = amd->offset[1] = amd->offset[2] = 0;
@@ -264,14 +264,14 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
        }
 
        /* calculate the maximum number of copies which will fit within the
-       prescribed length */
+        * prescribed length */
        if(amd->fit_type == MOD_ARR_FITLENGTH
                  || amd->fit_type == MOD_ARR_FITCURVE) {
                float dist = sqrt(dot_v3v3(offset[3], offset[3]));
 
                if(dist > 1e-6f)
                        /* this gives length = first copy start to last copy end
-                       add a tiny offset for floating point rounding errors */
+                        * add a tiny offset for floating point rounding errors */
                        count = (length + 1e-6f) / dist;
                else
                        /* if the offset has no translation, just make one copy */
@@ -282,11 +282,11 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
                count = 1;
 
        /* BMESH_TODO: bumping up the stack level avoids computing the normals
-          after every top-level operator execution (and this modifier has the
-          potential to execute a *lot* of top-level BMOps. There should be a
-          cleaner way to do this. One possibility: a "mirror" BMOp would
-          certainly help by compressing it all into one top-level BMOp that
-          executes a lot of second-level BMOps. */
+        * after every top-level operator execution (and this modifier has the
+        * potential to execute a *lot* of top-level BMOps. There should be a
+        * cleaner way to do this. One possibility: a "mirror" BMOp would
+        * certainly help by compressing it all into one top-level BMOp that
+        * executes a lot of second-level BMOps. */
        BMO_push(em->bm, NULL);
        bmesh_edit_begin(em->bm, 0);
 
@@ -349,8 +349,8 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
                        BMO_op_finish(em->bm, &findop);
                }
 
-               /*generate merge mappping using index map.  we do this by using the
-                 operator slots as lookup arrays.*/
+               /* generate merge mappping using index map.  we do this by using the
+                * operator slots as lookup arrays.*/
                #define E(i) (i) < s1->len ? _E(s1, i) : _E(s2, (i)-s1->len)
 
                for (i=0; i<indexLen; i++) {
index 92584800f9853175da3f6427370239b84f73e353..3e11090970259a921b57a64c632a601282447086 100644 (file)
@@ -173,12 +173,14 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *UNUSED(ob),
 
        options = bmd->flags|bmd->val_flags|bmd->lim_flags|bmd->e_flags;
 
-       /*if ((options & BME_BEVEL_VWEIGHT) && bmd->defgrp_name[0]) {
+#if 0
+       if ((options & BME_BEVEL_VWEIGHT) && bmd->defgrp_name[0]) {
                defgrp_index = defgroup_name_index(ob, bmd->defgrp_name);
                if (defgrp_index < 0) {
                        options &= ~BME_BEVEL_VWEIGHT;
                }
-       }*/
+       }
+#endif
 
        bm = BME_derivedmesh_to_bmesh(derivedData);
        BME_bevel(bm,bmd->value,bmd->res,options,defgrp_index,bmd->bevel_angle,NULL);
index 72e5475449803bb3dcb2fa9dba0bf9183c9c7bd7..76560d14e3b47c512dd43cc32b1f20b233777f36 100644 (file)
@@ -133,8 +133,8 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
                DerivedMesh *result;
 
                /* when one of objects is empty (has got no faces) we could speed up
-                  calculation a bit returning one of objects' derived meshes (or empty one)
-                  Returning mesh is depended on modifieier's operation (sergey) */
+                * calculation a bit returning one of objects' derived meshes (or empty one)
+                * Returning mesh is depended on modifieier's operation (sergey) */
                result = get_quick_derivedMesh(derivedData, dm, bmd->operation);
 
                if(result == NULL) {
@@ -151,7 +151,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
                }
 
                /* if new mesh returned, return it; otherwise there was
-               * an error, so delete the modifier object */
+                * an error, so delete the modifier object */
                if(result)
                        return result;
                else
index 04b6bf33b1e69cb18bdc340c78d2fa2048819bab..3fd4119c9159fd909eab096169e24593e9bbf448 100644 (file)
@@ -333,7 +333,7 @@ static void InterpCSGFace(
 }
 
 /* Iterate over the CSG Output Descriptors and create a new DerivedMesh
  from them */
* from them */
 static DerivedMesh *ConvertCSGDescriptorsToDerivedMesh(
        CSG_FaceIteratorDescriptor *face_it,
        CSG_VertexIteratorDescriptor *vertex_it,
index 8e3617cf74e28d52aeb0c47eaea3ec71c12605f9..6ba4940a4e945a16aa06dae43cc801ac749e3970 100644 (file)
@@ -39,15 +39,15 @@ struct Base;
 struct DerivedMesh;
 
 /* Performs a boolean between two mesh objects, it is assumed that both objects
  are in fact a mesh object. On success returns 1 and creates a new mesh object
  into blender data structures. On failure returns 0 and reports an error. */
* are in fact a mesh object. On success returns 1 and creates a new mesh object
* into blender data structures. On failure returns 0 and reports an error. */
 int NewBooleanMesh(struct Scene *scene, struct Base *base, struct Base *base_select, int op);
 
 
 /* Performs a boolean between two mesh objects, it is assumed that both objects
  are in fact mesh object. On success returns a DerivedMesh. On failure
  returns NULL and reports an error. */
-   
* 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);
 
 #endif // MOD_BOOLEAN_UTILS
index b7f25f126cd26b4c1424cf2cbd3ad3468b302b11..a268f475bc80dbe099486dcc8555e0ada9ba62f8 100644 (file)
@@ -192,8 +192,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *UNUSED(ob),
                        }
                }
 
-               /* get the set of edges that will be in the new mesh
-               */
+               /* get the set of edges that will be in the new mesh */
                for (i = 0; i < numEdges_dst; i++) {
                        j = BLI_ghash_size(edgeHash);
                        
index 7de8a8f792384205bd18a61e67db6401a37c7736..6ca3a82dd0ecb9dd01416cbab3c476bc8f715992 100644 (file)
@@ -154,8 +154,8 @@ static void sphere_do(
        ctrl_ob = cmd->object;
 
        /* spherify's center is {0, 0, 0} (the ob's own center in its local
-       * space), by default, but if the user defined a control object,
-       * we use its location, transformed to ob's local space */
+        * space), by default, but if the user defined a control object,
+        * we use its location, transformed to ob's local space */
        if (ctrl_ob) {
                if(flag & MOD_CAST_USE_OB_TRANSFORM) {
                        invert_m4_m4(ctrl_ob->imat, ctrl_ob->obmat);
@@ -171,11 +171,11 @@ static void sphere_do(
 
        /* 1) (flag was checked in the "if (ctrl_ob)" block above) */
        /* 2) cmd->radius > 0.0f: only the vertices within this radius from
-       * the center of the effect should be deformed */
+        * the center of the effect should be deformed */
        if (cmd->radius > FLT_EPSILON) has_radius = 1;
 
        /* 3) if we were given a vertex group name,
-       * only those vertices should be affected */
+        * only those vertices should be affected */
        modifier_get_vgroup(ob, dm, cmd->defgrp_name, &dvert, &defgrp_index);
 
        if(flag & MOD_CAST_SIZE_FROM_RADIUS) {
@@ -195,10 +195,10 @@ static void sphere_do(
        }
 
        /* ready to apply the effect, one vertex at a time;
-       * tiny optimization: the code is separated (with parts repeated)
+        * tiny optimization: the code is separated (with parts repeated)
         * in two possible cases:
-       * with or w/o a vgroup. With lots of if's in the code below,
-       * further optimization's are possible, if needed */
+        * with or w/o a vgroup. With lots of if's in the code below,
+        * further optimization's are possible, if needed */
        if (dvert) { /* with a vgroup */
                MDeformVert *dv= dvert;
                float fac_orig = fac;
@@ -321,11 +321,11 @@ static void cuboid_do(
 
        /* 1) (flag was checked in the "if (ctrl_ob)" block above) */
        /* 2) cmd->radius > 0.0f: only the vertices within this radius from
-       * the center of the effect should be deformed */
+        * the center of the effect should be deformed */
        if (cmd->radius > FLT_EPSILON) has_radius = 1;
 
        /* 3) if we were given a vertex group name,
-       * only those vertices should be affected */
+        * only those vertices should be affected */
        modifier_get_vgroup(ob, dm, cmd->defgrp_name, &dvert, &defgrp_index);
 
        if (ctrl_ob) {
@@ -352,12 +352,12 @@ static void cuboid_do(
        } else {
                /* get bound box */
                /* We can't use the object's bound box because other modifiers
-               * may have changed the vertex data. */
+                * may have changed the vertex data. */
                INIT_MINMAX(min, max);
 
                /* Cast's center is the ob's own center in its local space,
-               * by default, but if the user defined a control object, we use
-               * its location, transformed to ob's local space. */
+                * by default, but if the user defined a control object, we use
+                * its location, transformed to ob's local space. */
                if (ctrl_ob) {
                        float vec[3];
 
@@ -393,10 +393,10 @@ static void cuboid_do(
        bb[4][2] = bb[5][2] = bb[6][2] = bb[7][2] = max[2];
 
        /* ready to apply the effect, one vertex at a time;
-       * tiny optimization: the code is separated (with parts repeated)
+        * tiny optimization: the code is separated (with parts repeated)
         * in two possible cases:
-       * with or w/o a vgroup. With lots of if's in the code below,
-       * further optimization's are possible, if needed */
+        * with or w/o a vgroup. With lots of if's in the code below,
+        * further optimization's are possible, if needed */
        if (dvert) { /* with a vgroup */
                float fac_orig = fac;
                for (i = 0; i < numVerts; i++) {
@@ -434,10 +434,10 @@ static void cuboid_do(
                        /* The algo used to project the vertices to their
                         * bounding box (bb) is pretty simple:
                         * for each vertex v:
-                       * 1) find in which octant v is in;
-                       * 2) find which outer "wall" of that octant is closer to v;
-                       * 3) calculate factor (var fbb) to project v to that wall;
-                       * 4) project. */
+                        * 1) find in which octant v is in;
+                        * 2) find which outer "wall" of that octant is closer to v;
+                        * 3) calculate factor (var fbb) to project v to that wall;
+                        * 4) project. */
 
                        /* find in which octant this vertex is in */
                        octant = 0;
@@ -471,7 +471,7 @@ static void cuboid_do(
                                continue;
 
                        /* finally, this is the factor we wanted, to project the vertex
-                       * to its bounding box (bb) */
+                        * to its bounding box (bb) */
                        fbb = apex[coord] / tmp_co[coord];
 
                        /* calculate the new vertex position */
index c9831959adb24fdfcedd7ee93507312e888453dd..481ab805c5a6cd9ef98f73926758d0f6fe821ee2 100644 (file)
@@ -115,8 +115,7 @@ static void initData(ModifierData *md)
 {
        EdgeSplitModifierData *emd = (EdgeSplitModifierData*) md;
 
-       /* default to 30-degree split angle, sharpness from both angle & flag
-       */
+       /* default to 30-degree split angle, sharpness from both angle & flag */
        emd->split_angle = 30;
        emd->flags = MOD_EDGESPLIT_FROMANGLE | MOD_EDGESPLIT_FROMFLAG;
 }
index e9563b55d4756ba1307216213e45401426bb64d5..42a6f74aba562b4036d3bb84e6103ec9cd77a206 100644 (file)
@@ -131,11 +131,11 @@ void fluidsim_init(FluidsimModifierData *fluidmd)
                fss->cpsQuality = 10.0; // 1.0 / 10.0 => means 0.1 width
                
                /*
-               BAD TODO: this is done in buttons_object.c in the moment 
-               Mesh *mesh = ob->data;
-               // calculate bounding box
-               fluid_get_bb(mesh->mvert, mesh->totvert, ob->obmat, fss->bbStart, fss->bbSize); 
-               */