svn merge ^/trunk/blender -r48415:48469
authorCampbell Barton <ideasman42@gmail.com>
Sun, 1 Jul 2012 15:39:02 +0000 (15:39 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sun, 1 Jul 2012 15:39:02 +0000 (15:39 +0000)
145 files changed:
CMakeLists.txt
build_files/scons/config/win32-vc-config.py
build_files/scons/config/win64-vc-config.py
build_files/scons/tools/btools.py
intern/ghost/GHOST_C-api.h
intern/ghost/GHOST_ISystem.h
intern/ghost/GHOST_IWindow.h
intern/ghost/intern/GHOST_C-api.cpp
intern/ghost/intern/GHOST_CallbackEventConsumer.cpp
intern/ghost/intern/GHOST_DisplayManagerCarbon.cpp
intern/ghost/intern/GHOST_DisplayManagerSDL.cpp
intern/ghost/intern/GHOST_DropTargetWin32.cpp
intern/ghost/intern/GHOST_EventManager.cpp
intern/ghost/intern/GHOST_ISystem.cpp
intern/ghost/intern/GHOST_ISystemPaths.cpp
intern/ghost/intern/GHOST_ModifierKeys.cpp
intern/ghost/intern/GHOST_System.h
intern/ghost/intern/GHOST_SystemCarbon.cpp
intern/ghost/intern/GHOST_SystemCocoa.h
intern/ghost/intern/GHOST_SystemPaths.h
intern/ghost/intern/GHOST_SystemWin32.cpp
intern/ghost/intern/GHOST_SystemX11.cpp
intern/ghost/intern/GHOST_TimerManager.cpp
intern/ghost/intern/GHOST_WindowCarbon.cpp
intern/ghost/intern/GHOST_WindowManager.cpp
intern/ghost/intern/GHOST_WindowWin32.cpp
intern/ghost/intern/GHOST_WindowX11.cpp
intern/ghost/test/gears/GHOST_C-Test.c
intern/ghost/test/gears/GHOST_Test.cpp
intern/string/STR_String.h
intern/string/intern/STR_String.cpp
intern/utfconv/utf_winfunc.c
release/scripts/modules/bpy_extras/view3d_utils.py
release/scripts/templates/operator_file_export.py
release/scripts/templates/operator_file_import.py
release/scripts/templates/operator_mesh_add.py
release/scripts/templates/operator_modal.py
release/scripts/templates/operator_modal_draw.py
release/scripts/templates/operator_modal_timer.py
release/scripts/templates/operator_modal_view3d.py
release/scripts/templates/operator_modal_view3d_raycast.py [new file with mode: 0644]
release/scripts/templates/operator_node.py
release/scripts/templates/operator_simple.py
release/scripts/templates/operator_uv.py
source/SConscript
source/blender/CMakeLists.txt
source/blender/SConscript
source/blender/blenkernel/intern/fcurve.c
source/blender/blenkernel/intern/key.c
source/blender/blenlib/intern/freetypefont.c
source/blender/blenlib/intern/math_geom.c
source/blender/blenlib/intern/path_util.c
source/blender/blenlib/intern/scanfill.c
source/blender/blenlib/intern/threads.c
source/blender/blenlib/intern/time.c
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/versioning_250.c
source/blender/blenloader/intern/writefile.c
source/blender/bmesh/intern/bmesh_mesh.c
source/blender/bmesh/intern/bmesh_opdefines.c
source/blender/bmesh/intern/bmesh_operator_api.h
source/blender/bmesh/intern/bmesh_operator_api_inline.h
source/blender/bmesh/intern/bmesh_operators.c
source/blender/bmesh/intern/bmesh_operators_private.h
source/blender/bmesh/operators/bmo_bevel.c
source/blender/bmesh/operators/bmo_connect.c
source/blender/bmesh/operators/bmo_dissolve.c
source/blender/bmesh/operators/bmo_dupe.c
source/blender/bmesh/operators/bmo_edgesplit.c
source/blender/bmesh/operators/bmo_extrude.c
source/blender/bmesh/operators/bmo_hull.c
source/blender/bmesh/operators/bmo_mirror.c
source/blender/bmesh/operators/bmo_primitive.c
source/blender/bmesh/operators/bmo_removedoubles.c
source/blender/bmesh/operators/bmo_slide.c
source/blender/bmesh/operators/bmo_subdivide.c
source/blender/bmesh/operators/bmo_utils.c
source/blender/compositor/COM_compositor.h
source/blender/compositor/intern/COM_Converter.h
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
source/blender/compositor/operations/COM_GlareFogGlowOperation.cpp
source/blender/compositor/operations/COM_KeyingClipOperation.h
source/blender/compositor/operations/COM_KeyingDespillOperation.h
source/blender/compositor/operations/COM_KeyingOperation.h
source/blender/editors/mesh/editmesh_knife.c
source/blender/editors/mesh/editmesh_rip.c
source/blender/editors/mesh/editmesh_select.c
source/blender/editors/mesh/editmesh_slide.c
source/blender/editors/mesh/editmesh_tools.c
source/blender/editors/mesh/editmesh_utils.c
source/blender/editors/object/object_modifier.c
source/blender/editors/object/object_select.c
source/blender/editors/sculpt_paint/sculpt.c
source/blender/editors/space_node/node_templates.c
source/blender/editors/space_node/space_node.c
source/blender/editors/transform/transform.c
source/blender/editors/transform/transform_constraints.c
source/blender/gpu/CMakeLists.txt
source/blender/gpu/GPU_draw.h
source/blender/gpu/SConscript
source/blender/gpu/intern/gpu_draw.c
source/blender/ikplugin/intern/iksolver_plugin.c
source/blender/ikplugin/intern/itasc_plugin.cpp
source/blender/imbuf/IMB_imbuf_types.h
source/blender/imbuf/intern/allocimbuf.c
source/blender/imbuf/intern/dds/DirectDrawSurface.cpp
source/blender/imbuf/intern/dds/DirectDrawSurface.h
source/blender/imbuf/intern/dds/dds_api.cpp
source/blender/imbuf/intern/indexer.c
source/blender/makesdna/DNA_meshdata_types.h
source/blender/modifiers/intern/MOD_array.c
source/blender/modifiers/intern/MOD_edgesplit.c
source/blender/modifiers/intern/MOD_skin.c
source/blender/nodes/CMakeLists.txt
source/blender/nodes/SConscript
source/blender/nodes/composite/node_composite_tree.c
source/blender/nodes/composite/node_composite_util.c
source/blender/nodes/composite/nodes/node_composite_bilateralblur.c
source/blender/nodes/composite/nodes/node_composite_blur.c
source/blender/nodes/composite/nodes/node_composite_chromaMatte.c
source/blender/nodes/composite/nodes/node_composite_diffMatte.c
source/blender/nodes/composite/nodes/node_composite_displace.c
source/blender/nodes/composite/nodes/node_composite_distanceMatte.c
source/blender/nodes/composite/nodes/node_composite_image.c
source/blender/nodes/composite/nodes/node_composite_levels.c
source/blender/nodes/texture/node_texture_tree.c
source/blender/nodes/texture/node_texture_util.c
source/blender/nodes/texture/node_texture_util.h
source/blender/nodes/texture/nodes/node_texture_proc.c
source/blender/opencl/CMakeLists.txt
source/blender/python/bmesh/bmesh_py_api.c
source/blender/python/bmesh/bmesh_py_ops.c
source/blender/render/intern/source/convertblender.c
source/creator/CMakeLists.txt
source/creator/SConscript [deleted file]
source/gameengine/Expressions/Value.cpp
source/gameengine/GameLogic/SCA_IInputDevice.h
source/gameengine/GameLogic/SCA_LogicManager.cpp
source/gameengine/GameLogic/SCA_PropertySensor.cpp
source/gameengine/GameLogic/SCA_PythonController.cpp
source/gameengine/GamePlayer/common/GPC_Canvas.h
source/gameengine/Ketsji/BL_Texture.cpp
source/gameengine/Ketsji/BL_Texture.h
source/gameengine/Ketsji/CMakeLists.txt
source/gameengine/Physics/Dummy/DummyPhysicsEnvironment.h

index 72a5ebcfb1cec52353940679d3023fa315c41aff..fb2afb723e6a91c17ea1fde4d14a5cc37c82920e 100644 (file)
@@ -131,6 +131,7 @@ option(WITH_BULLET        "Enable Bullet (Physics Engine)" ON)
 option(WITH_GAMEENGINE    "Enable Game Engine" ON)
 option(WITH_PLAYER        "Build Player" OFF)
 option(WITH_OPENCOLORIO   "Enable OpenColorIO color management" ON)
+option(WITH_COMPOSITOR    "Enable the tile based nodal compositor" ON)
 
 # GHOST Windowing Library Options
 option(WITH_GHOST_DEBUG   "Enable debugging output for the GHOST library" OFF)
@@ -667,7 +668,6 @@ if(UNIX AND NOT APPLE)
 
                if(NOT OPENIMAGEIO_FOUND)
                        set(WITH_OPENIMAGEIO OFF)
-                       set(WITH_CYCLES OFF)
                        message(STATUS "OpenImageIO not found, disabling WITH_CYCLES")
                endif()
        endif()
@@ -1012,8 +1012,8 @@ elseif(WIN32)
                                set(BOOST_POSTFIX "vc100-mt-s-1_47.lib")
                                set(BOOST_DEBUG_POSTFIX "vc100-mt-sgd-1_47.lib")
                        else()
-                               set(BOOST_POSTFIX "vc90-mt-s-1_47.lib")
-                               set(BOOST_DEBUG_POSTFIX "vc90-mt-sgd-1_47.lib")                                 
+                               set(BOOST_POSTFIX "vc90-mt-s-1_49.lib")
+                               set(BOOST_DEBUG_POSTFIX "vc90-mt-sgd-1_49.lib")                                 
                        endif()
                        set(BOOST_LIBRARIES
                                optimized libboost_date_time-${BOOST_POSTFIX} optimized libboost_filesystem-${BOOST_POSTFIX}
@@ -1500,6 +1500,16 @@ if(APPLE OR WIN32)
        endif()
 endif()
 
+if(WITH_CYCLES)
+       if(NOT WITH_OPENIMAGEIO)
+               message(FATAL_ERROR "Cycles reqires WITH_OPENIMAGEIO, the library may not have been found. Configure OIIO or disable WITH_CYCLES")
+       endif()
+       if(NOT WITH_BOOST)
+               message(FATAL_ERROR "Cycles reqires WITH_BOOST, the library may not have been found. Configure BOOST or disable WITH_CYCLES")
+       endif()
+endif()
+
+
 # See TEST_SSE_SUPPORT() for how this is defined.
 
 if(WITH_RAYOPTIMIZATION)
index 10f473f81e08c343c75a5a01a189c708cc97e94d..00d77ec3246ad309c4622ba03d656f2808448195 100644 (file)
@@ -165,7 +165,7 @@ BF_OCIO_LIBPATH = '${BF_OCIO}/lib'
 WITH_BF_BOOST = True
 BF_BOOST = '${LIBDIR}/boost'
 BF_BOOST_INC = '${BF_BOOST}/include'
-BF_BOOST_LIB = 'libboost_date_time-vc90-mt-s-1_47 libboost_filesystem-vc90-mt-s-1_47 libboost_regex-vc90-mt-s-1_47 libboost_system-vc90-mt-s-1_47 libboost_thread-vc90-mt-s-1_47'
+BF_BOOST_LIB = 'libboost_date_time-vc90-mt-s-1_49 libboost_filesystem-vc90-mt-s-1_49 libboost_regex-vc90-mt-s-1_49 libboost_system-vc90-mt-s-1_49 libboost_thread-vc90-mt-s-1_49'
 BF_BOOST_LIBPATH = '${BF_BOOST}/lib'
 
 #CUDA
index 604d8b8f7659d09177da66c7f8e7387997d34c1a..bdeca1db0f9248c19e66ea0ee499d123acb43ceb 100644 (file)
@@ -163,7 +163,7 @@ BF_OCIO_LIBPATH = '${BF_OCIO}/lib'
 WITH_BF_BOOST = True
 BF_BOOST = '${LIBDIR}/boost'
 BF_BOOST_INC = '${BF_BOOST}/include'
-BF_BOOST_LIB = 'libboost_date_time-vc90-mt-s-1_47 libboost_filesystem-vc90-mt-s-1_47 libboost_regex-vc90-mt-s-1_47 libboost_system-vc90-mt-s-1_47 libboost_thread-vc90-mt-s-1_47'
+BF_BOOST_LIB = 'libboost_date_time-vc90-mt-s-1_49 libboost_filesystem-vc90-mt-s-1_49 libboost_regex-vc90-mt-s-1_49 libboost_system-vc90-mt-s-1_49 libboost_thread-vc90-mt-s-1_49'
 BF_BOOST_LIBPATH = '${BF_BOOST}/lib'
 
 #CUDA
index b1467bc6f2f891cd6794f3150df3b03c87532749..a7d4aa0d3e1ea67002c3c61ef82011a86499c41b 100644 (file)
@@ -108,6 +108,7 @@ def validate_arguments(args, bc):
             'WITH_BF_STATICFFMPEG', 'BF_FFMPEG_LIB_STATIC',
             'WITH_BF_OGG', 'BF_OGG', 'BF_OGG_LIB',
             'WITH_BF_FRAMESERVER',
+            'WITH_BF_COMPOSITOR',
             'WITH_BF_JPEG', 'BF_JPEG', 'BF_JPEG_INC', 'BF_JPEG_LIB', 'BF_JPEG_LIBPATH',
             'WITH_BF_OPENJPEG', 'BF_OPENJPEG', 'BF_OPENJPEG_INC', 'BF_OPENJPEG_LIB', 'BF_OPENJPEG_LIBPATH',
             'WITH_BF_REDCODE', 'BF_REDCODE', 'BF_REDCODE_INC', 'BF_REDCODE_LIB', 'BF_REDCODE_LIBPATH',
@@ -532,6 +533,8 @@ def read_opts(env, cfg, args):
         (BoolVariable('WITH_BF_CARVE', 'Enable carve library for mesh boolean operations', True)),
         
         (BoolVariable('WITH_BF_LIBMV', 'Enable libmv structure from motion library', True)),
+        
+        (BoolVariable('WITH_BF_COMPOSITOR', 'Enable the tile based nodal compositor', True)),
 
         ('BF_X264_CONFIG', 'configuration flags for x264', ''),
         ('BF_XVIDCORE_CONFIG', 'configuration flags for xvidcore', ''),
index 7f33f2bdcde31336b251f4d239ab4e9eef276d5b..764df79230d09b71280b41078dc3f8eeebca3fbd 100644 (file)
@@ -128,8 +128,8 @@ extern GHOST_TSuccess GHOST_RemoveTimer(GHOST_SystemHandle systemhandle,
                                         GHOST_TimerTaskHandle timertaskhandle);
 
 /***************************************************************************************
-** Display/window management functionality
-***************************************************************************************/
+ * Display/window management functionality
+ ***************************************************************************************/
 
 /**
  * Returns the number of displays on this system.
@@ -235,8 +235,8 @@ extern GHOST_TSuccess GHOST_EndFullScreen(GHOST_SystemHandle systemhandle);
 extern int GHOST_GetFullScreen(GHOST_SystemHandle systemhandle);
 
 /***************************************************************************************
-** Event management functionality
-***************************************************************************************/
+ * Event management functionality
+ ***************************************************************************************/
 
 /**
  * Retrieves events from the system and stores them in the queue.
@@ -273,8 +273,8 @@ extern GHOST_TSuccess GHOST_RemoveEventConsumer(GHOST_SystemHandle systemhandle,
                                                 GHOST_EventConsumerHandle consumerhandle);
 
 /***************************************************************************************
-** Progress bar functionality
-***************************************************************************************/
+ * Progress bar functionality
+ ***************************************************************************************/
 
 /**
  * Sets the progress bar value displayed in the window/application icon
@@ -290,8 +290,8 @@ extern GHOST_TSuccess GHOST_SetProgressBar(GHOST_WindowHandle windowhandle, floa
 extern GHOST_TSuccess GHOST_EndProgressBar(GHOST_WindowHandle windowhandle);
 
 /***************************************************************************************
-** Cursor management functionality
-***************************************************************************************/
+ * Cursor management functionality
+ ***************************************************************************************/
 
 /**
  * Returns the current cursor shape.
@@ -394,8 +394,8 @@ extern GHOST_TSuccess GHOST_SetCursorGrab(GHOST_WindowHandle windowhandle,
                                           int *bounds);
 
 /***************************************************************************************
-** Access to mouse button and keyboard states.
-***************************************************************************************/
+ * Access to mouse button and keyboard states.
+ ***************************************************************************************/
 
 /**
  * Returns the state of a modifier key (ouside the message queue).
@@ -421,8 +421,8 @@ extern GHOST_TSuccess GHOST_GetButtonState(GHOST_SystemHandle systemhandle,
 
 
 /***************************************************************************************
-** Drag'n'drop operations
-***************************************************************************************/
+ * Drag'n'drop operations
+ ***************************************************************************************/
 
 /**
  * Tells if the ongoing drag'n'drop object can be accepted upon mouse drop
index 0bc09077f391735a3eb496b2a6980aa4367509de..474e3e97c452e648542365cd593f6e9076eecc65 100644 (file)
@@ -177,8 +177,8 @@ protected:
 
 public:
        /***************************************************************************************
-       ** Time(r) functionality
-       ***************************************************************************************/
+        * Time(r) functionality
+        ***************************************************************************************/
 
        /**
         * Returns the system time.
@@ -211,8 +211,8 @@ public:
        virtual GHOST_TSuccess removeTimer(GHOST_ITimerTask *timerTask) = 0;
 
        /***************************************************************************************
-       ** Display/window management functionality
-       ***************************************************************************************/
+        * Display/window management functionality
+        ***************************************************************************************/
 
        /**
         * Returns the number of displays on this system.
@@ -296,8 +296,8 @@ public:
        virtual bool getFullScreen(void) = 0;
 
        /***************************************************************************************
-       ** Event management functionality
-       ***************************************************************************************/
+        * Event management functionality
+        ***************************************************************************************/
 
        /**
         * Retrieves events from the system and stores them in the queue.
@@ -327,8 +327,8 @@ public:
        virtual GHOST_TSuccess removeEventConsumer(GHOST_IEventConsumer *consumer) = 0;
 
        /***************************************************************************************
-       ** Cursor management functionality
-       ***************************************************************************************/
+        * Cursor management functionality
+        ***************************************************************************************/
 
        /**
         * Returns the current location of the cursor (location in screen coordinates)
@@ -348,8 +348,8 @@ public:
        virtual GHOST_TSuccess setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y) = 0;
 
        /***************************************************************************************
-       ** Access to mouse button and keyboard states.
-       ***************************************************************************************/
+        * Access to mouse button and keyboard states.
+        ***************************************************************************************/
 
        /**
         * Returns the state of a modifier key (ouside the message queue).
@@ -379,8 +379,8 @@ public:
        virtual int toggleConsole(int action) = 0;
        
        /***************************************************************************************
-       ** Access to clipboard.
-       ***************************************************************************************/
+        * Access to clipboard.
+        ***************************************************************************************/
        
        /**
         * Returns the selection buffer
index 69aaeeb4b2e1c5382c2ff8d47c328f83cbbb37da..5005718e4a5df5758df52232ffd383978e061f47 100644 (file)
@@ -235,8 +235,8 @@ public:
        virtual const GHOST_TabletData *GetTabletData() = 0;
        
        /***************************************************************************************
-       ** Progress bar functionality
-       ***************************************************************************************/
+        * Progress bar functionality
+        ***************************************************************************************/
        
        /**
         * Sets the progress bar value displayed in the window/application icon
@@ -250,8 +250,8 @@ public:
        virtual GHOST_TSuccess endProgressBar() = 0;
        
        /***************************************************************************************
-       ** Cursor management functionality
-       ***************************************************************************************/
+        * Cursor management functionality
+        ***************************************************************************************/
 
        /**
         * Returns the current cursor shape.
index ad43798bc6009951c780db539639f07332e78ca5..4cdd9384eeef73dea3de75ba75a1ada2c3851a10 100644 (file)
 
 /** \file ghost/intern/GHOST_C-api.cpp
  *  \ingroup GHOST
- */
-
-
-/*
-
- * GHOST_C-Api.cpp
  *
  * C Api for GHOST
- *
  */
 
 #include <stdlib.h>
index 2e602f33b4346a965aecd8bbb98a95776ac9df2d..47121562604d253754805581455a0290d481c5d4 100644 (file)
@@ -31,7 +31,6 @@
 
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * @author     Maarten Gribnau
  * @date       October 25, 2001
index 7752ae8cbc0f15f3a0ce0877874ab169bebc2f0c..21798ed2d0a11c8a4b3131575f0e8293be4d1c43 100644 (file)
@@ -31,7 +31,6 @@
 
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * @author     Maarten Gribnau
  * @date       September 21, 2001
index fbfbce264a52479edc928eca58ccffae657e787d..86f0380c8d64b9803abf28bbfd62ce94c2b0063f 100644 (file)
@@ -177,7 +177,7 @@ GHOST_DisplayManagerSDL:: setCurrentDisplaySetting(GHOST_TUns8 display,
        }
        else {
                /* this is a problem for the BGE player :S, perhaps SDL2 will resolve at some point.
-               * we really need SDL_SetDisplayModeForDisplay() to become an API func! - campbell */
+                * we really need SDL_SetDisplayModeForDisplay() to become an API func! - campbell */
                printf("no windows available, cant fullscreen");
 
                /* do not fail, we will try again later when the window is created - wander */
index 0f07435d417a0cd9c9ecb32056d1a335308144ac..4142b19f21dfa65c06da26c3e71aa2dc0b675d85 100644 (file)
@@ -136,7 +136,7 @@ HRESULT __stdcall GHOST_DropTargetWin32::DragOver(DWORD grfKeyState, POINTL pt,
        }
        else {
                *pdwEffect = DROPEFFECT_NONE;
-               //*pdwEffect = DROPEFFECT_COPY; // XXX Uncomment to test drop. Drop will not be called if pdwEffect == DROPEFFECT_NONE.
+               // *pdwEffect = DROPEFFECT_COPY; // XXX Uncomment to test drop. Drop will not be called if pdwEffect == DROPEFFECT_NONE.
        }
        m_system->pushDragDropEvent(GHOST_kEventDraggingUpdated, m_draggedObjectType, m_window, pt.x, pt.y, NULL);
        return S_OK;
index 4c03dad2e73e74e75e56b5b5ad10b9cfab59256e..33e0afb797a5af2aadb6477931ef4be21b40f34e 100644 (file)
@@ -31,7 +31,6 @@
 
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * @author     Maarten Gribnau
  * @date       May 14, 2001
index e983bd8214a9b77a476fe840627d84784193f07b..fe1132e7996708d5435d7097a1924513ba202268 100644 (file)
@@ -31,7 +31,6 @@
 
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * @author     Maarten Gribnau
  * @date       May 7, 2001
index 0ad9dd48d2bbcce3aa3373e9acdbe3908233cd99..f84c50770f0abff6a0ea97a72aee027d0f8081f4 100644 (file)
@@ -31,7 +31,6 @@
 
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * @author     Maarten Gribnau
  * @date       May 7, 2001
index a02e621889121fe8ba2d17b10571d044cdeeb591..ffc7a09e4ddf16bc540167900c929fcb0f83a2a6 100644 (file)
@@ -31,7 +31,6 @@
 
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * @author     Maarten Gribnau
  * @date       May 31, 2001
index b25f24e653c242668210ed9a52ead29a6d12ea0c..de475c79f431099a095a16fc6f90f98b9632b017 100644 (file)
@@ -76,8 +76,8 @@ protected:
 
 public:
        /***************************************************************************************
-       ** Time(r) functionality
-       ***************************************************************************************/
+        * Time(r) functionality
+        ***************************************************************************************/
 
        /**
         * Returns the system time.
@@ -110,8 +110,8 @@ public:
        virtual GHOST_TSuccess removeTimer(GHOST_ITimerTask *timerTask);
 
        /***************************************************************************************
-       ** Display/window management functionality
-       ***************************************************************************************/
+        * Display/window management functionality
+        ***************************************************************************************/
        
        /**
         * Inherited from GHOST_ISystem but left pure virtual
@@ -169,8 +169,8 @@ public:
 
 
        /***************************************************************************************
-       ** Event management functionality
-       ***************************************************************************************/
+        * Event management functionality
+        ***************************************************************************************/
 
        /**
         * Inherited from GHOST_ISystem but left pure virtual
@@ -202,8 +202,8 @@ public:
        virtual GHOST_TSuccess removeEventConsumer(GHOST_IEventConsumer *consumer);
 
        /***************************************************************************************
-       ** Cursor management functionality
-       ***************************************************************************************/
+        * Cursor management functionality
+        ***************************************************************************************/
 
        /** Inherited from GHOST_ISystem but left pure virtual
         *      GHOST_TSuccess getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const = 0;   
@@ -211,8 +211,8 @@ public:
         */
 
        /***************************************************************************************
-       ** Access to mouse button and keyboard states.
-       ***************************************************************************************/
+        * Access to mouse button and keyboard states.
+        ***************************************************************************************/
 
        /**
         * Returns the state of a modifier key (ouside the message queue).
@@ -231,8 +231,8 @@ public:
        virtual GHOST_TSuccess getButtonState(GHOST_TButtonMask mask, bool& isDown) const;
        
        /***************************************************************************************
-       ** Other (internal) functionality.
-       ***************************************************************************************/
+        * Other (internal) functionality.
+        ***************************************************************************************/
 
        /**
         * Pushes an event on the stack.
index 1e53e7f42917c9b1858cb121dc7818b1b6147889..ffb8388543bfef54a1ebd7c229b7515718b687f6 100644 (file)
@@ -31,7 +31,6 @@
 
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * @author     Maarten Gribnau
  * @date       May 7, 2001
@@ -70,10 +69,10 @@ enum {
 const EventTypeSpec kEvents[] =
 {
        { kEventClassAppleEvent, kEventAppleEvent },
-/*
-    { kEventClassApplication, kEventAppActivated },
-    { kEventClassApplication, kEventAppDeactivated },
- */
+#if 0
+       { kEventClassApplication, kEventAppActivated },
+       { kEventClassApplication, kEventAppDeactivated },
+ #endif
        { kEventClassKeyboard, kEventRawKeyDown },
        { kEventClassKeyboard, kEventRawKeyRepeat },
        { kEventClassKeyboard, kEventRawKeyUp },
@@ -994,7 +993,7 @@ bool GHOST_SystemCarbon::handleMouseDown(EventRef event)
                         * @see GHOST_SystemCarbon::handleWindowEvent(EventRef event)
                         */
                        /* even worse: scale window also generates a load of events, and nothing 
-                          is handled (read: client's event proc called) until you release mouse (ton) */
+                        * is handled (read: client's event proc called) until you release mouse (ton) */
                        
                        GHOST_ASSERT(validWindow(ghostWindow), "GHOST_SystemCarbon::handleMouseDown: invalid window");
                        m_ignoreWindowSizedMessages = true;
index 47a7a6a9a7389e425d739502162efb572ed69d48..cb4e9fe3c99da700b8484169b8a40fa9dca90fa8 100644 (file)
@@ -62,8 +62,8 @@ public:
        ~GHOST_SystemCocoa();
 
        /***************************************************************************************
-       ** Time(r) functionality
-       ***************************************************************************************/
+        * Time(r) functionality
+        ***************************************************************************************/
 
        /**
         * Returns the system time.
@@ -74,8 +74,8 @@ public:
        virtual GHOST_TUns64 getMilliSeconds() const;
 
        /***************************************************************************************
-       ** Display/window management functionality
-       ***************************************************************************************/
+        * Display/window management functionality
+        ***************************************************************************************/
 
        /**
         * Returns the number of displays on this system.
@@ -119,8 +119,8 @@ public:
            );
        
        /***************************************************************************************
-       ** Event management functionality
-       ***************************************************************************************/
+        * Event management functionality
+        ***************************************************************************************/
 
        /**
         * Gets events from the system and stores them in the queue.
@@ -154,8 +154,8 @@ public:
                                           GHOST_WindowCocoa *window, int mouseX, int mouseY, void *data);
        
        /***************************************************************************************
-       ** Cursor management functionality
-       ***************************************************************************************/
+        * Cursor management functionality
+        ***************************************************************************************/
 
        /**
         * Returns the current location of the cursor (location in screen coordinates)
@@ -174,8 +174,8 @@ public:
        virtual GHOST_TSuccess setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y);
        
        /***************************************************************************************
-       ** Access to mouse button and keyboard states.
-       ***************************************************************************************/
+        * Access to mouse button and keyboard states.
+        ***************************************************************************************/
 
        /**
         * Returns the state of all modifier keys.
index f53d4f4a7b77fc5a6ac6c8027856888d28605a8e..fe0fae71955ad254a1ecb002e0e9171bc84cbd9b 100644 (file)
@@ -58,10 +58,10 @@ public:
        virtual const GHOST_TUns8 *getSystemDir(int version, const char *versionstr) const = 0;
 
        /**
-         * Determine the base dir in which user configuration is stored, including versioning.
-         * If needed, it will create the base directory.
-         * @return Unsigned char string pointing to user dir (eg ~/.blender/).
-         */
+        * Determine the base dir in which user configuration is stored, including versioning.
+        * If needed, it will create the base directory.
+        * @return Unsigned char string pointing to user dir (eg ~/.blender/).
+        */
        virtual const GHOST_TUns8 *getUserDir(int version, const char *versionstr) const = 0;
 
        /**
index c2456fed800db018bf9179507969313c99abc525..6c201c24c3d9f36087b065ef1b53abd338000beb 100644 (file)
@@ -1093,7 +1093,7 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, UINT msg, WPARAM wParam,
                                        system->storeModifierKeys(modifiers);
                                        event = processWindowEvent(LOWORD(wParam) ? GHOST_kEventWindowActivate : GHOST_kEventWindowDeactivate, window);
                                        /* WARNING: Let DefWindowProc handle WM_ACTIVATE, otherwise WM_MOUSEWHEEL
-                                          will not be dispatched to OUR active window if we minimize one of OUR windows. */
+                                        * will not be dispatched to OUR active window if we minimize one of OUR windows. */
                                        lResult = ::DefWindowProc(hwnd, msg, wParam, lParam);
                                        break;
                                }
@@ -1230,11 +1230,11 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, UINT msg, WPARAM wParam,
                        // Event found for a window before the pointer to the class has been set.
                        GHOST_PRINT("GHOST_SystemWin32::wndProc: GHOST window event before creation\n");
                        /* These are events we typically miss at this point:
-                          WM_GETMINMAXINFO     0x24
-                          WM_NCCREATE                  0x81
-                          WM_NCCALCSIZE                0x83
-                          WM_CREATE                    0x01
-                          We let DefWindowProc do the work.
+                        * WM_GETMINMAXINFO     0x24
+                        * WM_NCCREATE                  0x81
+                        * WM_NCCALCSIZE                0x83
+                        * WM_CREATE                    0x01
+                        * We let DefWindowProc do the work.
                         */
                }
        }
@@ -1274,7 +1274,7 @@ GHOST_TUns8 *GHOST_SystemWin32::getClipboard(bool selection) const
                temp_buff = alloc_utf_8_from_16(buffer, 0);
                
                /* Buffer mustn't be accessed after CloseClipboard
-                  it would like accessing free-d memory */
+                * it would like accessing free-d memory */
                GlobalUnlock(hData);
                CloseClipboard();
                
@@ -1300,7 +1300,7 @@ GHOST_TUns8 *GHOST_SystemWin32::getClipboard(bool selection) const
                temp_buff[len] = '\0';
                
                /* Buffer mustn't be accessed after CloseClipboard
-                  it would like accessing free-d memory */
+                * it would like accessing free-d memory */
                GlobalUnlock(hData);
                CloseClipboard();
                
index c58ed93425d157ed08147eacf0160684180de61e..2d8f5e7890ca5d90ad46262fc40974d5dd66fc6b 100644 (file)
@@ -566,7 +566,7 @@ GHOST_SystemX11::processEvent(XEvent *xe)
                                }
                                else if (status == XLookupKeySym) {
                                        /* this key doesn't have a text representation, it is a command
-                                          key of some sort */;
+                                        * key of some sort */;
                                }
                                else {
                                        printf("Bad keycode lookup. Keysym 0x%x Status: %s\n",
@@ -745,11 +745,11 @@ GHOST_SystemX11::processEvent(XEvent *xe)
                case LeaveNotify:
                {
                        /* XCrossingEvents pointer leave enter window.
-                          also do cursor move here, MotionNotify only
-                          happens when motion starts & ends inside window.
-                          we only do moves when the crossing mode is 'normal'
-                          (really crossing between windows) since some windowmanagers
-                          also send grab/ungrab crossings for mousewheel events.
+                        * also do cursor move here, MotionNotify only
+                        * happens when motion starts & ends inside window.
+                        * we only do moves when the crossing mode is 'normal'
+                        * (really crossing between windows) since some windowmanagers
+                        * also send grab/ungrab crossings for mousewheel events.
                         */
                        XCrossingEvent &xce = xe->xcrossing;
                        if (xce.mode == NotifyNormal) {
@@ -1077,15 +1077,15 @@ convertXKey(KeySym key)
                type = GHOST_TKey(key - XK_F1 + int(GHOST_kKeyF1));
 #if defined(__sun) || defined(__sun__) 
                /* This is a bit of a hack, but it looks like sun
-                  Used F11 and friends for its special keys Stop,again etc..
-                  So this little patch enables F11 and F12 to work as expected
-                  following link has documentation on it: 
-                  http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4734408
-                  also from /usr/include/X11/Sunkeysym.h 
-                  #define SunXK_F36               0x1005FF10      // Labeled F11
-                  #define SunXK_F37               0x1005FF11      // Labeled F12
-
-                       mein@cs.umn.edu
+                * Used F11 and friends for its special keys Stop,again etc..
+                * So this little patch enables F11 and F12 to work as expected
+                * following link has documentation on it:
+                * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4734408
+                * also from /usr/include/X11/Sunkeysym.h
+                * #define SunXK_F36               0x1005FF10      // Labeled F11
+                * #define SunXK_F37               0x1005FF11      // Labeled F12
+                *
+                *      mein@cs.umn.edu
                 */
                
        }
index 4780a4a0d4488a805bf262f34cb5a892da9cc6bf..4ad28d6633d7072cfa481dc10478a36d2a74c550 100644 (file)
@@ -31,7 +31,6 @@
 
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * @author     Maarten Gribnau
  * @date       May 31, 2001
index d67b02fce6babe57f731fa3983024667db4a7c2c..ca3366004d379f7851bd623bc4799507f0961513 100644 (file)
@@ -31,7 +31,6 @@
 
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * @author     Maarten Gribnau
  * @date       May 10, 2001
index a6211b42fe6569ad1c4c4cbbcbb784f933ca9faa..2b7fb6686f2bbed6989db58ecdfeb0705c18e875 100644 (file)
@@ -31,7 +31,6 @@
 
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * @author     Maarten Gribnau
  * @date       May 11, 2001
index 81eefdfdc9c1f501eb5e66f3ec221d8d5db38e03..e3fe28e2e6499898c4f514cff4c362745be4a56c 100644 (file)
@@ -31,7 +31,6 @@
 
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * @author     Maarten Gribnau
  * @date       May 10, 2001
@@ -106,10 +105,10 @@ static PIXELFORMATDESCRIPTOR sPreferredFormat = {
 };
 
 /* Intel videocards don't work fine with multiple contexts and
  have to share the same context for all windows.
  But if we just share context for all windows it could work incorrect
  with multiple videocards configuration. Suppose, that Intel videocards
  can't be in multiple-devices configuration. */
* have to share the same context for all windows.
* But if we just share context for all windows it could work incorrect
* with multiple videocards configuration. Suppose, that Intel videocards
* can't be in multiple-devices configuration. */
 static int is_crappy_intel_card(void)
 {
        int crappy = 0;
@@ -1279,8 +1278,8 @@ GHOST_TSuccess GHOST_WindowWin32::endProgressBar()
        return GHOST_kFailure;
 }
 
-/*  Ron Fosner's code for weighting pixel formats and forcing software.
   See http://www.opengl.org/resources/faq/technical/weight.cpp */
+/* Ron Fosner's code for weighting pixel formats and forcing software.
* See http://www.opengl.org/resources/faq/technical/weight.cpp */
 
 static int WeightPixelFormat(PIXELFORMATDESCRIPTOR& pfd)
 {
@@ -1335,7 +1334,7 @@ static int EnumPixelFormats(HDC hdc)
                                      sizeof(PIXELFORMATDESCRIPTOR), &pfd);
 
        /* choose a pixel format using the useless Windows function in case
-           we come up empty handed */
+        * we come up empty handed */
        iPixelFormat = ::ChoosePixelFormat(hdc, &sPreferredFormat);
 
        if (!iPixelFormat) return 0;  /* couldn't find one to use */
index 1f4111c8cf3b65d39378d2997357955e9d7a0962..cdb274b0e611ccb395dbddc5b28bd4c030e8910f 100644 (file)
@@ -228,7 +228,7 @@ GHOST_WindowX11(
                m_visual = glXChooseVisual(m_display, DefaultScreen(m_display), attributes);
 
                /* Any sample level or even zero, which means oversampling disabled, is good
-                  but we need a valid visual to continue */
+                * but we need a valid visual to continue */
                if (m_visual == NULL) {
                        if (samples == 0) {
                                /* All options exhausted, cannot continue */
@@ -1155,8 +1155,8 @@ setOrder(
                Atom atom;
 
                /* We use both XRaiseWindow and _NET_ACTIVE_WINDOW, since some
-                  window managers ignore the former (e.g. kwin from kde) and others
-                  don't implement the latter (e.g. fluxbox pre 0.9.9) */
+                * window managers ignore the former (e.g. kwin from kde) and others
+                * don't implement the latter (e.g. fluxbox pre 0.9.9) */
 
                XRaiseWindow(m_display, m_window);
 
index c32d78f035801eae87f9ba31f644852308b3d467..98e2b9c2497d4a0b19ef9c54362e3b3e912255f4 100644 (file)
@@ -26,7 +26,6 @@
  */
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  *
  * Simple test file for the GHOST library.
@@ -294,14 +293,14 @@ int processEvent(GHOST_EventHandle hEvent, GHOST_TUserDataPtr userData)
        
        switch (GHOST_GetEventType(hEvent))
        {
-               /*
-                  case GHOST_kEventUnknown:
-                   break;
-                  case GHOST_kEventCursorButton:
-                   break;
-                  case GHOST_kEventCursorMove:
-                   break;
-                */
+#if 0
+               case GHOST_kEventUnknown:
+                       break;
+               case GHOST_kEventCursorButton:
+                       break;
+               case GHOST_kEventCursorMove:
+                       break;
+#endif
                case GHOST_kEventWheel:
                {
                        wheelData = (GHOST_TEventWheelData *)GHOST_GetEventData(hEvent);
@@ -345,10 +344,10 @@ int processEvent(GHOST_EventHandle hEvent, GHOST_TUserDataPtr userData)
                                                setting.yPixels = 480;
 
                                                /*
-                                                  setting.bpp = 16;
-                                                  setting.frequency = 75;
-                                                  setting.xPixels = 640;
-                                                  setting.yPixels = 480;
+                                                * setting.bpp = 16;
+                                                * setting.frequency = 75;
+                                                * setting.xPixels = 640;
+                                                * setting.yPixels = 480;
                                                 */
 
                                                sFullScreenWindow = GHOST_BeginFullScreen(shSystem, &setting,
index d338f11ddde76ac14f36860eee9be93d24b310bd..c02272094f4f66bb0d60e3661dc274896ac49aff 100644 (file)
@@ -1,4 +1,4 @@
-/**
+/*
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
@@ -26,7 +26,6 @@
  */
 
 /**
-
  * Copyright (C) 2001 NaN Technologies B.V.
  * Simple test file for the GHOST library.
  * The OpenGL gear code is taken from the Qt sample code which,
@@ -344,27 +343,27 @@ void StereoProjection(float left, float right, float bottom, float top, float ne
                float zero_plane, float dist,
                float eye)
 /* Perform the perspective projection for one eye's subfield.
  The projection is in the direction of the negative z axis.
-
  -6.0, 6.0, -4.8, 4.8,
  left, right, bottom, top = the coordinate range, in the plane of zero
  parallax setting, which will be displayed on the screen.  The
  ratio between (right-left) and (top-bottom) should equal the aspect
  ratio of the display.
-
  6.0, -6.0,
  near, far = the z-coordinate values of the clipping planes.
-
  0.0,
  zero_plane = the z-coordinate of the plane of zero parallax setting.
-
  14.5,
  dist = the distance from the center of projection to the plane
  of zero parallax.
-
  -0.31
  eye = half the eye separation; positive for the right eye subfield,
  negative for the left eye subfield.
* The projection is in the direction of the negative z axis.
+ *
* -6.0, 6.0, -4.8, 4.8,
* left, right, bottom, top = the coordinate range, in the plane of zero
* parallax setting, which will be displayed on the screen.  The
* ratio between (right-left) and (top-bottom) should equal the aspect
* ratio of the display.
+ *
* 6.0, -6.0,
* near, far = the z-coordinate values of the clipping planes.
+ *
* 0.0,
* zero_plane = the z-coordinate of the plane of zero parallax setting.
+ *
* 14.5,
* dist = the distance from the center of projection to the plane
* of zero parallax.
+ *
* -0.31
* eye = half the eye separation; positive for the right eye subfield,
* negative for the left eye subfield.
  */
 {
        float xmid, ymid, clip_near, clip_far, topw, bottomw, leftw, rightw,
@@ -462,13 +461,14 @@ bool Application::processEvent(GHOST_IEvent *event)
        bool handled = true;
 
        switch (event->getType()) {
-/*     case GHOST_kEventUnknown:
-        break;
-    case GHOST_kEventCursorButton:
-        std::cout << "GHOST_kEventCursorButton"; break;
-    case GHOST_kEventCursorMove:
-        std::cout << "GHOST_kEventCursorMove"; break;
- */
+#if 0
+       case GHOST_kEventUnknown:
+               break;
+       case GHOST_kEventCursorButton:
+               std::cout << "GHOST_kEventCursorButton"; break;
+       case GHOST_kEventCursorMove:
+               std::cout << "GHOST_kEventCursorMove"; break;
+ #endif
                case GHOST_kEventWheel:
                {
                        GHOST_TEventWheelData *wheelData = (GHOST_TEventWheelData *) event->getData();
index ac8b855bbe99fee75f9d8edb0fa916be4f09d62d..1705d7855e09d9108b660aeffcdc70d2ccad45bf 100644 (file)
@@ -115,23 +115,23 @@ public:
        void                            Replace(int pos, int num, rcSTR_String str);
 
        // Substrings
-       inline STR_String       Left(int num) const                                                             { num = (num < Len ? num:Len ); return STR_String(pData, num); }
-       inline STR_String       Right(int num) const                                                    { num = (num < Len ? num:Len ); return STR_String(pData+Len-num, num); }
-       inline STR_String       Mid(int pos, int num = INT_MAX) const                   { pos = (pos < Len ? pos:Len ); num = (num < (Len - pos) ? num : (Len - pos)); return STR_String(pData+pos, num); }
+       inline STR_String       Left(int num) const                                                     { num = (num < Len ? num:Len ); return STR_String(pData, num); }
+       inline STR_String       Right(int num) const                                            { num = (num < Len ? num:Len ); return STR_String(pData+Len-num, num); }
+       inline STR_String       Mid(int pos, int num = INT_MAX) const           { pos = (pos < Len ? pos:Len ); num = (num < (Len - pos) ? num : (Len - pos)); return STR_String(pData+pos, num); }
 
        // Comparison
-       int                             Compare(rcSTR_String rhs) const;
-       int                             CompareNoCase(rcSTR_String rhs) const;
-       inline bool             IsEqual(rcSTR_String rhs) const                                 { return (Compare(rhs)==0); }
-       inline bool             IsEqualNoCase(rcSTR_String rhs) const                           { return (CompareNoCase(rhs)==0); }
+       int                                     Compare(rcSTR_String rhs) const;
+       int                                     CompareNoCase(rcSTR_String rhs) const;
+       inline bool                     IsEqual(rcSTR_String rhs) const                                 { return (Compare(rhs)==0); }
+       inline bool                     IsEqualNoCase(rcSTR_String rhs) const                   { return (CompareNoCase(rhs)==0); }
 
        // Search/replace
-       int                             Find(char c, int pos = 0) const;
-       int                             Find(const char *str, int pos = 0) const;
-       int                             Find(rcSTR_String str, int pos = 0) const;
-       int                             RFind(char c) const;
-       int                             FindOneOf(const char *set, int pos = 0) const;
-       int                             RFindOneOf(const char *set, int pos = 0) const;
+       int                                     Find(char c, int pos = 0) const;
+       int                                     Find(const char *str, int pos = 0) const;
+       int                                     Find(rcSTR_String str, int pos = 0) const;
+       int                                     RFind(char c) const;
+       int                                     FindOneOf(const char *set, int pos = 0) const;
+       int                                     RFindOneOf(const char *set, int pos = 0) const;
 
        std::vector<STR_String> Explode(char c) const;
 
@@ -148,42 +148,42 @@ public:
        STR_String&                     TrimQuotes();
 
        // Conversions
-//     inline operator char*()                                                                                         { return pData; }
-       inline operator const char *() const                                                            { return pData; }
-       inline char *Ptr()                                                                                                      { return pData; }
-       inline const char *ReadPtr() const                                                                      { return pData; }
-       inline float    ToFloat() const                                                                         { float x=(float)(atof(pData)); return x; }
-       inline int              ToInt() const                                                                           { return atoi(pData); }
+//     inline operator char*()                                                         { return pData; }
+       inline operator const char *() const                            { return pData; }
+       inline char *Ptr()                                                                      { return pData; }
+       inline const char *ReadPtr() const                                      { return pData; }
+       inline float    ToFloat() const                                         { float x=(float)(atof(pData)); return x; }
+       inline int              ToInt() const                                           { return atoi(pData); }
 
        // Operators
-       inline rcSTR_String     operator=(const byte *rhs)                                              { return Copy((const char *)rhs, strlen((const char *)rhs)); }
-       inline rcSTR_String     operator=(rcSTR_String rhs)                                             { return Copy(rhs.ReadPtr(), rhs.Length()); }
-       inline rcSTR_String     operator=(char rhs)                                                             { return Copy(&rhs, 1); }
-       inline rcSTR_String     operator=(const char *rhs)                                              { return Copy(rhs, strlen(rhs)); }
-
-       inline rcSTR_String     operator+=(const char *rhs)                                             { return Concat(rhs, strlen(rhs)); }
-       inline rcSTR_String     operator+=(rcSTR_String rhs)                                            { return Concat(rhs.ReadPtr(), rhs.Length()); }
-       inline rcSTR_String     operator+=(char rhs)                                                    { return Concat(&rhs, 1); }
-
-       
-       inline friend bool operator<(rcSTR_String      lhs, rcSTR_String                rhs)    { return (strcmp(lhs, rhs)<0); }
-       inline friend bool operator<(rcSTR_String      lhs, const char          *rhs)   { return (strcmp(lhs, rhs)<0); };
-       inline friend bool operator<(const char         *lhs, rcSTR_String     rhs)     { return (strcmp(lhs, rhs)<0); }
-       inline friend bool operator>(rcSTR_String      lhs, rcSTR_String                rhs)    { return (strcmp(lhs, rhs)>0); }
-       inline friend bool operator>(rcSTR_String      lhs, const char          *rhs)   { return (strcmp(lhs, rhs)>0); }
-       inline friend bool operator>(const char         *lhs, rcSTR_String     rhs)     { return (strcmp(lhs, rhs)>0); }
-       inline friend bool operator<=(rcSTR_String     lhs, rcSTR_String                rhs)    { return (strcmp(lhs, rhs)<=0); }
-       inline friend bool operator<=(rcSTR_String     lhs, const char          *rhs)   { return (strcmp(lhs, rhs)<=0); }
-       inline friend bool operator<=(const char        *lhs, rcSTR_String     rhs)     { return (strcmp(lhs, rhs)<=0); }
-       inline friend bool operator>=(rcSTR_String     lhs, rcSTR_String                rhs)    { return (strcmp(lhs, rhs)>=0); }
-       inline friend bool operator>=(rcSTR_String     lhs, const char          *rhs)   { return (strcmp(lhs, rhs)>=0); }
-       inline friend bool operator>=(const char        *lhs, rcSTR_String     rhs)     { return (strcmp(lhs, rhs)>=0); }
-       inline friend bool operator==(rcSTR_String     lhs, rcSTR_String                rhs)    { return ((lhs.Length() == rhs.Length()) && (memcmp(lhs, rhs, lhs.Length())==0)); }
-       inline friend bool operator==(rcSTR_String     lhs, const char          *rhs)   { return (memcmp(lhs, rhs, lhs.Length()+1)==0); }
-       inline friend bool operator==(const char        *lhs, rcSTR_String     rhs)     { return (memcmp(lhs, rhs, rhs.Length()+1)==0); }
-       inline friend bool operator!=(rcSTR_String     lhs, rcSTR_String                rhs)    { return ((lhs.Length() != rhs.Length()) || (memcmp(lhs, rhs, lhs.Length())!=0)); }
-       inline friend bool operator!=(rcSTR_String     lhs, const char          *rhs)   { return (memcmp(lhs, rhs, lhs.Length()+1)!=0); }
-       inline friend bool operator!=(const char        *lhs, rcSTR_String     rhs)     { return (memcmp(lhs, rhs, rhs.Length()+1)!=0); }
+       inline rcSTR_String     operator=(const byte *rhs)              { return Copy((const char *)rhs, strlen((const char *)rhs)); }
+       inline rcSTR_String     operator=(rcSTR_String rhs)             { return Copy(rhs.ReadPtr(), rhs.Length()); }
+       inline rcSTR_String     operator=(char rhs)                             { return Copy(&rhs, 1); }
+       inline rcSTR_String     operator=(const char *rhs)              { return Copy(rhs, strlen(rhs)); }
+
+       inline rcSTR_String     operator+=(const char *rhs)             { return Concat(rhs, strlen(rhs)); }
+       inline rcSTR_String     operator+=(rcSTR_String rhs)    { return Concat(rhs.ReadPtr(), rhs.Length()); }
+       inline rcSTR_String     operator+=(char rhs)                    { return Concat(&rhs, 1); }
+
+
+       inline friend bool operator<(rcSTR_String      lhs, rcSTR_String     rhs)       { return (strcmp(lhs, rhs)<0); }
+       inline friend bool operator<(rcSTR_String      lhs, const char      *rhs)       { return (strcmp(lhs, rhs)<0); }
+       inline friend bool operator<(const char       *lhs, rcSTR_String     rhs)       { return (strcmp(lhs, rhs)<0); }
+       inline friend bool operator>(rcSTR_String      lhs, rcSTR_String     rhs)       { return (strcmp(lhs, rhs)>0); }
+       inline friend bool operator>(rcSTR_String      lhs, const char      *rhs)       { return (strcmp(lhs, rhs)>0); }
+       inline friend bool operator>(const char       *lhs, rcSTR_String     rhs)       { return (strcmp(lhs, rhs)>0); }
+       inline friend bool operator<=(rcSTR_String     lhs, rcSTR_String     rhs)       { return (strcmp(lhs, rhs)<=0); }
+       inline friend bool operator<=(rcSTR_String     lhs, const char      *rhs)       { return (strcmp(lhs, rhs)<=0); }
+       inline friend bool operator<=(const char      *lhs, rcSTR_String     rhs)       { return (strcmp(lhs, rhs)<=0); }
+       inline friend bool operator>=(rcSTR_String     lhs, rcSTR_String     rhs)       { return (strcmp(lhs, rhs)>=0); }
+       inline friend bool operator>=(rcSTR_String     lhs, const char      *rhs)       { return (strcmp(lhs, rhs)>=0); }
+       inline friend bool operator>=(const char      *lhs, rcSTR_String     rhs)       { return (strcmp(lhs, rhs)>=0); }
+       inline friend bool operator==(rcSTR_String     lhs, rcSTR_String     rhs)       { return ((lhs.Length() == rhs.Length()) && (memcmp(lhs, rhs, lhs.Length())==0)); }
+       inline friend bool operator==(rcSTR_String     lhs, const char      *rhs)       { return (memcmp(lhs, rhs, lhs.Length()+1)==0); }
+       inline friend bool operator==(const char      *lhs, rcSTR_String     rhs)       { return (memcmp(lhs, rhs, rhs.Length()+1)==0); }
+       inline friend bool operator!=(rcSTR_String     lhs, rcSTR_String     rhs)       { return ((lhs.Length() != rhs.Length()) || (memcmp(lhs, rhs, lhs.Length())!=0)); }
+       inline friend bool operator!=(rcSTR_String     lhs, const char      *rhs)       { return (memcmp(lhs, rhs, lhs.Length()+1)!=0); }
+       inline friend bool operator!=(const char       *lhs, rcSTR_String    rhs)       { return (memcmp(lhs, rhs, rhs.Length()+1)!=0); }
 
        // serializing
        //int                   Serialize(pCStream stream);
@@ -198,7 +198,7 @@ protected:
        static bool             isUpper(char c)                                                                 { return (c>='A') && (c <= 'Z'); }
        static bool             isSpace(char c)                                                                 { return (c==' ') || (c=='\t'); }
 
-       char   *pData;                                                                                                  // -> STR_String data
+       char  *pData;                                                                                                   // -> STR_String data
        int        Len;                                                                                                         // Data length
        int        Max;                                                                                                         // Space in data buffer
 
@@ -209,10 +209,10 @@ protected:
 };
 
 inline  STR_String operator+(rcSTR_String    lhs, rcSTR_String   rhs)  { return STR_String(lhs.ReadPtr(), lhs.Length(), rhs.ReadPtr(), rhs.Length()); }
-inline  STR_String operator+(rcSTR_String    lhs, char        rhs)     { return STR_String(lhs.ReadPtr(), lhs.Length(), &rhs, 1); }
-inline  STR_String operator+(char         lhs, rcSTR_String   rhs)     { return STR_String(&lhs, 1, rhs.ReadPtr(), rhs.Length()); }
-inline  STR_String operator+(rcSTR_String    lhs, const char *rhs)     { return STR_String(lhs.ReadPtr(), lhs.Length(), rhs, strlen(rhs)); }
-inline  STR_String operator+(const char  *lhs, rcSTR_String   rhs)     { return STR_String(lhs, strlen(lhs), rhs.ReadPtr(), rhs.Length()); }
+inline  STR_String operator+(rcSTR_String    lhs, char        rhs)             { return STR_String(lhs.ReadPtr(), lhs.Length(), &rhs, 1); }
+inline  STR_String operator+(char            lhs, rcSTR_String   rhs)  { return STR_String(&lhs, 1, rhs.ReadPtr(), rhs.Length()); }
+inline  STR_String operator+(rcSTR_String    lhs, const char *rhs)             { return STR_String(lhs.ReadPtr(), lhs.Length(), rhs, strlen(rhs)); }
+inline  STR_String operator+(const char      *lhs, rcSTR_String   rhs) { return STR_String(lhs, strlen(lhs), rhs.ReadPtr(), rhs.Length()); }
 
 
 #endif //__STR_STRING_H__
index 5ad41c696e30f41930f190c7b53270c26c187427..bea6e88cfff50722d9703ee7e0a1c6b2f209d9d8 100644 (file)
 
 #include <stdio.h>
 #include <stdarg.h>
-#include <stdlib.h> 
+#include <stdlib.h>
 #include <ctype.h>
 #include <string.h>
-#if defined(__sun__) || defined( __sun ) || defined (__sparc) || defined (__sparc__) || defined (_AIX)
+#if defined(__sun__) || defined(__sun) || defined(__sparc) || defined(__sparc__) || defined(_AIX)
 #  include <strings.h>
 #endif
 #include "STR_String.h"
@@ -57,7 +57,7 @@
 // Construct an empty string
 //
 STR_String::STR_String() :
-       pData(new char [32]), 
+       pData(new char[32]),
        Len(0),
        Max(32)
 {
@@ -70,7 +70,7 @@ STR_String::STR_String() :
 // Construct a string of one character
 //
 STR_String::STR_String(char c) :
-       pData(new char [9]),
+       pData(new char[9]),
        Len(1),
        Max(9)
 {
@@ -84,9 +84,9 @@ STR_String::STR_String(char c) :
 // Construct a string of multiple repeating characters
 //
 STR_String::STR_String(char c, int len) :
-       pData(new char [len+8]),
+       pData(new char[len + 8]),
        Len(len),
-       Max(len+8)
+       Max(len + 8)
 {
        assertd(pData != NULL);
        memset(pData, c, len);
@@ -104,7 +104,7 @@ STR_String::STR_String(const char *str)
        if (str) {
                Len = ::strlen(str);
                Max = Len + 8;
-               pData = new char [Max];
+               pData = new char[Max];
                assertd(pData != NULL);
                ::memcpy(pData, str, Len);
                pData[Len] = 0;
@@ -122,9 +122,9 @@ STR_String::STR_String(const char *str)
 // Construct a string from a pointer-to-ASCII-string and a length
 //
 STR_String::STR_String(const char *str, int len) :
-       pData(new char [len+8]),
+       pData(new char[len + 8]),
        Len(len),
-       Max(len+8)
+       Max(len + 8)
 {
        assertd(pData != NULL);
        memcpy(pData, str, len);
@@ -137,9 +137,9 @@ STR_String::STR_String(const char *str, int len) :
 // Construct a string from another string
 //
 STR_String::STR_String(rcSTR_String str) :
-       pData(new char [str.Length()+8]),
+       pData(new char[str.Length() + 8]),
        Len(str.Length()),
-       Max(str.Length()+8)
+       Max(str.Length() + 8)
 {
        assertd(pData != NULL);
        assertd(str.pData != NULL);
@@ -153,9 +153,9 @@ STR_String::STR_String(rcSTR_String str) :
 // Construct a string from the first number of characters in another string
 //
 STR_String::STR_String(rcSTR_String str, int len) :
-       pData(new char [len+8]),
+       pData(new char[len + 8]),
        Len(len),
-       Max(len+8)
+       Max(len + 8)
 {
        assertd(pData != NULL);
        assertd(str.pData != NULL);
@@ -169,14 +169,14 @@ STR_String::STR_String(rcSTR_String str, int len) :
 // Create a string by concatenating two sources
 //
 STR_String::STR_String(const char *src1, int len1, const char *src2, int len2) :
-       pData(new char [len1+len2+8]),
-       Len(len1+len2),
-       Max(len1+len2+8)
+       pData(new char[len1 + len2 + 8]),
+       Len(len1 + len2),
+       Max(len1 + len2 + 8)
 {
        assertd(pData != NULL);
        memcpy(pData, src1, len1);
-       memcpy(pData+len1, src2, len2);
-       pData[len1+len2] = 0;
+       memcpy(pData + len1, src2, len2);
+       pData[len1 + len2] = 0;
 }
 
 
@@ -185,13 +185,13 @@ STR_String::STR_String(const char *src1, int len1, const char *src2, int len2) :
 // Create a string with an integer value
 //
 STR_String::STR_String(int val) :
-       pData(new char [32]),
+       pData(new char[32]),
        Max(32)
 {
        assertd(pData != NULL);
-       Len=sprintf(pData, "%d", val);
+       Len = sprintf(pData, "%d", val);
 }
-       
+
 
 
 
@@ -199,11 +199,11 @@ STR_String::STR_String(int val) :
 // Create a string with a dword value
 //
 STR_String::STR_String(dword val) :
-       pData(new char [32]),
+       pData(new char[32]),
        Max(32)
 {
        assertd(pData != NULL);
-       Len=sprintf(pData, "%lu", val);
+       Len = sprintf(pData, "%lu", val);
 }
 
 
@@ -212,11 +212,11 @@ STR_String::STR_String(dword val) :
 // Create a string with a floating point value
 //
 STR_String::STR_String(float val) :
-       pData(new char [32]),
+       pData(new char[32]),
        Max(32)
 {
        assertd(pData != NULL);
-       Len=sprintf(pData, "%g", val);
+       Len = sprintf(pData, "%g", val);
 }
 
 
@@ -225,11 +225,11 @@ STR_String::STR_String(float val) :
 // Create a string with a double value
 //
 STR_String::STR_String(double val) :
-       pData(new char [32]),
+       pData(new char[32]),
        Max(32)
 {
        assertd(pData != NULL);
-       Len=sprintf(pData, "%g", val);
+       Len = sprintf(pData, "%g", val);
 }
 
 
@@ -246,19 +246,19 @@ STR_String::STR_String(double val) :
 void STR_String::AllocBuffer(int len, bool keep_contents)
 {
        // Check if we have enough space
-       if (len+1 <= Max) return;
+       if (len + 1 <= Max) return;
 
        // Reallocate string
-       char *new_data = new char [len+8];
+       char *new_data = new char[len + 8];
        if (keep_contents) memcpy(new_data, pData, Len);
        delete[] pData;
 
        // Accept new data
-       Max = len+8;
+       Max = len + 8;
        pData = new_data;
        assertd(pData != NULL);
 }
-       
+
 
 
 /*-------------------------------------------------------------------------------------------------
@@ -298,7 +298,7 @@ STR_String& STR_String::FormatAdd(const char *fmt, ...)
        // Expand arguments and format to string
        va_list args;
        va_start(args, fmt);
-       Len += vsprintf(pData+Len, fmt, args);
+       Len += vsprintf(pData + Len, fmt, args);
        assertd(Len <= 2048);
        va_end(args);
 
@@ -318,7 +318,7 @@ STR_String& STR_String::FormatAdd(const char *fmt, ...)
 //
 bool STR_String::IsUpper() const
 {
-       for (int i=0; i<Len; i++)
+       for (int i = 0; i < Len; i++)
                if (isLower(pData[i]))
                        return false;
 
@@ -332,7 +332,7 @@ bool STR_String::IsUpper() const
 //
 bool STR_String::IsLower() const
 {
-       for (int i=0; i<Len; i++)
+       for (int i = 0; i < Len; i++)
                if (isUpper(pData[i]))
                        return false;
 
@@ -353,10 +353,10 @@ bool STR_String::IsLower() const
 int STR_String::Find(char c, int pos) const
 {
        assertd(pos >= 0);
-       assertd(Len==0 || pos<Len);
+       assertd(Len == 0 || pos < Len);
        assertd(pData != NULL);
-       char *find_pos = strchr(pData+pos, c);
-       return (find_pos) ? (find_pos-pData) : -1;
+       char *find_pos = strchr(pData + pos, c);
+       return (find_pos) ? (find_pos - pData) : -1;
 }
 
 
@@ -364,13 +364,13 @@ int STR_String::Find(char c, int pos) const
 //
 // Find the first occurrence of <str> in the string
 //
-int    STR_String::Find(const char *str, int pos) const
+int STR_String::Find(const char *str, int pos) const
 {
        assertd(pos >= 0);
-       assertd(Len==0 || pos<Len);
+       assertd(Len == 0 || pos < Len);
        assertd(pData != NULL);
-       char *find_pos = strstr(pData+pos, str);
-       return (find_pos) ? (find_pos-pData) : -1;
+       char *find_pos = strstr(pData + pos, str);
+       return (find_pos) ? (find_pos - pData) : -1;
 }
 
 
@@ -378,13 +378,13 @@ int       STR_String::Find(const char *str, int pos) const
 //
 // Find the first occurrence of <str> in the string
 //
-int    STR_String::Find(rcSTR_String str, int pos) const
+int STR_String::Find(rcSTR_String str, int pos) const
 {
        assertd(pos >= 0);
-       assertd(Len==0 || pos<Len);
+       assertd(Len == 0 || pos < Len);
        assertd(pData != NULL);
-       char *find_pos = strstr(pData+pos, str.ReadPtr());
-       return (find_pos) ? (find_pos-pData) : -1;
+       char *find_pos = strstr(pData + pos, str.ReadPtr());
+       return (find_pos) ? (find_pos - pData) : -1;
 }
 
 
@@ -396,7 +396,7 @@ int STR_String::RFind(char c) const
 {
        assertd(pData != NULL);
        char *pos = strrchr(pData, c);
-       return (pos) ? (pos-pData) : -1;
+       return (pos) ? (pos - pData) : -1;
 }
 
 
@@ -407,10 +407,10 @@ int STR_String::RFind(char c) const
 int STR_String::FindOneOf(const char *set, int pos) const
 {
        assertd(pos >= 0);
-       assertd(Len==0 || pos<Len);
+       assertd(Len == 0 || pos < Len);
        assertd(pData != NULL);
-       char *find_pos = strpbrk(pData+pos, set);
-       return (find_pos) ? (find_pos-pData) : -1;
+       char *find_pos = strpbrk(pData + pos, set);
+       return (find_pos) ? (find_pos - pData) : -1;
 }
 
 
@@ -425,17 +425,16 @@ void STR_String::Replace(int pos, rcSTR_String str)
        if (str.Length() < 1)
        {
                // Remove one character from the string
-               memcpy(pData+pos, pData+pos+1, Len-pos);
+               memcpy(pData + pos, pData + pos + 1, Len - pos);
        }
-       else
-       {
+       else {
                // Insert zero or more characters into the string
                AllocBuffer(Len + str.Length() - 1, true);
-               if (str.Length() != 1) memcpy(pData+pos+str.Length(), pData+pos+1, Length()-pos);
-               memcpy(pData+pos, str.ReadPtr(), str.Length());
+               if (str.Length() != 1) memcpy(pData + pos + str.Length(), pData + pos + 1, Length() - pos);
+               memcpy(pData + pos, str.ReadPtr(), str.Length());
        }
 
-       Len += str.Length()-1;
+       Len += str.Length() - 1;
 }
 
 
@@ -452,18 +451,17 @@ void STR_String::Replace(int pos, int num, rcSTR_String str)
        if (str.Length() < num)
        {
                // Remove some data from the string by replacement
-               memcpy(pData+pos+str.Length(), pData+pos+num, Len-pos-num+1);
-               memcpy(pData+pos, str.ReadPtr(), str.Length());
+               memcpy(pData + pos + str.Length(), pData + pos + num, Len - pos - num + 1);
+               memcpy(pData + pos, str.ReadPtr(), str.Length());
        }
-       else
-       {
+       else {
                // Insert zero or more characters into the string
                AllocBuffer(Len + str.Length() - num, true);
-               if (str.Length() != num) memcpy(pData+pos+str.Length(), pData+pos+num, Length()-pos-num+1);
-               memcpy(pData+pos, str.ReadPtr(), str.Length());
+               if (str.Length() != num) memcpy(pData + pos + str.Length(), pData + pos + num, Length() - pos - num + 1);
+               memcpy(pData + pos, str.ReadPtr(), str.Length());
        }
 
-       Len += str.Length()-num;
+       Len += str.Length() - num;
 }
 
 
@@ -477,7 +475,7 @@ void STR_String::Replace(int pos, int num, rcSTR_String str)
 //
 // Compare two strings and return the result, <0 if *this<rhs, >0 if *this>rhs or 0 if *this==rhs
 //
-int    STR_String::Compare(rcSTR_String rhs) const
+int STR_String::Compare(rcSTR_String rhs) const
 {
        return strcmp(pData, rhs.pData);
 }
@@ -507,14 +505,14 @@ int STR_String::CompareNoCase(rcSTR_String rhs) const
 //
 // Capitalize string, "heLLo" -> "HELLO"
 //
-STR_String&    STR_String::Upper()
+STR_String& STR_String::Upper()
 {
        assertd(pData != NULL);
 #ifdef WIN32
        _strupr(pData);
 #else
-       for (int i=0;i<Len;i++)
-               pData[i] = (pData[i] >= 'a' && pData[i] <= 'z')?pData[i]+'A'-'a':pData[i];
+       for (int i = 0; i < Len; i++)
+               pData[i] = (pData[i] >= 'a' && pData[i] <= 'z') ? pData[i] + 'A' - 'a' : pData[i];
 #endif
        return *this;
 }
@@ -524,14 +522,14 @@ STR_String&       STR_String::Upper()
 //
 // Lower string, "heLLo" -> "hello"
 //
-STR_String&    STR_String::Lower()
+STR_String& STR_String::Lower()
 {
        assertd(pData != NULL);
 #ifdef WIN32
        _strlwr(pData);
 #else
-       for (int i=0;i<Len;i++)
-               pData[i] = (pData[i] >= 'A' && pData[i] <= 'Z')?pData[i]+'a'-'A':pData[i];
+       for (int i = 0; i < Len; i++)
+               pData[i] = (pData[i] >= 'A' && pData[i] <= 'Z') ? pData[i] + 'a' - 'A' : pData[i];
 #endif
        return *this;
 }
@@ -541,17 +539,17 @@ STR_String&       STR_String::Lower()
 //
 // Capitalize string, "heLLo" -> "Hello"
 //
-STR_String&    STR_String::Capitalize()
+STR_String& STR_String::Capitalize()
 {
        assertd(pData != NULL);
 #ifdef WIN32
-       if (Len>0) pData[0] = toupper(pData[0]);
-       if (Len>1) _strlwr(pData+1);
+       if (Len > 0) pData[0] = toupper(pData[0]);
+       if (Len > 1) _strlwr(pData + 1);
 #else
        if (Len > 0)
-               pData[0] = (pData[0] >= 'A' && pData[0] <= 'A')?pData[0]+'a'-'A':pData[0];
-       for (int i=1;i<Len;i++)
-               pData[i] = (pData[i] >= 'a' && pData[i] <= 'z')?pData[i]+'A'-'a':pData[i];
+               pData[0] = (pData[0] >= 'A' && pData[0] <= 'A') ? pData[0] + 'a' - 'A' : pData[0];
+       for (int i = 1; i < Len; i++)
+               pData[i] = (pData[i] >= 'a' && pData[i] <= 'z') ? pData[i] + 'A' - 'a' : pData[i];
 #endif
        return *this;
 }
@@ -561,13 +559,13 @@ STR_String&       STR_String::Capitalize()
 //
 // Trim whitespace from the left side of the string
 //
-STR_String&    STR_String::TrimLeft()
+STR_String& STR_String::TrimLeft()
 {
        int skip;
        assertd(pData != NULL);
-       for (skip=0; isSpace(pData[skip]); skip++, Len--)
-               {};
-       memmove(pData, pData+skip, Len+1);
+       for (skip = 0; isSpace(pData[skip]); skip++, Len--)
+       {};
+       memmove(pData, pData + skip, Len + 1);
        return *this;
 }
 
@@ -576,11 +574,11 @@ STR_String&       STR_String::TrimLeft()
 //
 // Trim whitespaces from the right side of the string
 //
-STR_String&    STR_String::TrimRight()
+STR_String& STR_String::TrimRight()
 {
        assertd(pData != NULL);
-       while (Len && isSpace(pData[Len-1])) Len--;
-       pData[Len]=0;
+       while (Len && isSpace(pData[Len - 1])) Len--;
+       pData[Len] = 0;
        return *this;
 }
 
@@ -589,7 +587,7 @@ STR_String& STR_String::TrimRight()
 //
 // Trim spaces from both sides of the character set
 //
-STR_String&    STR_String::Trim()
+STR_String& STR_String::Trim()
 {
        TrimRight();
        TrimLeft();
@@ -601,13 +599,13 @@ STR_String&       STR_String::Trim()
 //
 // Trim characters from the character set <set> from the left side of the string
 //
-STR_String&    STR_String::TrimLeft(char *set)
+STR_String& STR_String::TrimLeft(char *set)
 {
        int skip;
        assertd(pData != NULL);
-       for (skip=0; Len && strchr(set, pData[skip]); skip++, Len--)
-               {};
-       memmove(pData, pData+skip, Len+1);
+       for (skip = 0; Len && strchr(set, pData[skip]); skip++, Len--)
+       {};
+       memmove(pData, pData + skip, Len + 1);
        return *this;
 }
 
@@ -616,11 +614,11 @@ STR_String&       STR_String::TrimLeft(char *set)
 //
 // Trim characters from the character set <set> from the right side of the string
 //
-STR_String&    STR_String::TrimRight(char *set)
+STR_String& STR_String::TrimRight(char *set)
 {
        assertd(pData != NULL);
-       while (Len && strchr(set, pData[Len-1])) Len--;
-       pData[Len]=0;
+       while (Len && strchr(set, pData[Len - 1])) Len--;
+       pData[Len] = 0;
        return *this;
 }
 
@@ -629,7 +627,7 @@ STR_String& STR_String::TrimRight(char *set)
 //
 // Trim characters from the character set <set> from both sides of the character set
 //
-STR_String&    STR_String::Trim(char *set)
+STR_String& STR_String::Trim(char *set)
 {
        TrimRight(set);
        TrimLeft(set);
@@ -641,14 +639,14 @@ STR_String&       STR_String::Trim(char *set)
 //
 // Trim quotes from both sides of the string
 //
-STR_String&    STR_String::TrimQuotes()
+STR_String& STR_String::TrimQuotes()
 {
        // Trim quotes if they are on both sides of the string
        assertd(pData != NULL);
-       if ((Len >= 2) && (pData[0] == '\"') && (pData[Len-1] == '\"'))
+       if ((Len >= 2) && (pData[0] == '\"') && (pData[Len - 1] == '\"'))
        {
-               memmove(pData, pData+1, Len-2+1);
-               Len-=2;
+               memmove(pData, pData + 1, Len - 2 + 1);
+               Len -= 2;
        }
        return *this;
 }
@@ -666,7 +664,7 @@ STR_String& STR_String::TrimQuotes()
 //
 rcSTR_String STR_String::Copy(const char *src, int len)
 {
-       assertd(len>=0);
+       assertd(len >= 0);
        assertd(src);
        assertd(pData != NULL);
 
@@ -685,23 +683,23 @@ rcSTR_String STR_String::Copy(const char *src, int len)
 //
 rcSTR_String STR_String::Concat(const char *data, int len)
 {
-       assertd(Len>=0);
-       assertd(len>=0);
+       assertd(Len >= 0);
+       assertd(len >= 0);
        assertd(data);
        assertd(pData != NULL);
 
-       AllocBuffer(Len+len, true);
-       memcpy(pData+Len, data, len);
-       Len+=len;
+       AllocBuffer(Len + len, true);
+       memcpy(pData + Len, data, len);
+       Len += len;
        pData[Len] = 0;
 
        return *this;
 }
 
 
-std::vector<STR_String>        STR_String::Explode(char c) const
+std::vector<STR_String> STR_String::Explode(char c) const
 {
-       STR_String              lcv = *this;
+       STR_String lcv = *this;
        std::vector<STR_String> uc;
 
        while (lcv.Length())
@@ -713,7 +711,7 @@ std::vector<STR_String>     STR_String::Explode(char c) const
                }
                else {
                        uc.push_back(lcv.Left(pos));
-                       lcv = lcv.Mid(pos+1);
+                       lcv = lcv.Mid(pos + 1);
                }
        }
 
@@ -723,25 +721,24 @@ std::vector<STR_String>   STR_String::Explode(char c) const
 }
 
 
-/*
+#if 0
 
 int            STR_String::Serialize(pCStream stream)
 {
-       if (stream->GetAccess() == CStream::Access_Read)
-       {
+       if (stream->GetAccess() == CStream::Access_Read) {
                int ln;
                stream->Read(&ln, sizeof(ln));
                AllocBuffer(ln, false);
                stream->Read(pData, ln); 
                pData[ln]       = '\0';
                Len                     = ln;
-       } else
-       {
+       }
+       else {
                stream->Write(&Len, sizeof(Len));
                stream->Write(pData, Len);
        }
 
        return Len + sizeof(Len);
 }
-*/
+#endif
 
index 68d1d6bb403c4ff453bc1ace9e4c2107aca32eba..3840dc2564896e05f0d094033f2b28deb0e8c071 100644 (file)
@@ -67,7 +67,7 @@ int uopen(const char *filename, int oflag, int pmode)
        UTF16_UN_ENCODE(filename);
 
        if (f == -1) {
-               if ((f=open(filename,oflag, pmode)) != -1) {
+               if ((f = open(filename,oflag, pmode)) != -1) {
                        printf("WARNING: %s is not utf path. Please update it.\n",filename);
                }
        }
index edc17c36c36af3416c24f492137611a643c629fc..b2f366d5d1ea0621331f793c25511d5712879f22 100644 (file)
@@ -20,6 +20,7 @@
 
 __all__ = (
     "region_2d_to_vector_3d",
+    "region_2d_to_origin_3d",
     "region_2d_to_location_3d",
     "location_3d_to_region_2d",
     )
@@ -58,6 +59,40 @@ def region_2d_to_vector_3d(region, rv3d, coord):
         return viewinv.col[2].xyz.normalized()
 
 
+def region_2d_to_origin_3d(region, rv3d, coord):
+    """
+    Return the 3d view origin from the region relative 2d coords.
+
+    :arg region: region of the 3D viewport, typically bpy.context.region.
+    :type region: :class:`bpy.types.Region`
+    :arg rv3d: 3D region data, typically bpy.context.space_data.region_3d.
+    :type rv3d: :class:`bpy.types.RegionView3D`
+    :arg coord: 2d coordinates relative to the region;
+       (event.mouse_region_x, event.mouse_region_y) for example.
+    :type coord: 2d vector
+    :return: The origin of the viewpoint in 3d space.
+    :rtype: :class:`mathutils.Vector`
+    """
+    from mathutils import Vector
+
+    viewinv = rv3d.view_matrix.inverted()
+
+    if rv3d.is_perspective:
+        from mathutils.geometry import intersect_line_plane
+
+        origin_start = viewinv.translation.copy()
+    else:
+        from mathutils.geometry import intersect_point_line
+        persmat = rv3d.perspective_matrix.copy()
+        dx = (2.0 * coord[0] / region.width) - 1.0
+        dy = (2.0 * coord[1] / region.height) - 1.0
+        persinv = persmat.inverted()
+        origin_start = ((persinv.col[0].xyz * dx) +
+                        (persinv.col[1].xyz * dy) +
+                         viewinv.translation)
+    return origin_start
+
+
 def region_2d_to_location_3d(region, rv3d, coord, depth_location):
     """
     Return a 3d location from the region relative 2d coords, aligned with
@@ -77,18 +112,16 @@ def region_2d_to_location_3d(region, rv3d, coord, depth_location):
     :rtype: :class:`mathutils.Vector`
     """
     from mathutils import Vector
-    from mathutils.geometry import intersect_point_line
 
-    persmat = rv3d.perspective_matrix.copy()
-    viewinv = rv3d.view_matrix.inverted()
     coord_vec = region_2d_to_vector_3d(region, rv3d, coord)
     depth_location = Vector(depth_location)
 
+    origin_start = region_2d_to_origin_3d(region, rv3d, coord)
+    origin_end = origin_start + coord_vec
+
     if rv3d.is_perspective:
         from mathutils.geometry import intersect_line_plane
-
-        origin_start = viewinv.translation.copy()
-        origin_end = origin_start + coord_vec
+        viewinv = rv3d.view_matrix.inverted()
         view_vec = viewinv.col[2].copy()
         return intersect_line_plane(origin_start,
                                     origin_end,
@@ -96,14 +129,7 @@ def region_2d_to_location_3d(region, rv3d, coord, depth_location):
                                     view_vec, 1,
                                     )
     else:
-        dx = (2.0 * coord[0] / region.width) - 1.0
-        dy = (2.0 * coord[1] / region.height) - 1.0
-        persinv = persmat.inverted()
-        viewinv = rv3d.view_matrix.inverted()
-        origin_start = ((persinv.col[0].xyz * dx) +
-                        (persinv.col[1].xyz * dy) +
-                         viewinv.translation)
-        origin_end = origin_start + coord_vec
+        from mathutils.geometry import intersect_point_line
         return intersect_point_line(depth_location,
                                     origin_start,
                                     origin_end,
index e3e0217e26a6aa74e98b2324c426b265d9d04567..9511cb163bcbfa4323b80ffce29463e78e30a7dd 100644 (file)
@@ -18,7 +18,7 @@ from bpy.types import Operator
 
 
 class ExportSomeData(Operator, ExportHelper):
-    '''This appears in the tooltip of the operator and in the generated docs'''
+    """This appears in the tooltip of the operator and in the generated docs"""
     bl_idname = "export_test.some_data"  # important since its how bpy.ops.import_test.some_data is constructed
     bl_label = "Export Some Data"
 
index 80d850aae60cd4e52048ac83046a9dc25512ffe6..9940a1b98eb846a1026f720211fe1d5ad56a6418 100644 (file)
@@ -21,7 +21,7 @@ from bpy.types import Operator
 
 
 class ImportSomeData(Operator, ImportHelper):
-    '''This appears in the tooltip of the operator and in the generated docs'''
+    """This appears in the tooltip of the operator and in the generated docs"""
     bl_idname = "import_test.some_data"  # important since its how bpy.ops.import_test.some_data is constructed
     bl_label = "Import Some Data"
 
index 3228e3c4d62100ab1aeb037305a8f00d47a30f16..f2bb231cb7a8a7e08d54585ab54b8e56d62fe297 100644 (file)
@@ -37,7 +37,7 @@ from bpy.props import FloatProperty, BoolProperty, FloatVectorProperty
 
 
 class AddBox(bpy.types.Operator):
-    '''Add a simple box mesh'''
+    """Add a simple box mesh"""
     bl_idname = "mesh.primitive_box_add"
     bl_label = "Add Box"
     bl_options = {'REGISTER', 'UNDO'}
index a428b097f8233c76a705268b4b3b98178815c1d0..d8115bc95bfd86dbb7dc639a87f394f032dcaf75 100644 (file)
@@ -3,7 +3,7 @@ from bpy.props import IntProperty, FloatProperty
 
 
 class ModalOperator(bpy.types.Operator):
-    '''Move an object with the mouse, example.'''
+    """Move an object with the mouse, example"""
     bl_idname = "object.modal_operator"
     bl_label = "Simple Modal Operator"
 
index b3d525a59bf08596ad17292e6e31901cc82e5c8f..f2d5ad8982b7a168a2605cf612afdc84b54435f5 100644 (file)
@@ -31,7 +31,7 @@ def draw_callback_px(self, context):
 
 
 class ModalDrawOperator(bpy.types.Operator):
-    '''Draw a line with the mouse'''
+    """Draw a line with the mouse"""
     bl_idname = "view3d.modal_operator"
     bl_label = "Simple Modal View3D Operator"
 
index ebbf6395df56dc441b373ed775ba592d21626804..6d2ec95aedb2f516ee17c64d7e93b95282e8e3bb 100644 (file)
@@ -2,7 +2,7 @@ import bpy
 
 
 class ModalTimerOperator(bpy.types.Operator):
-    '''Operator which runs its self from a timer.'''
+    """Operator which runs its self from a timer"""
     bl_idname = "wm.modal_timer_operator"
     bl_label = "Modal Timer Operator"
 
index 263bf72f1293e796ef13e00970226a09d3a93bb2..0babf169610d4678d80079c6a19a661499318e68 100644 (file)
@@ -4,7 +4,7 @@ from bpy.props import FloatVectorProperty
 
 
 class ViewOperator(bpy.types.Operator):
-    '''Translate the view using mouse events.'''
+    """Translate the view using mouse events"""
     bl_idname = "view3d.modal_operator"
     bl_label = "Simple View Operator"
 
diff --git a/release/scripts/templates/operator_modal_view3d_raycast.py b/release/scripts/templates/operator_modal_view3d_raycast.py
new file mode 100644 (file)
index 0000000..3236c08
--- /dev/null
@@ -0,0 +1,107 @@
+import bpy
+from mathutils import Vector
+from bpy_extras import view3d_utils
+
+
+def main(context, event, ray_max=10000.0):
+    """Run this function on left mouse, execute the ray cast"""
+    # get the context arguments
+    scene = context.scene
+    region = context.region
+    rv3d = context.region_data
+    coord = event.mouse_region_x, event.mouse_region_y
+
+    # get the ray from the viewport and mouse
+    view_vector = view3d_utils.region_2d_to_vector_3d(region, rv3d, coord)
+    ray_origin = view3d_utils.region_2d_to_origin_3d(region, rv3d, coord)
+    ray_target = ray_origin + (view_vector * ray_max)
+
+    scene.cursor_location = ray_target
+
+    def visible_objects_and_duplis():
+        """Loop over (object, matrix) pairs (mesh only)"""
+
+        for obj in context.visible_objects:
+            if obj.type == 'MESH':
+                yield (obj, obj.matrix_world.copy())
+
+            if obj.dupli_type != 'NONE':
+                obj.dupli_list_create(scene)
+                for dob in obj.dupli_list:
+                    obj_dupli = dob.object
+                    if obj_dupli.type == 'MESH':
+                        yield (obj_dupli, dob.matrix.copy())
+
+            obj.dupli_list_clear()
+
+    def obj_ray_cast(obj, matrix):
+        """Wrapper for ray casting that moves the ray into object space"""
+
+        # get the ray relative to the object
+        matrix_inv = matrix.inverted()
+        ray_origin_obj = matrix_inv * ray_origin
+        ray_target_obj = matrix_inv * ray_target
+
+        # cast the ray
+        hit, normal, face_index = obj.ray_cast(ray_origin_obj, ray_target_obj)
+
+        if face_index != -1:
+            return hit, normal, face_index
+        else:
+            return None, None, None
+
+    # cast rays and find the closest object
+    best_length_squared = ray_max * ray_max
+    best_obj = None
+
+    for obj, matrix in visible_objects_and_duplis():
+        if obj.type == 'MESH':
+            hit, normal, face_index = obj_ray_cast(obj, matrix)
+            if hit is not None:
+                length_squared = (hit - ray_origin).length_squared
+                if length_squared < best_length_squared:
+                    best_length_squared = length_squared
+                    best_obj = obj
+
+    # now we have the object under the mouse cursor,
+    # we could do lots of stuff but for the example just select.
+    if best_obj is not None:
+        best_obj.select = True
+
+
+class ViewOperatorRayCast(bpy.types.Operator):
+    """Modal object selection with a ray cast"""
+    bl_idname = "view3d.modal_operator_raycast"
+    bl_label = "RayCast View Operator"
+
+    def modal(self, context, event):
+        if event.type in {'MIDDLEMOUSE', 'WHEELUPMOUSE', 'WHEELDOWNMOUSE'}:
+            # allow navigation
+            return {'PASS_THROUGH'}
+        elif event.type == 'LEFTMOUSE':
+            main(context, event)
+            return {'RUNNING_MODAL'}
+        elif event.type in {'RIGHTMOUSE', 'ESC'}:
+            return {'CANCELLED'}
+
+        return {'RUNNING_MODAL'}
+
+    def invoke(self, context, event):
+        if context.space_data.type == 'VIEW_3D':
+            context.window_manager.modal_handler_add(self)
+            return {'RUNNING_MODAL'}
+        else:
+            self.report({'WARNING'}, "Active space must be a View3d")
+            return {'CANCELLED'}
+
+
+def register():
+    bpy.utils.register_class(ViewOperatorRayCast)
+
+
+def unregister():
+    bpy.utils.unregister_class(ViewOperatorRayCast)
+
+
+if __name__ == "__main__":
+    register()
index 5962651995b0233ccc0fbedb4ab7930b5215f622..9c19993a38a51450a178dc492722081df28cc3e0 100644 (file)
@@ -33,7 +33,7 @@ def main(operator, context):
 
 
 class NodeOperator(bpy.types.Operator):
-    '''Tooltip'''
+    """Tooltip"""
     bl_idname = "node.simple_operator"
     bl_label = "Simple Node Operator"
 
index 05d9afc0ad1d46ba32876bf75f66b76905ad9819..715daa3a8b441a4ecccef447ddcf2a29c993aa42 100644 (file)
@@ -7,7 +7,7 @@ def main(context):
 
 
 class SimpleOperator(bpy.types.Operator):
-    '''Tooltip'''
+    """Tooltip"""
     bl_idname = "object.simple_operator"
     bl_label = "Simple Object Operator"
 
index 93fec117fa10bb2be1bef26ccbae9eb79c450923..fdd0b993f8b448222773d7b10332c08adb655d3b 100644 (file)
@@ -27,7 +27,7 @@ def main(context):
 
 
 class UvOperator(bpy.types.Operator):
-    '''UV Operator description'''
+    """UV Operator description"""
     bl_idname = "uv.simple_operator"
     bl_label = "Simple UV Operator"
 
index cfb204cd52ae8fa6d6f448c36c188bd5e4b40d6f..fdd126b28c6a2f9593ffdc857d2cbe8392ea66cf 100644 (file)
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 Import ('env')
 
-SConscript(['blender/SConscript', 'creator/SConscript'])
+SConscript(['blender/SConscript'])
 
 if env['WITH_BF_GAMEENGINE']:
     SConscript (['gameengine/SConscript'])
index a0d840b5de6362f6978ee3cbe2a4fb69bb811a55..3c75666857874b2cbed41ac41443ac0ef674ae65 100644 (file)
@@ -95,12 +95,10 @@ add_subdirectory(blenkernel)
 add_subdirectory(blenlib)
 add_subdirectory(bmesh)
 add_subdirectory(render)
-add_subdirectory(compositor)
 add_subdirectory(blenfont)
 add_subdirectory(blenloader)
 add_subdirectory(ikplugin)
 add_subdirectory(gpu)
-add_subdirectory(opencl)
 add_subdirectory(imbuf)
 add_subdirectory(avi)
 add_subdirectory(nodes)
@@ -108,6 +106,11 @@ add_subdirectory(modifiers)
 add_subdirectory(makesdna)
 add_subdirectory(makesrna)
 
+if(WITH_COMPOSITOR)
+       add_subdirectory(opencl)  # later on this may be used more generally
+       add_subdirectory(compositor)
+endif()
+
 if(WITH_IMAGE_OPENEXR)
        add_subdirectory(imbuf/intern/openexr)
 endif()
index c2ca6eb5ae59087a584b68d9ef42dc1168a3896c..e1f81f9aaba3195bf0401933180a014dc12e511a 100644 (file)
@@ -8,11 +8,9 @@ SConscript(['avi/SConscript',
             'blenlib/SConscript',
             'blenloader/SConscript',
             'gpu/SConscript',
-            'opencl/SConscript',
             'editors/SConscript',
             'imbuf/SConscript',
             'makesdna/SConscript',
-            'compositor/SConscript',
             'render/SConscript',
             'nodes/SConscript',
             'modifiers/SConscript',
@@ -39,3 +37,7 @@ if env['WITH_BF_QUICKTIME']:
 
 if env['WITH_BF_COLLADA']:
     SConscript (['collada/SConscript'])
+    
+if env['WITH_BF_COMPOSITOR']:
+    SConscript (['compositor/SConscript',
+                 'opencl/SConscript'])
index e20a74e713cb6987839cbf61837d4ab16129ba8a..d072ffb72ecadcc80007f15af129a2aa72ddfd3a 100644 (file)
@@ -811,7 +811,7 @@ void calchandles_fcurve(FCurve *fcu)
                if (bezt->vec[2][0] < bezt->vec[1][0]) bezt->vec[2][0] = bezt->vec[1][0];
                
                /* calculate auto-handles */
-               BKE_nurb_handle_calc(bezt, prev, next, 1);  /* 1==special autohandle */
+               BKE_nurb_handle_calc(bezt, prev, next, 1);  /* (1 == special) autohandle */
                
                /* for automatic ease in and out */
                if (ELEM(bezt->h1, HD_AUTO, HD_AUTO_ANIM) && ELEM(bezt->h2, HD_AUTO, HD_AUTO_ANIM)) {
index deb294a6738a0770b5ecd2cafba0272d0229da03..bed70bbd7808595485263474b4aff0b8aa1b0be8 100644 (file)
@@ -771,7 +771,7 @@ void do_rel_key(const int start, int end, const int tot, char *basispoin, Key *k
                                        
                                        ofsp = ofs;
                                        
-                                       while (cp[0]) {     /* cp[0]==amount */
+                                       while (cp[0]) {  /* (cp[0] == amount) */
                                                
                                                switch (cp[1]) {
                                                        case IPO_FLOAT:
@@ -936,7 +936,7 @@ static void do_key(const int start, int end, const int tot, char *poin, Key *key
                
                ofsp = ofs;
 
-               while (cp[0]) {     /* cp[0]==amount */
+               while (cp[0]) {  /* (cp[0] == amount) */
 
                        switch (cp[1]) {
                                case IPO_FLOAT:
index a0e72af81316adfac6da28ae98e9bd75d0976c11..eb2070bce76119383911f0af8fa8d377d25d7455 100644 (file)
@@ -545,90 +545,90 @@ typedef struct  FT_Outline_
 
 #endif
 
-/***//*
-from: http://www.freetype.org/freetype2/docs/glyphs/glyphs-6.html#section-1
-
-Vectorial representation of Freetype glyphs
-
-The source format of outlines is a collection of closed paths called "contours". Each contour is
-made of a series of line segments and bezier arcs. Depending on the file format, these can be
-second-order or third-order polynomials. The former are also called quadratic or conic arcs, and
-they come from the TrueType format. The latter are called cubic arcs and mostly come from the
-Type1 format.
-
-Each arc is described through a series of start, end and control points. Each point of the outline
-has a specific tag which indicates wether it is used to describe a line segment or an arc.
-
-
-The following rules are applied to decompose the contour's points into segments and arcs :
-
-# two successive "on" points indicate a line segment joining them.
-
-# one conic "off" point amidst two "on" points indicates a conic bezier arc, the "off" point being
-  the control point, and the "on" ones the start and end points.
-
-# Two successive cubic "off" points amidst two "on" points indicate a cubic bezier arc. There must
-  be exactly two cubic control points and two on points for each cubic arc (using a single cubic 
-  "off" point between two "on" points is forbidden, for example).
-
-# finally, two successive conic "off" points forces the rasterizer to create (during the scan-line
-  conversion process exclusively) a virtual "on" point amidst them, at their exact middle. This
-  greatly facilitates the definition of successive conic bezier arcs. Moreover, it's the way
-  outlines are described in the TrueType specification.
-
-Note that it is possible to mix conic and cubic arcs in a single contour, even though no current
-font driver produces such outlines.
-
-                                                                 *            # on      
                                                                                         * off
                                                         __---__
-  #-__                      _--       -_
        --__                _-            -
                --__           #               \
                        --__                        #
                                -#
                                                 Two "on" points
-   Two "on" points       and one "conic" point
                                                      between them
-
-
-
                              *
-  #            __      Two "on" points with two "conic"
-   \          -  -     points between them. The point
      \        /    \    marked '0' is the middle of the
       -      0      \   "off" points, and is a 'virtual'
        -_  _-       #   "on" point where the curve passes.
              --             It does not appear in the point
                                         list.
              *
-
-
-
-
              *                # on
                                 *     * off
               __---__
        _--       -_
      _-            -
-   #               \
                                      #
-
-     Two "on" points
-   and two "cubic" point
        between them
-
-
-Each glyph's original outline points are located on a grid of indivisible units. The points are stored
-in the font file as 16-bit integer grid coordinates, with the grid origin's being at (0, 0); they thus
-range from -16384 to 16383.
-
-Convert conic to bezier arcs:
-Conic P0 P1 P2
-Bezier B0 B1 B2 B3
-B0=P0
-B1=(P0+2*P1)/3
-B2=(P2+2*P1)/3
-B3=P2
-
-*//****/
+/*
+ * from: http://www.freetype.org/freetype2/docs/glyphs/glyphs-6.html#section-1
+ *
+ * Vectorial representation of Freetype glyphs
+ *
+ * The source format of outlines is a collection of closed paths called "contours". Each contour is
+ * made of a series of line segments and bezier arcs. Depending on the file format, these can be
+ * second-order or third-order polynomials. The former are also called quadratic or conic arcs, and
+ * they come from the TrueType format. The latter are called cubic arcs and mostly come from the
+ * Type1 format.
+ *
+ * Each arc is described through a series of start, end and control points. Each point of the outline
+ * has a specific tag which indicates wether it is used to describe a line segment or an arc.
+ *
+ *
+ * The following rules are applied to decompose the contour's points into segments and arcs :
+ *
+ * # two successive "on" points indicate a line segment joining them.
+ *
+ * # one conic "off" point amidst two "on" points indicates a conic bezier arc, the "off" point being
*   the control point, and the "on" ones the start and end points.
+ *
+ * # Two successive cubic "off" points amidst two "on" points indicate a cubic bezier arc. There must
+ *   be exactly two cubic control points and two on points for each cubic arc (using a single cubic
*   "off" point between two "on" points is forbidden, for example).
+ *
+ * # finally, two successive conic "off" points forces the rasterizer to create (during the scan-line
*   conversion process exclusively) a virtual "on" point amidst them, at their exact middle. This
*   greatly facilitates the definition of successive conic bezier arcs. Moreover, it's the way
*   outlines are described in the TrueType specification.
+ *
+ * Note that it is possible to mix conic and cubic arcs in a single contour, even though no current
+ * font driver produces such outlines.
+ *
+ *                                   *            # on
*                                                * off
*                                __---__
*   #-__                      _--       -_
*       --__                _-            -
*           --__           #               \
*               --__                        #
*                   -#
*                            Two "on" points
*    Two "on" points       and one "conic" point
*                             between them
+ *
+ *
+ *
*                 *
*   #            __      Two "on" points with two "conic"
*    \          -  -     points between them. The point
*     \        /    \    marked '0' is the middle of the
*      -      0      \   "off" points, and is a 'virtual'
*       -_  _-       #   "on" point where the curve passes.
*         --             It does not appear in the point
*                        list.
*         *
+ *
+ *
+ *
+ *
*         *                # on
*                    *     * off
*          __---__
*       _--       -_
*     _-            -
*    #               \
*                     #
+ *
*      Two "on" points
*    and two "cubic" point
*       between them
+ *
+ *
+ * Each glyph's original outline points are located on a grid of indivisible units. The points are stored
+ * in the font file as 16-bit integer grid coordinates, with the grid origin's being at (0, 0); they thus
+ * range from -16384 to 16383.
+ *
+ * Convert conic to bezier arcs:
+ * Conic P0 P1 P2
+ * Bezier B0 B1 B2 B3
+ * B0=P0
+ * B1=(P0+2*P1)/3
+ * B2=(P2+2*P1)/3
+ * B3=P2
+ *
+ */
index d35624e84d26e90a30e587cf43650a19df2bc0f4..e51d0d2645f14ecdaa7fbd647bde6b84d947c80e 100644 (file)
@@ -901,8 +901,8 @@ static int getLowestRoot(const float a, const float b, const float c, const floa
 
        // If determinant is negative it means no solutions.
        if (determinant >= 0.0f) {
-               // calculate the two roots: (if determinant == 0 then
-               // x1==x2 but lets disregard that slight optimization)
+               /* calculate the two roots: (if determinant == 0 then
+                * x1==x2 but lets disregard that slight optimization) */
                float sqrtD = (float)sqrt(determinant);
                float r1 = (-b - sqrtD) / (2.0f * a);
                float r2 = (-b + sqrtD) / (2.0f * a);
index 55428893963b8b4606494f3110178db9a03ec158..c85efc1fd9a2faffb5a78a99510cb2dd9fa3a74c 100644 (file)
@@ -1643,7 +1643,7 @@ int BLI_rebase_path(char *abs, size_t abs_len, char *rel, size_t rel_len, const
                strncat(rel, base, rel_len);
        }
 
-       /* return 2 if src=dest */
+       /* return 2 if (src == dest) */
        if (BLI_path_cmp(path, dest_path) == 0) {
                // if (G.debug & G_DEBUG) printf("%s and %s are the same file\n", path, dest_path);
                return BLI_REBASE_IDENTITY;
index 94752965f3a9f20f9a437ff0330a02d96a407172..1f0bd445831516093f1518d2012be8e6b90e0646 100644 (file)
@@ -288,7 +288,7 @@ static void mergepolysSimp(ScanFillContext *sf_ctx, PolyFill *pf1, PolyFill *pf2
 }
 
 static short testedgeside(const float v1[2], const float v2[2], const float v3[2])
-/* is v3 to the right of v1-v2 ? With exception: v3==v1 || v3==v2 */
+/* is v3 to the right of v1-v2 ? With exception: v3 == v1 || v3 == v2 */
 {
        float inp;
 
index d591f98ddc0fcdc3d402fe87442816ea67a051d0..348fa29eae79be6db99679e965b53b7dd106b59d 100644 (file)
@@ -96,7 +96,7 @@ static void *thread_tls_data;
  *         }
  *         // conditions to exit loop 
  *         if (if escape loop event) {
- *             if (BLI_available_threadslots(&lb)==maxthreads)
+ *             if (BLI_available_threadslots(&lb) == maxthreads)
  *                 break;
  *         }
  *     }
index 64f007513ede3303e566631bf16ec7101bf2fc88..bf9720fee09144ec4b1e27c5b19c9f69c1fe54bb 100644 (file)
@@ -37,7 +37,7 @@
 
 double PIL_check_seconds_timer(void) 
 {
-       static int hasperfcounter = -1; /* -1==unknown */
+       static int hasperfcounter = -1; /* (-1 == unknown) */
        static double perffreq;
 
        if (hasperfcounter == -1) {
index 639b14ff2d85ae4ad2f2312b32f19728a9714673..37e05623f2d9d0079f85fcc331fc539f50c65af6 100644 (file)
 #include <errno.h>
 
 /*
- Remark: still a weak point is the newaddress() function, that doesnt solve reading from
- multiple files at the same time
-
- (added remark: oh, i thought that was solved? will look at that... (ton)
-
-READ
-- Existing Library (Main) push or free
-- allocate new Main
-- load file
-- read SDNA
-- for each LibBlock
      - read LibBlock
      - if a Library
              - make a new Main
              - attach ID's to it
      - else
              - read associated 'direct data'
              - link direct data (internal and to LibBlock)
-- read FileGlobal
-- read USER data, only when indicated (file is ~/X.XX/startup.blend)
-- free file
-- per Library (per Main)
      - read file
      - read SDNA
      - find LibBlocks and attach IDs to Main
              - if external LibBlock
                      - search all Main's
                              - or it's already read,
                              - or not read yet
                              - or make new Main
      - per LibBlock
              - read recursive
              - read associated direct data
              - link direct data (internal and to LibBlock)
      - free file
-- per Library with unread LibBlocks
      - read file
      - read SDNA
      - per LibBlock
                         - read recursive
                         - read associated direct data
                         - link direct data (internal and to LibBlock)
              - free file
-- join all Mains
-- link all LibBlocks and indirect pointers to libblocks
-- initialize FileGlobal and copy pointers to Global
Remark: still a weak point is the newaddress() function, that doesnt solve reading from
multiple files at the same time
+ *
(added remark: oh, i thought that was solved? will look at that... (ton)
+ *
+ * READ
+ * - Existing Library (Main) push or free
+ * - allocate new Main
+ * - load file
+ * - read SDNA
+ * - for each LibBlock
*     - read LibBlock
*     - if a Library
*         - make a new Main
*         - attach ID's to it
*     - else
*         - read associated 'direct data'
*         - link direct data (internal and to LibBlock)
+ * - read FileGlobal
+ * - read USER data, only when indicated (file is ~/X.XX/startup.blend)
+ * - free file
+ * - per Library (per Main)
*     - read file
*     - read SDNA
*     - find LibBlocks and attach IDs to Main
*         - if external LibBlock
*             - search all Main's
*                 - or it's already read,
*                 - or not read yet
*                 - or make new Main
*     - per LibBlock
*         - read recursive
*         - read associated direct data
*         - link direct data (internal and to LibBlock)
*     - free file
+ * - per Library with unread LibBlocks
*     - read file
*     - read SDNA
*     - per LibBlock
*                - read recursive
*                - read associated direct data
*                - link direct data (internal and to LibBlock)
*         - free file
+ * - join all Mains
+ * - link all LibBlocks and indirect pointers to libblocks
+ * - initialize FileGlobal and copy pointers to Global
 */
 
 /* also occurs in library.c */
@@ -4426,7 +4426,7 @@ static void direct_link_modifiers(FileData *fd, ListBase *lb)
                }
                else if (md->type == eModifierType_Collision) {
                        CollisionModifierData *collmd = (CollisionModifierData *)md;
-                       /*
+#if 0
                        // TODO: CollisionModifier should use pointcache 
                        // + have proper reset events before enabling this
                        collmd->x = newdataadr(fd, collmd->x);
@@ -4436,7 +4436,7 @@ static void direct_link_modifiers(FileData *fd, ListBase *lb)
                        collmd->current_x = MEM_callocN(sizeof(MVert)*collmd->numverts, "current_x");
                        collmd->current_xnew = MEM_callocN(sizeof(MVert)*collmd->numverts, "current_xnew");
                        collmd->current_v = MEM_callocN(sizeof(MVert)*collmd->numverts, "current_v");
-                       */
+#endif
                        
                        collmd->x = NULL;
                        collmd->xnew = NULL;
@@ -5496,7 +5496,7 @@ void lib_link_screen_restore(Main *newmain, bScreen *curscreen, Scene *curscene)
                                                v3d->localvd->camera = sc->scene->camera;
                                                
                                                /* localview can become invalid during undo/redo steps, so we exit it when no could be found */
-                                               /* XXX  regionlocalview ?
+#if 0                                  /* XXX  regionlocalview ? */
                                                for (base= sc->scene->base.first; base; base= base->next) {
                                                        if (base->lay & v3d->lay) break;
                                                }
@@ -5506,7 +5506,7 @@ void lib_link_screen_restore(Main *newmain, bScreen *curscreen, Scene *curscene)
                                                        MEM_freeN(v3d->localvd); 
                                                        v3d->localvd= NULL;
                                                }
-                                               */
+#endif
                                        }
                                        else if (v3d->scenelock) v3d->lay = sc->scene->lay;
                                        
@@ -7421,7 +7421,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
 
        if (main->versionfile < 263) {
                /* set fluidsim rate. the version patch for this in 2.62 was wrong, so
-               try to correct it, if rate is 0.0 that's likely not intentional */
+                * try to correct it, if rate is 0.0 that's likely not intentional */
                Object *ob;
 
                for (ob = main->object.first; ob; ob = ob->id.next) {
index bfaa526b9953e5b308a6431ca59f2a0b4fb3ae93..ca071e0cc2545e0f147b8d7c9405747393616268 100644 (file)
@@ -2580,8 +2580,8 @@ void blo_do_versions_250(FileData *fd, Library *lib, Main *main)
                                                act->type = act->otype = ACT_ACTION;
 
                                                /* Fix for converting 2.4x files: if we don't have an action, but we have an
-                                                  object IPO, then leave the actuator as an IPO actuator for now and let the
-                                                  IPO conversion code handle it */
+                                                * object IPO, then leave the actuator as an IPO actuator for now and let the
+                                                * IPO conversion code handle it */
                                                if (ob->ipo && !aa->act)
                                                        act->type = ACT_IPO;
                                        }
index f257994bc1c92ffad3886e504bf2e923117cfe38..02b4537e9c851a45816d3b60ca7dc02e70fb54c0 100644 (file)
@@ -1380,14 +1380,14 @@ static void write_modifiers(WriteData *wd, ListBase *modbase)
                } 
                else if (md->type==eModifierType_Collision) {
                        
-                       /*
+#if 0
                        CollisionModifierData *collmd = (CollisionModifierData*) md;
                        // TODO: CollisionModifier should use pointcache 
                        // + have proper reset events before enabling this
                        writestruct(wd, DATA, "MVert", collmd->numverts, collmd->x);
                        writestruct(wd, DATA, "MVert", collmd->numverts, collmd->xnew);
                        writestruct(wd, DATA, "MFace", collmd->numfaces, collmd->mfaces);
-                       */
+#endif
                }
                else if (md->type==eModifierType_MeshDeform) {
                        MeshDeformModifierData *mmd = (MeshDeformModifierData*) md;
index 8d9f2ed7336d833f006fe0bda90cd6118055259e..385572cceff9e3038a49f396ef4460bed65350a9 100644 (file)
@@ -318,10 +318,10 @@ static void bm_rationalize_normals(BMesh *bm, int undo)
                return;
        }
        
-       BMO_op_initf(bm, &bmop, "righthandfaces faces=%af do_flip=%b", FALSE);
+       BMO_op_initf(bm, &bmop, "recalc_face_normals faces=%af do_flip=%b", FALSE);
        
        BMO_push(bm, &bmop);
-       bmo_righthandfaces_exec(bm, &bmop);
+       bmo_recalc_face_normals_exec(bm, &bmop);
        
        BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
                BM_elem_flag_set(f, BM_ELEM_TAG, BMO_elem_flag_test(bm, f, FACE_FLIP));
index f606347baf6e4c2de6cf8b6aeb6488638b279da1..1d3385eaab636de6f0d55583d5aa42a9768d8b7c 100644 (file)
@@ -97,8 +97,8 @@
  *
  * Smooths vertices by using a basic vertex averaging scheme.
  */
-static BMOpDefine bmo_vertexsmooth_def = {
-       "vertexsmooth",
+static BMOpDefine bmo_smooth_vert_def = {
+       "smooth_vert",
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, //input vertices
         {BMO_OP_SLOT_BOOL, "mirror_clip_x"}, //set vertices close to the x axis before the operation to 0
         {BMO_OP_SLOT_BOOL, "mirror_clip_y"}, //set vertices close to the y axis before the operation to 0
@@ -106,7 +106,7 @@ static BMOpDefine bmo_vertexsmooth_def = {
         {BMO_OP_SLOT_FLT, "clipdist"}, //clipping threshod for the above three slots
        {0} /* null-terminating sentinel */,
        },
-       bmo_vertexsmooth_exec,
+       bmo_smooth_vert_exec,
        0
 };
 
@@ -116,13 +116,13 @@ static BMOpDefine bmo_vertexsmooth_def = {
  * Computes an "outside" normal for the specified input faces.
  */
 
-static BMOpDefine bmo_righthandfaces_def = {
-       "righthandfaces",
+static BMOpDefine bmo_recalc_face_normals_def = {
+       "recalc_face_normals",
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"},
         {BMO_OP_SLOT_BOOL, "do_flip"}, //internal flag, used by bmesh_rationalize_normals
         {0} /* null-terminating sentinel */,
        },
-       bmo_righthandfaces_exec,
+       bmo_recalc_face_normals_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES,
 };
 
@@ -136,15 +136,15 @@ static BMOpDefine bmo_righthandfaces_def = {
  * if usefaces is 0 then geomout spits out verts and edges,
  * otherwise it spits out faces.
  */
-static BMOpDefine bmo_regionextend_def = {
-       "regionextend",
+static BMOpDefine bmo_region_extend_def = {
+       "region_extend",
        {{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, //input geometry
         {BMO_OP_SLOT_ELEMENT_BUF, "geomout"}, //output slot, computed boundary geometry.
         {BMO_OP_SLOT_BOOL, "constrict"}, //find boundary inside the regions, not outside.
         {BMO_OP_SLOT_BOOL, "use_faces"}, //extend from faces instead of edges
         {0} /* null-terminating sentinel */,
        },
-       bmo_regionextend_exec,
+       bmo_region_extend_exec,
        0
 };
 
@@ -154,14 +154,14 @@ static BMOpDefine bmo_regionextend_def = {
  * Rotates edges topologically.  Also known as "spin edge" to some people.
  * Simple example: [/] becomes [|] then [\].
  */
-static BMOpDefine bmo_edgerotate_def = {
-       "edgerotate",
+static BMOpDefine bmo_rotate_edges_def = {
+       "rotate_edges",
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, //input edges
         {BMO_OP_SLOT_ELEMENT_BUF, "edgeout"}, //newly spun edges
         {BMO_OP_SLOT_BOOL, "ccw"}, //rotate edge counter-clockwise if true, othewise clockwise
         {0} /* null-terminating sentinel */,
        },
-       bmo_edgerotate_exec,
+       bmo_rotate_edges_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
 };
 
@@ -171,12 +171,12 @@ static BMOpDefine bmo_edgerotate_def = {
  * Reverses the winding (vertex order) of faces.  This has the effect of
  * flipping the normal.
  */
-static BMOpDefine bmo_reversefaces_def = {
-       "reversefaces",
+static BMOpDefine bmo_reverse_faces_def = {
+       "reverse_faces",
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, //input faces
         {0} /* null-terminating sentinel */,
        },
-       bmo_reversefaces_exec,
+       bmo_reverse_faces_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES,
 };
 
@@ -186,14 +186,14 @@ static BMOpDefine bmo_reversefaces_def = {
  * Splits input edges (but doesn't do anything else).
  * This creates a 2-valence vert.
  */
-static BMOpDefine bmo_edgebisect_def = {
-       "edgebisect",
+static BMOpDefine bmo_bisect_edges_def = {
+       "bisect_edges",
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, //input edges
         {BMO_OP_SLOT_INT, "numcuts"}, //number of cuts
         {BMO_OP_SLOT_ELEMENT_BUF, "outsplit"}, //newly created vertices and edges
         {0} /* null-terminating sentinel */,
        },
-       bmo_edgebisect_exec,
+       bmo_bisect_edges_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
 };
 
@@ -225,17 +225,17 @@ static BMOpDefine bmo_mirror_def = {
  * Takes input verts and find vertices they should weld to.  Outputs a
  * mapping slot suitable for use with the weld verts bmop.
  *
- * If keepverts is used, vertices outside that set can only be merged
+ * If keep_verts is used, vertices outside that set can only be merged
  * with vertices in that set.
  */
-static BMOpDefine bmo_finddoubles_def = {
-       "finddoubles",
+static BMOpDefine bmo_find_doubles_def = {
+       "find_doubles",
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, //input vertices
-        {BMO_OP_SLOT_ELEMENT_BUF, "keepverts"}, //list of verts to keep
+        {BMO_OP_SLOT_ELEMENT_BUF, "keep_verts"}, //list of verts to keep
         {BMO_OP_SLOT_FLT,         "dist"}, //minimum distance
         {BMO_OP_SLOT_MAPPING, "targetmapout"},
         {0, /* null-terminating sentinel */}},
-       bmo_finddoubles_exec,
+       bmo_find_doubles_exec,
        0,
 };
 
@@ -305,11 +305,11 @@ static BMOpDefine bmo_pointmerge_facedata_def = {
  * the bounding box center. (I know, it's not averaging but
  * the vert_snap_to_bb_center is just too long).
  */
-static BMOpDefine bmo_vert_average_facedata_def = {
-       "vert_average_facedata",
+static BMOpDefine bmo_average_vert_facedata_def = {
+       "average_vert_facedata",
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertice */
         {0, /* null-terminating sentinel */}},
-       bmo_vert_average_facedata_exec,
+       bmo_average_vert_facedata_exec,
        0,
 };
 
@@ -321,7 +321,7 @@ static BMOpDefine bmo_vert_average_facedata_def = {
 static BMOpDefine bmo_pointmerge_def = {
        "pointmerge",
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertice */
-        {BMO_OP_SLOT_VEC,         "mergeco"},
+        {BMO_OP_SLOT_VEC,         "merge_co"},
         {0, /* null-terminating sentinel */}},
        bmo_pointmerge_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES,
@@ -347,11 +347,11 @@ static BMOpDefine bmo_collapse_uvs_def = {
  * use or will use this bmop).  You pass in mappings from vertices to the vertices
  * they weld with.
  */
-static BMOpDefine bmo_weldverts_def = {
-       "weldverts",
+static BMOpDefine bmo_weld_verts_def = {
+       "weld_verts",
        {{BMO_OP_SLOT_MAPPING, "targetmap"}, /* maps welded vertices to verts they should weld to */
         {0, /* null-terminating sentinel */}},
-       bmo_weldverts_exec,
+       bmo_weld_verts_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES,
 };
 
@@ -361,12 +361,12 @@ static BMOpDefine bmo_weldverts_def = {
  * Creates a single vertex; this bmop was necessary
  * for click-create-vertex.
  */
-static BMOpDefine bmo_makevert_def = {
-       "makevert",
+static BMOpDefine bmo_create_vert_def = {
+       "create_vert",
        {{BMO_OP_SLOT_VEC, "co"}, //the coordinate of the new vert
         {BMO_OP_SLOT_ELEMENT_BUF, "newvertout"}, //the new vert
         {0, /* null-terminating sentinel */}},
-       bmo_makevert_exec,
+       bmo_create_vert_exec,
        0,
 };
 
@@ -572,13 +572,13 @@ static BMOpDefine bmo_mesh_to_bmesh_def = {
  *
  * Extrudes faces individually.
  */
-static BMOpDefine bmo_extrude_indivface_def = {
-       "extrude_face_indiv",
+static BMOpDefine bmo_extrude_discrete_faces_def = {
+       "extrude_discrete_faces",
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, //input faces
         {BMO_OP_SLOT_ELEMENT_BUF, "faceout"}, //output faces
         {BMO_OP_SLOT_ELEMENT_BUF, "skirtout"}, //output skirt geometry, faces and edges
         {0} /* null-terminating sentinel */},
-       bmo_extrude_face_indiv_exec,
+       bmo_extrude_discrete_faces_exec,
        0
 };
 
@@ -612,12 +612,12 @@ static BMOpDefine bmo_extrude_vert_indiv_def = {
        0
 };
 
-static BMOpDefine bmo_connectverts_def = {
-       "connectverts",
+static BMOpDefine bmo_connect_verts_def = {
+       "connect_verts",
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"},
         {BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},
         {0} /* null-terminating sentinel */},
-       bmo_connectverts_exec,
+       bmo_connect_verts_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
 };
 
@@ -691,8 +691,8 @@ static BMOpDefine bmo_triangulate_def = {
        BMO_OP_FLAG_UNTAN_MULTIRES
 };
 
-static BMOpDefine bmo_esubd_def = {
-       "esubd",
+static BMOpDefine bmo_subdivide_edges_def = {
+       "subdivide_edges",
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"},
         {BMO_OP_SLOT_FLT, "smooth"},
         {BMO_OP_SLOT_FLT, "fractal"},
@@ -714,21 +714,21 @@ static BMOpDefine bmo_esubd_def = {
 
         {0} /* null-terminating sentinel */,
        },
-       bmo_esubd_exec,
+       bmo_subdivide_edges_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
 };
 
-static BMOpDefine bmo_del_def = {
-       "del",
+static BMOpDefine bmo_delete_def = {
+       "delete",
        {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
         {BMO_OP_SLOT_INT, "context"},
         {0} /* null-terminating sentinel */},
-       bmo_del_exec,
+       bmo_delete_exec,
        0
 };
 
-static BMOpDefine bmo_dupe_def = {
-       "dupe",
+static BMOpDefine bmo_duplicate_def = {
+       "duplicate",
        {{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
         {BMO_OP_SLOT_ELEMENT_BUF, "origout"},
         {BMO_OP_SLOT_ELEMENT_BUF, "newout"},
@@ -739,7 +739,7 @@ static BMOpDefine bmo_dupe_def = {
         {BMO_OP_SLOT_MAPPING, "isovertmap"},
         {BMO_OP_SLOT_PNT, "dest"}, /* destination bmesh, if NULL will use current on */
         {0} /* null-terminating sentinel */},
-       bmo_dupe_exec,
+       bmo_duplicate_exec,
        0
 };
 
@@ -783,14 +783,14 @@ static BMOpDefine bmo_spin_def = {
  *
  * Find similar faces (area/material/perimeter, ...).
  */
-static BMOpDefine bmo_similarfaces_def = {
-       "similarfaces",
+static BMOpDefine bmo_similar_faces_def = {
+       "similar_faces",
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
         {BMO_OP_SLOT_ELEMENT_BUF, "faceout"}, /* output faces */
         {BMO_OP_SLOT_INT, "type"},                     /* type of selection */
         {BMO_OP_SLOT_FLT, "thresh"},           /* threshold of selection */
         {0} /* null-terminating sentinel */},
-       bmo_similarfaces_exec,
+       bmo_similar_faces_exec,
        0
 };
 
@@ -799,14 +799,14 @@ static BMOpDefine bmo_similarfaces_def = {
  *
  *  Find similar edges (length, direction, edge, seam, ...).
  */
-static BMOpDefine bmo_similaredges_def = {
-       "similaredges",
+static BMOpDefine bmo_similar_edges_def = {
+       "similar_edges",
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edges */
         {BMO_OP_SLOT_ELEMENT_BUF, "edgeout"}, /* output edges */
         {BMO_OP_SLOT_INT, "type"},                     /* type of selection */
         {BMO_OP_SLOT_FLT, "thresh"},           /* threshold of selection */
         {0} /* null-terminating sentinel */},
-       bmo_similaredges_exec,
+       bmo_similar_edges_exec,
        0
 };
 
@@ -815,14 +815,14 @@ static BMOpDefine bmo_similaredges_def = {
  *
  * Find similar vertices (normal, face, vertex group, ...).
  */
-static BMOpDefine bmo_similarverts_def = {
-       "similarverts",
+static BMOpDefine bmo_similar_verts_def = {
+       "similar_verts",
        {{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertices */
         {BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output vertices */
         {BMO_OP_SLOT_INT, "type"},                     /* type of selection */
         {BMO_OP_SLOT_FLT, "thresh"},           /* threshold of selection */
         {0} /* null-terminating sentinel */},
-       bmo_similarverts_exec,
+       bmo_similar_verts_exec,
        0
 };
 
@@ -830,12 +830,12 @@ static BMOpDefine bmo_similarverts_def = {
  * uv rotation
  * cycle the uvs
  */
-static BMOpDefine bmo_face_rotateuvs_def = {
-       "face_rotateuvs",
+static BMOpDefine bmo_rotate_uvs_def = {
+       "rotate_uvs",
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
         {BMO_OP_SLOT_INT, "dir"},                      /* direction */
         {0} /* null-terminating sentinel */},
-       bmo_face_rotateuvs_exec,
+       bmo_rotate_uvs_exec,
        0
 };
 
@@ -843,11 +843,11 @@ static BMOpDefine bmo_face_rotateuvs_def = {
  * uv reverse
  * reverse the uvs
  */
-static BMOpDefine bmo_face_reverseuvs_def = {
-       "face_reverseuvs",
+static BMOpDefine bmo_reverse_uvs_def = {
+       "reverse_uvs",
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
         {0} /* null-terminating sentinel */},
-       bmo_face_reverseuvs_exec,
+       bmo_reverse_uvs_exec,
        0
 };
 
@@ -855,12 +855,12 @@ static BMOpDefine bmo_face_reverseuvs_def = {
  * color rotation
  * cycle the colors
  */
-static BMOpDefine bmo_face_rotatecolors_def = {
-       "face_rotatecolors",
+static BMOpDefine bmo_rotate_colors_def = {
+       "rotate_colors",
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
         {BMO_OP_SLOT_INT, "dir"},                      /* direction */
         {0} /* null-terminating sentinel */},
-       bmo_rotatecolors_exec,
+       bmo_rotate_colors_exec,
        0
 };
 
@@ -868,11 +868,11 @@ static BMOpDefine bmo_face_rotatecolors_def = {
  * color reverse
  * reverse the colors
  */
-static BMOpDefine bmo_face_reversecolors_def = {
-       "face_reversecolors",
+static BMOpDefine bmo_reverse_colors_def = {
+       "reverse_colors",
        {{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
         {0} /* null-terminating sentinel */},
-       bmo_face_reversecolors_exec,
+       bmo_reverse_colors_exec,
        0
 };
 
@@ -881,14 +881,14 @@ static BMOpDefine bmo_face_reversecolors_def = {
  *
  * Find similar vertices (normal, face, vertex group, ...).
  */
-static BMOpDefine bmo_vertexshortestpath_def = {
-       "vertexshortestpath",
+static BMOpDefine bmo_shortest_path_def = {
+       "shortest_path",
        {{BMO_OP_SLOT_ELEMENT_BUF, "startv"}, /* start vertex */
         {BMO_OP_SLOT_ELEMENT_BUF, "endv"}, /* end vertex */
         {BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output vertices */
         {BMO_OP_SLOT_INT, "type"},                     /* type of selection */
         {0} /* null-terminating sentinel */},
-       bmo_vertexshortestpath_exec,
+       bmo_shortest_path_exec,
        0
 };
 
@@ -897,15 +897,15 @@ static BMOpDefine bmo_vertexshortestpath_def = {
  *
  * Disconnects faces along input edges.
  */
-static BMOpDefine bmo_edgesplit_def = {
-       "edgesplit",
+static BMOpDefine bmo_split_edges_def = {
+       "split_edges",
        {{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edges */
         {BMO_OP_SLOT_ELEMENT_BUF, "edgeout"}, /* old output disconnected edges */
         /* needed for vertex rip so we can rip only half an edge at a boundary wich would otherwise split off */
         {BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* optional tag verts, use to have greater control of splits */
         {BMO_OP_SLOT_BOOL,        "use_verts"}, /* use 'verts' for splitting, else just find verts to split from edges */
         {0} /* null-terminating sentinel */},
-       bmo_edgesplit_exec,
+       bmo_split_edges_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
 };
 
@@ -1034,7 +1034,7 @@ static BMOpDefine bmo_bevel_def = {
        {{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, /* input edges and vertices */
         {BMO_OP_SLOT_ELEMENT_BUF, "face_spans"}, /* new geometry */
         {BMO_OP_SLOT_ELEMENT_BUF, "face_holes"}, /* new geometry */
-        {BMO_OP_SLOT_BOOL, "use_lengths"}, /* grab edge lengths from a PROP_FLT customdata laye */
+        {BMO_OP_SLOT_BOOL, "use_lengths"}, /* grab edge lengths from a PROP_FLT customdata layer */
         {BMO_OP_SLOT_BOOL, "use_even"}, /* corner vert placement: use shell/angle calculations  */
         {BMO_OP_SLOT_BOOL, "use_dist"}, /* corner vert placement: evaluate percent as a distance,
                                          * modifier uses this. We could do this as another float setting */
@@ -1134,14 +1134,14 @@ static BMOpDefine bmo_wireframe_def = {
  *
  * Translates vertes along an edge
  */
-static BMOpDefine bmo_vertex_slide_def = {
-       "vertex_slide",
+static BMOpDefine bmo_slide_vert_def = {
+       "slide_vert",
        {{BMO_OP_SLOT_ELEMENT_BUF, "vert"},
         {BMO_OP_SLOT_ELEMENT_BUF, "edge"},
         {BMO_OP_SLOT_ELEMENT_BUF, "vertout"},
         {BMO_OP_SLOT_FLT, "distance_t"},
         {0} /* null-terminating sentinel */},
-       bmo_vertex_slide_exec,
+       bmo_slide_vert_exec,
        BMO_OP_FLAG_UNTAN_MULTIRES
 };
 
@@ -1176,75 +1176,76 @@ static BMOpDefine bmo_convex_hull_def = {
 };
 
 BMOpDefine *opdefines[] = {
-       &bmo_split_def,
-       &bmo_spin_def,
-       &bmo_dupe_def,
-       &bmo_del_def,
-       &bmo_esubd_def,
-       &bmo_triangulate_def,
-       &bmo_dissolve_faces_def,
-       &bmo_dissolve_edges_def,
+       &bmo_automerge_def,
+       &bmo_average_vert_facedata_def,
+       &bmo_beautify_fill_def,
+       &bmo_bevel_def,
+       &bmo_bisect_edges_def,
+       &bmo_bmesh_to_mesh_def,
+       &bmo_bridge_loops_def,
+       &bmo_collapse_def,
+       &bmo_collapse_uvs_def,
+       &bmo_connect_verts_def,
+       &bmo_contextual_create_def,
+       &bmo_convex_hull_def,
+       &bmo_create_circle_def,
+       &bmo_create_cone_def,
+       &bmo_create_cube_def,
+       &bmo_create_grid_def,
+       &bmo_create_icosphere_def,
+       &bmo_create_monkey_def,
+       &bmo_create_uvsphere_def,
+       &bmo_create_vert_def,
+       &bmo_delete_def,
        &bmo_dissolve_edge_loop_def,
-       &bmo_dissolve_verts_def,
+       &bmo_dissolve_edges_def,
+       &bmo_dissolve_faces_def,
        &bmo_dissolve_limit_def,
+       &bmo_dissolve_verts_def,
+       &bmo_duplicate_def,
+       &bmo_edgenet_fill_def,
+       &bmo_edgenet_prepare_def,
+       &bmo_extrude_discrete_faces_def,
+       &bmo_extrude_edge_only_def,
        &bmo_extrude_face_region_def,
-       &bmo_connectverts_def,
        &bmo_extrude_vert_indiv_def,
+       &bmo_find_doubles_def,
+       &bmo_inset_def,
+       &bmo_join_triangles_def,
        &bmo_mesh_to_bmesh_def,
-       &bmo_object_load_bmesh_def,
-       &bmo_transform_def,
-       &bmo_translate_def,
-       &bmo_rotate_def,
-       &bmo_edgenet_fill_def,
-       &bmo_contextual_create_def,
-       &bmo_makevert_def,
-       &bmo_weldverts_def,
-       &bmo_remove_doubles_def,
-       &bmo_finddoubles_def,
        &bmo_mirror_def,
-       &bmo_edgebisect_def,
-       &bmo_reversefaces_def,
-       &bmo_edgerotate_def,
-       &bmo_regionextend_def,
-       &bmo_righthandfaces_def,
-       &bmo_vertexsmooth_def,
-       &bmo_extrude_edge_only_def,
-       &bmo_extrude_indivface_def,
-       &bmo_collapse_uvs_def,
+       &bmo_object_load_bmesh_def,
        &bmo_pointmerge_def,
-       &bmo_collapse_def,
-       &bmo_similarfaces_def,
-       &bmo_similaredges_def,
-       &bmo_similarverts_def,
        &bmo_pointmerge_facedata_def,
-       &bmo_vert_average_facedata_def,
-       &bmo_face_rotateuvs_def,
-       &bmo_bmesh_to_mesh_def,
-       &bmo_face_reverseuvs_def,
-       &bmo_edgenet_prepare_def,
-       &bmo_face_rotatecolors_def,
-       &bmo_face_reversecolors_def,
-       &bmo_vertexshortestpath_def,
+       &bmo_recalc_face_normals_def,
+       &bmo_region_extend_def,
+       &bmo_remove_doubles_def,
+       &bmo_reverse_colors_def,
+       &bmo_reverse_faces_def,
+       &bmo_reverse_uvs_def,
+       &bmo_rotate_colors_def,
+       &bmo_rotate_def,
+       &bmo_rotate_edges_def,
+       &bmo_rotate_uvs_def,
        &bmo_scale_def,
-       &bmo_edgesplit_def,
-       &bmo_automerge_def,
-       &bmo_create_uvsphere_def,
-       &bmo_create_grid_def,
-       &bmo_create_icosphere_def,
-       &bmo_create_monkey_def,
-       &bmo_create_cube_def,
-       &bmo_create_circle_def,
-       &bmo_create_cone_def,
-       &bmo_join_triangles_def,
-       &bmo_bevel_def,
-       &bmo_beautify_fill_def,
-       &bmo_triangle_fill_def,
-       &bmo_bridge_loops_def,
+       &bmo_shortest_path_def,
+       &bmo_similar_edges_def,
+       &bmo_similar_faces_def,
+       &bmo_similar_verts_def,
+       &bmo_slide_vert_def,
+       &bmo_smooth_vert_def,
        &bmo_solidify_def,
-       &bmo_inset_def,
+       &bmo_spin_def,
+       &bmo_split_def,
+       &bmo_split_edges_def,
+       &bmo_subdivide_edges_def,
+       &bmo_transform_def,
+       &bmo_translate_def,
+       &bmo_triangle_fill_def,
+       &bmo_triangulate_def,
+       &bmo_weld_verts_def,
        &bmo_wireframe_def,
-       &bmo_vertex_slide_def,
-       &bmo_convex_hull_def,
+
 };
 
 int bmesh_total_ops = (sizeof(opdefines) / sizeof(void *));
index b5e6534de3e3ee63af4dd89b0762fb001b469365..620800cca169e4ebe77f636c09094dda80f0852c 100644 (file)
@@ -116,7 +116,7 @@ enum {
  * for when your defining an operator with BMOpDefine.*/
 
 typedef struct BMOpSlot {
-       int slottype;
+       int slot_type;
        int len;
        int flag;
        int index; /* index within slot array */
@@ -132,16 +132,13 @@ typedef struct BMOpSlot {
 
 #define BMO_OP_MAX_SLOTS 16 /* way more than probably needed */
 
-#ifdef slots
-#undef slots
-#endif
-
 typedef struct BMOperator {
        int type;
-       int slottype;
+       int slot_type;
        int needflag;
        int flag;
-       struct BMOpSlot slots[BMO_OP_MAX_SLOTS]; void (*exec)(BMesh *bm, struct BMOperator *op);
+       struct BMOpSlot slot_args[BMO_OP_MAX_SLOTS];
+       void (*exec)(BMesh *bm, struct BMOperator *op);
        struct MemArena *arena;
 } BMOperator;
 
@@ -154,7 +151,7 @@ typedef struct BMOSlotType {
 
 typedef struct BMOpDefine {
        const char *name;
-       BMOSlotType slottypes[BMO_OP_MAX_SLOTS];
+       BMOSlotType slot_types[BMO_OP_MAX_SLOTS];
        void (*exec)(BMesh *bm, BMOperator *op);
        int flag;
 } BMOpDefine;
@@ -197,11 +194,11 @@ int BMO_mesh_disabled_flag_count(BMesh *bm, const char htype, const short oflag)
  * this system is used to execute or initialize an operator,
  * using a formatted-string system.
  *
- * for example, BMO_op_callf(bm, "del geom=%hf context=%i", BM_ELEM_SELECT, DEL_FACES);
+ * for example, BMO_op_callf(bm, "delete geom=%hf context=%i", BM_ELEM_SELECT, DEL_FACES);
  * . . .will execute the delete operator, feeding in selected faces, deleting them.
  *
  * the basic format for the format string is:
- *   [operatorname] [slotname]=%[code] [slotname]=%[code]
+ *   [operatorname] [slot_name]=%[code] [slot_name]=%[code]
  *
  * as in printf, you pass in one additional argument to the function
  * for every code.
@@ -246,10 +243,10 @@ int BMO_op_initf(BMesh *bm, BMOperator *op, const char *fmt, ...);
 int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *fmt, va_list vlist);
 
 /* test whether a named slot exists */
-int BMO_slot_exists(BMOperator *op, const char *slotname);
+int BMO_slot_exists(BMOperator *op, const char *slot_name);
 
 /* get a pointer to a slot.  this may be removed layer on from the public API. */
-BMOpSlot *BMO_slot_get(BMOperator *op, const char *slotname);
+BMOpSlot *BMO_slot_get(BMOperator *op, const char *slot_name);
 
 /* copies the data of a slot from one operator to another.  src and dst are the
  * source/destination slot codes, respectively. */
@@ -270,30 +267,30 @@ enum {
 void BMO_op_flag_enable(BMesh *bm, BMOperator *op, const int op_flag);
 void BMO_op_flag_disable(BMesh *bm, BMOperator *op, const int op_flag);
 
-void  BMO_slot_float_set(BMOperator *op, const char *slotname, const float f);
-float BMO_slot_float_get(BMOperator *op, const char *slotname);
-void  BMO_slot_int_set(BMOperator *op, const char *slotname, const int i);
-int   BMO_slot_int_get(BMOperator *op, const char *slotname);
-void  BMO_slot_bool_set(BMOperator *op, const char *slotname, const int i);
-int   BMO_slot_bool_get(BMOperator *op, const char *slotname);
+void  BMO_slot_float_set(BMOperator *op, const char *slot_name, const float f);
+float BMO_slot_float_get(BMOperator *op, const char *slot_name);
+void  BMO_slot_int_set(BMOperator *op, const char *slot_name, const int i);
+int   BMO_slot_int_get(BMOperator *op, const char *slot_name);
+void  BMO_slot_bool_set(BMOperator *op, const char *slot_name, const int i);
+int   BMO_slot_bool_get(BMOperator *op, const char *slot_name);
 
 /* don't pass in arrays that are supposed to map to elements this way.
  *
  * so, e.g. passing in list of floats per element in another slot is bad.
  * passing in, e.g. pointer to an editmesh for the conversion operator is fine
  * though. */
-void  BMO_slot_ptr_set(BMOperator *op, const char *slotname, void *p);
-void *BMO_slot_ptr_get(BMOperator *op, const char *slotname);
-void  BMO_slot_vec_set(BMOperator *op, const char *slotname, const float vec[3]);
-void  BMO_slot_vec_get(BMOperator *op, const char *slotname, float r_vec[3]);
+void  BMO_slot_ptr_set(BMOperator *op, const char *slot_name, void *p);
+void *BMO_slot_ptr_get(BMOperator *op, const char *slot_name);
+void  BMO_slot_vec_set(BMOperator *op, const char *slot_name, const float vec[3]);
+void  BMO_slot_vec_get(BMOperator *op, const char *slot_name, float r_vec[3]);
 
 /* only supports square mats */
 /* size must be 3 or 4; this api is meant only for transformation matrices.
  * note that internally the matrix is stored in 4x4 form, and it's safe to
  * call whichever BMO_Get_Mat* function you want. */
-void BMO_slot_mat_set(BMOperator *op, const char *slotname, const float *mat, int size);
-void BMO_slot_mat4_get(BMOperator *op, const char *slotname, float r_mat[4][4]);
-void BMO_slot_mat3_set(BMOperator *op, const char *slotname, float r_mat[3][3]);
+void BMO_slot_mat_set(BMOperator *op, const char *slot_name, const float *mat, int size);
+void BMO_slot_mat4_get(BMOperator *op, const char *slot_name, float r_mat[4][4]);
+void BMO_slot_mat3_set(BMOperator *op, const char *slot_name, float r_mat[3][3]);
 
 void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *op, const char htype, const short oflag);
 
@@ -303,47 +300,47 @@ void BMO_slot_buffer_append(BMOperator *output_op, const char *output_op_slot,
 
 /* puts every element of type 'type' (which is a bitmask) with tool
  * flag 'flag', into a slot. */
-void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, const char *slot_name,
                                        const char htype, const short oflag);
 
 /* puts every element of type 'type' (which is a bitmask) without tool
  * flag 'flag', into a slot. */
-void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *slot_name,
                                         const char htype, const short oflag);
 
 /* tool-flags all elements inside an element slot array with flag flag. */
-void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slot_name,
                                  const char htype, const short oflag);
 /* clears tool-flag flag from all elements inside a slot array. */
-void BMO_slot_buffer_flag_disable(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_flag_disable(BMesh *bm, BMOperator *op, const char *slot_name,
                                   const char htype, const short oflag);
 
 /* tool-flags all elements inside an element slot array with flag flag. */
-void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slot_name,
                                   const char htype, const char hflag, const char do_flush);
 /* clears tool-flag flag from all elements inside a slot array. */
-void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slot_name,
                                    const char htype, const char hflag, const char do_flush);
 
 /* puts every element of type 'type' (which is a bitmask) with header
  * flag 'flag', into a slot.  note: ignores hidden elements
  * (e.g. elements with header flag BM_ELEM_HIDDEN set).*/
 void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op,
-                                        const char *slotname,
+                                        const char *slot_name,
                                         const char htype, const char hflag);
 
 /* puts every element of type 'type' (which is a bitmask) without
  * header flag 'flag', into a slot.  note: ignores hidden elements
  * (e.g. elements with header flag BM_ELEM_HIDDEN set).*/
 void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op,
-                                         const char *slotname,
+                                         const char *slot_name,
                                          const char htype, const char hflag);
 
 /* counts number of elements inside a slot array. */
-int BMO_slot_buffer_count(BMesh *bm, BMOperator *op, const char *slotname);
-int BMO_slot_map_count(BMesh *bm, BMOperator *op, const char *slotname);
+int BMO_slot_buffer_count(BMesh *bm, BMOperator *op, const char *slot_name);
+int BMO_slot_map_count(BMesh *bm, BMOperator *op, const char *slot_name);
 
-void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slotname,
+void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name,
                          void *element, void *data, int len);
 
 /* Counts the number of edges with tool flag toolflag around
@@ -352,9 +349,14 @@ int BMO_vert_edge_flags_count(BMesh *bm, BMVert *v, const short oflag);
 
 /* flags all elements in a mapping.  note that the mapping must only have
  * bmesh elements in it.*/
-void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slot_name,
                           const char hflag, const short oflag);
 
+void *BMO_slot_buffer_alloc(BMOperator *op, const char *slot_name, const int len);
+
+void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot_name,
+                              const char htype);
+
 /* this part of the API is used to iterate over element buffer or
  * mapping slots.
  *
@@ -363,7 +365,7 @@ void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname,
  *    BMOIter oiter;
  *    BMFace *f;
  *
- *    f = BMO_iter_new(&oiter, bm, some_operator, "slotname", BM_FACE);
+ *    f = BMO_iter_new(&oiter, bm, some_operator, "slot_name", BM_FACE);
  *    for (; f; f = BMO_iter_step(&oiter)) {
  *        /do something with the face
  *    }
@@ -373,7 +375,7 @@ void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname,
  *    void *key;
  *    void *val;
  *
- *    key = BMO_iter_new(&oiter, bm, some_operator, "slotname", 0);
+ *    key = BMO_iter_new(&oiter, bm, some_operator, "slot_name", 0);
  *    for (; key; key = BMO_iter_step(&oiter)) {
  *        val = BMO_iter_map_value(&oiter);
  *        //do something with the key/val pair
@@ -396,10 +398,10 @@ typedef struct BMOIter {
        char restrictmask; /* bitwise '&' with BMHeader.htype */
 } BMOIter;
 
-void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slotname);
+void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slot_name);
 
 void *BMO_iter_new(BMOIter *iter, BMesh *bm, BMOperator *op,
-                   const char *slotname, const char restrictmask);
+                   const char *slot_name, const char restrictmask);
 void *BMO_iter_step(BMOIter *iter);
 
 /* returns a pointer to the key value when iterating over mappings.
@@ -412,8 +414,8 @@ void *BMO_iter_map_value_p(BMOIter *iter);
 /* use this for float mappings */
 float BMO_iter_map_value_f(BMOIter *iter);
 
-#define BMO_ITER(ele, iter, bm, op, slotname, restrict)   \
-       for (ele = BMO_iter_new(iter, bm, op, slotname, restrict); ele; ele = BMO_iter_step(iter))
+#define BMO_ITER(ele, iter, bm, op, slot_name, restrict)   \
+       for (ele = BMO_iter_new(iter, bm, op, slot_name, restrict); ele; ele = BMO_iter_step(iter))
 
 /******************* Inlined Functions********************/
 typedef void (*opexec)(BMesh *bm, BMOperator *op);
index e04079f42c97466abf67edb865a91970a08e5eec..16c2b8b050515039ddb84c54d62459440d7838b5 100644 (file)
@@ -69,16 +69,16 @@ BLI_INLINE void _bmo_elem_flag_toggle(BMesh *bm, BMFlagLayer *oflags, const shor
        oflags[bm->stackdepth - 1].f ^= oflag;
 }
 
-BLI_INLINE void BMO_slot_map_int_insert(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE void BMO_slot_map_int_insert(BMesh *bm, BMOperator *op, const char *slot_name,
                                         void *element, int val)
 {
-       BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(int));
+       BMO_slot_map_insert(bm, op, slot_name, element, &val, sizeof(int));
 }
 
-BLI_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char *slot_name,
                                           void *element, float val)
 {
-       BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(float));
+       BMO_slot_map_insert(bm, op, slot_name, element, &val, sizeof(float));
 }
 
 
@@ -87,16 +87,16 @@ BLI_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char
  * do NOT use these for non-operator-api-allocated memory! instead
  * use BMO_slot_map_data_get and BMO_slot_map_insert, which copies the data. */
 
-BLI_INLINE void BMO_slot_map_ptr_insert(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE void BMO_slot_map_ptr_insert(BMesh *bm, BMOperator *op, const char *slot_name,
                                         void *element, void *val)
 {
-       BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(void *));
+       BMO_slot_map_insert(bm, op, slot_name, element, &val, sizeof(void *));
 }
 
-BLI_INLINE int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, void *element)
+BLI_INLINE int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name, void *element)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
 
        /* sanity check */
        if (!slot->data.ghash) return 0;
@@ -104,12 +104,12 @@ BLI_INLINE int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const ch
        return BLI_ghash_haskey(slot->data.ghash, element);
 }
 
-BLI_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const char *slotname,
+BLI_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name,
                                        void *element)
 {
        BMOElemMapping *mapping;
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
 
        /* sanity check */
        if (!slot->data.ghash) return NULL;
@@ -121,28 +121,28 @@ BLI_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const
        return mapping + 1;
 }
 
-BLI_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *slot_name,
                                         void *element)
 {
-       float *val = (float *) BMO_slot_map_data_get(bm, op, slotname, element);
+       float *val = (float *) BMO_slot_map_data_get(bm, op, slot_name, element);
        if (val) return *val;
 
        return 0.0f;
 }
 
-BLI_INLINE int BMO_slot_map_int_get(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE int BMO_slot_map_int_get(BMesh *bm, BMOperator *op, const char *slot_name,
                                     void *element)
 {
-       int *val = (int *) BMO_slot_map_data_get(bm, op, slotname, element);
+       int *val = (int *) BMO_slot_map_data_get(bm, op, slot_name, element);
        if (val) return *val;
 
        return 0;
 }
 
-BLI_INLINE void *BMO_slot_map_ptr_get(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE void *BMO_slot_map_ptr_get(BMesh *bm, BMOperator *op, const char *slot_name,
                                       void *element)
 {
-       void **val = (void **) BMO_slot_map_data_get(bm, op, slotname, element);
+       void **val = (void **) BMO_slot_map_data_get(bm, op, slot_name, element);
        if (val) return *val;
 
        return NULL;
index 65288522b3b24724d6100c4ce9cc9b0a951828ca..efd028331852db69bb3ea26a20b0bcf12cad63e4 100644 (file)
@@ -145,9 +145,9 @@ void BMO_op_init(BMesh *bm, BMOperator *op, const char *opname)
        op->flag = opdefines[opcode]->flag;
        
        /* initialize the operator slot types */
-       for (i = 0; opdefines[opcode]->slottypes[i].type; i++) {
-               op->slots[i].slottype = opdefines[opcode]->slottypes[i].type;
-               op->slots[i].index = i;
+       for (i = 0; opdefines[opcode]->slot_types[i].type; i++) {
+               op->slot_args[i].slot_type = opdefines[opcode]->slot_types[i].type;
+               op->slot_args[i].index = i;
        }
 
        /* callback */
@@ -192,9 +192,9 @@ void BMO_op_finish(BMesh *bm, BMOperator *op)
        BMOpSlot *slot;
        int i;
 
-       for (i = 0; opdefines[op->type]->slottypes[i].type; i++) {
-               slot = &op->slots[i];
-               if (slot->slottype == BMO_OP_SLOT_MAPPING) {
+       for (i = 0; opdefines[op->type]->slot_types[i].type; i++) {
+               slot = &op->slot_args[i];
+               if (slot->slot_type == BMO_OP_SLOT_MAPPING) {
                        if (slot->data.ghash)
                                BLI_ghash_free(slot->data.ghash, NULL, NULL);
                }
@@ -214,26 +214,26 @@ void BMO_op_finish(BMesh *bm, BMOperator *op)
  *
  * \return Success if the slot if found.
  */
-int BMO_slot_exists(BMOperator *op, const char *slotname)
+int BMO_slot_exists(BMOperator *op, const char *slot_name)
 {
-       int slotcode = bmo_name_to_slotcode(opdefines[op->type], slotname);
-       return (slotcode >= 0);
+       int slot_code = bmo_name_to_slotcode(opdefines[op->type], slot_name);
+       return (slot_code >= 0);
 }
 
 /**
  * \brief BMESH OPSTACK GET SLOT
  *
- * Returns a pointer to the slot of type 'slotcode'
+ * Returns a pointer to the slot of type 'slot_code'
  */
-BMOpSlot *BMO_slot_get(BMOperator *op, const char *slotname)
+BMOpSlot *BMO_slot_get(BMOperator *op, const char *slot_name)
 {
-       int slotcode = bmo_name_to_slotcode_check(opdefines[op->type], slotname);
+       int slot_code = bmo_name_to_slotcode_check(opdefines[op->type], slot_name);
 
-       if (slotcode < 0) {
+       if (slot_code < 0) {
                return &BMOpEmptySlot;
        }
 
-       return &(op->slots[slotcode]);
+       return &(op->slot_args[slot_code]);
 }
 
 /**
@@ -249,22 +249,22 @@ void BMO_slot_copy(BMOperator *source_op, BMOperator *dest_op, const char *src,
        if (source_slot == dest_slot)
                return;
 
-       if (source_slot->slottype != dest_slot->slottype) {
+       if (source_slot->slot_type != dest_slot->slot_type) {
                /* possibly assert here? */
                return;
        }
 
-       if (dest_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF) {
+       if (dest_slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF) {
                /* do buffer copy */
                dest_slot->data.buf = NULL;
                dest_slot->len = source_slot->len;
                if (dest_slot->len) {
-                       const int slot_alloc_size = BMO_OPSLOT_TYPEINFO[dest_slot->slottype] * dest_slot->len;
+                       const int slot_alloc_size = BMO_OPSLOT_TYPEINFO[dest_slot->slot_type] * dest_slot->len;
                        dest_slot->data.buf = BLI_memarena_alloc(dest_op->arena, slot_alloc_size);
                        memcpy(dest_slot->data.buf, source_slot->data.buf, slot_alloc_size);
                }
        }
-       else if (dest_slot->slottype == BMO_OP_SLOT_MAPPING) {
+       else if (dest_slot->slot_type == BMO_OP_SLOT_MAPPING) {
                GHashIterator it;
                BMOElemMapping *srcmap, *dstmap;
 
@@ -301,42 +301,42 @@ void BMO_slot_copy(BMOperator *source_op, BMOperator *dest_op, const char *src,
  * Sets the value of a slot depending on it's type
  */
 
-void BMO_slot_float_set(BMOperator *op, const char *slotname, const float f)
+void BMO_slot_float_set(BMOperator *op, const char *slot_name, const float f)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_FLT);
-       if (!(slot->slottype == BMO_OP_SLOT_FLT))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_FLT);
+       if (!(slot->slot_type == BMO_OP_SLOT_FLT))
                return;
 
        slot->data.f = f;
 }
 
-void BMO_slot_int_set(BMOperator *op, const char *slotname, const int i)
+void BMO_slot_int_set(BMOperator *op, const char *slot_name, const int i)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_INT);
-       if (!(slot->slottype == BMO_OP_SLOT_INT))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_INT);
+       if (!(slot->slot_type == BMO_OP_SLOT_INT))
                return;
 
        slot->data.i = i;
 }
 
-void BMO_slot_bool_set(BMOperator *op, const char *slotname, const int i)
+void BMO_slot_bool_set(BMOperator *op, const char *slot_name, const int i)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_BOOL);
-       if (!(slot->slottype == BMO_OP_SLOT_BOOL))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_BOOL);
+       if (!(slot->slot_type == BMO_OP_SLOT_BOOL))
                return;
 
        slot->data.i = i;
 }
 
 /* only supports square mats */
-void BMO_slot_mat_set(BMOperator *op, const char *slotname, const float *mat, int size)
+void BMO_slot_mat_set(BMOperator *op, const char *slot_name, const float *mat, int size)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_MAT);
-       if (!(slot->slottype == BMO_OP_SLOT_MAT))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_MAT);
+       if (!(slot->slot_type == BMO_OP_SLOT_MAT))
                return;
 
        slot->len = 4;
@@ -355,93 +355,93 @@ void BMO_slot_mat_set(BMOperator *op, const char *slotname, const float *mat, in
        }
 }
 
-void BMO_slot_mat4_get(BMOperator *op, const char *slotname, float r_mat[4][4])
+void BMO_slot_mat4_get(BMOperator *op, const char *slot_name, float r_mat[4][4])
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_MAT);
-       if (!(slot->slottype == BMO_OP_SLOT_MAT))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_MAT);
+       if (!(slot->slot_type == BMO_OP_SLOT_MAT))
                return;
 
        copy_m4_m4(r_mat, (float (*)[4])slot->data.p);
 }
 
-void BMO_slot_mat3_set(BMOperator *op, const char *slotname, float r_mat[3][3])
+void BMO_slot_mat3_set(BMOperator *op, const char *slot_name, float r_mat[3][3])
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_MAT);
-       if (!(slot->slottype == BMO_OP_SLOT_MAT))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_MAT);
+       if (!(slot->slot_type == BMO_OP_SLOT_MAT))
                return;
 
        copy_m3_m4(r_mat, slot->data.p);
 }
 
-void BMO_slot_ptr_set(BMOperator *op, const char *slotname, void *p)
+void BMO_slot_ptr_set(BMOperator *op, const char *slot_name, void *p)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_PNT);
-       if (!(slot->slottype == BMO_OP_SLOT_PNT))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_PNT);
+       if (!(slot->slot_type == BMO_OP_SLOT_PNT))
                return;
 
        slot->data.p = p;
 }
 
-void BMO_slot_vec_set(BMOperator *op, const char *slotname, const float vec[3])
+void BMO_slot_vec_set(BMOperator *op, const char *slot_name, const float vec[3])
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_VEC);
-       if (!(slot->slottype == BMO_OP_SLOT_VEC))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_VEC);
+       if (!(slot->slot_type == BMO_OP_SLOT_VEC))
                return;
 
        copy_v3_v3(slot->data.vec, vec);
 }
 
 
-float BMO_slot_float_get(BMOperator *op, const char *slotname)
+float BMO_slot_float_get(BMOperator *op, const char *slot_name)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_FLT);
-       if (!(slot->slottype == BMO_OP_SLOT_FLT))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_FLT);
+       if (!(slot->slot_type == BMO_OP_SLOT_FLT))
                return 0.0f;
 
        return slot->data.f;
 }
 
-int BMO_slot_int_get(BMOperator *op, const char *slotname)
+int BMO_slot_int_get(BMOperator *op, const char *slot_name)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_INT);
-       if (!(slot->slottype == BMO_OP_SLOT_INT))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_INT);
+       if (!(slot->slot_type == BMO_OP_SLOT_INT))
                return 0;
 
        return slot->data.i;
 }
 
-int BMO_slot_bool_get(BMOperator *op, const char *slotname)
+int BMO_slot_bool_get(BMOperator *op, const char *slot_name)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_BOOL);
-       if (!(slot->slottype == BMO_OP_SLOT_BOOL))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_BOOL);
+       if (!(slot->slot_type == BMO_OP_SLOT_BOOL))
                return 0;
 
        return slot->data.i;
 }
 
 
-void *BMO_slot_ptr_get(BMOperator *op, const char *slotname)
+void *BMO_slot_ptr_get(BMOperator *op, const char *slot_name)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_PNT);
-       if (!(slot->slottype == BMO_OP_SLOT_PNT))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_PNT);
+       if (!(slot->slot_type == BMO_OP_SLOT_PNT))
                return NULL;
 
        return slot->data.p;
 }
 
-void BMO_slot_vec_get(BMOperator *op, const char *slotname, float r_vec[3])
+void BMO_slot_vec_get(BMOperator *op, const char *slot_name, float r_vec[3])
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_VEC);
-       if (!(slot->slottype == BMO_OP_SLOT_VEC))
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_VEC);
+       if (!(slot->slot_type == BMO_OP_SLOT_VEC))
                return;
 
        copy_v3_v3(r_vec, slot->data.vec);
@@ -515,25 +515,25 @@ void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *UNUSED(op), const char hty
        }
 }
 
-int BMO_slot_buffer_count(BMesh *UNUSED(bm), BMOperator *op, const char *slotname)
+int BMO_slot_buffer_count(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
        
        /* check if its actually a buffer */
-       if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF)
+       if (slot->slot_type != BMO_OP_SLOT_ELEMENT_BUF)
                return 0;
 
        return slot->len;
 }
 
-int BMO_slot_map_count(BMesh *UNUSED(bm), BMOperator *op, const char *slotname)
+int BMO_slot_map_count(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
        
        /* check if its actually a buffer */
-       if (!(slot->slottype == BMO_OP_SLOT_MAPPING))
+       if (!(slot->slot_type == BMO_OP_SLOT_MAPPING))
                return 0;
 
        return slot->data.ghash ? BLI_ghash_size(slot->data.ghash) : 0;
@@ -542,12 +542,12 @@ int BMO_slot_map_count(BMesh *UNUSED(bm), BMOperator *op, const char *slotname)
 /* inserts a key/value mapping into a mapping slot.  note that it copies the
  * value, it doesn't store a reference to it. */
 
-void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slotname,
+void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name,
                          void *element, void *data, int len)
 {
        BMOElemMapping *mapping;
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
 
        mapping = (BMOElemMapping *) BLI_memarena_alloc(op->arena, sizeof(*mapping) + len);
 
@@ -563,9 +563,9 @@ void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slotname
 }
 
 #if 0
-void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slotcode, int totadd)
+void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slot_code, int totadd)
 {
-       BMOpSlot *slot = &op->slots[slotcode];
+       BMOpSlot *slot = &op->slots[slot_code];
        void *tmp;
        ssize_t allocsize;
        
@@ -579,7 +579,7 @@ void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slotcode, int totadd)
                if (slot->len >= slot->size) {
                        slot->size = (slot->size + 1 + totadd) * 2;
 
-                       allocsize = BMO_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->size;
+                       allocsize = BMO_OPSLOT_TYPEINFO[opdefines[op->type]->slot_types[slot_code].type] * slot->size;
 
                        tmp = slot->data.buf;
                        slot->data.buf = MEM_callocN(allocsize, "opslot dynamic array");
@@ -594,7 +594,7 @@ void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slotcode, int totadd)
                slot->len += totadd;
                slot->size = slot->len + 2;
 
-               allocsize = BMO_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->len;
+               allocsize = BMO_OPSLOT_TYPEINFO[opdefines[op->type]->slot_types[slot_code].type] * slot->len;
 
                tmp = slot->data.buf;
                slot->data.buf = MEM_callocN(allocsize, "opslot dynamic array");
@@ -605,14 +605,14 @@ void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slotcode, int totadd)
 }
 #endif
 
-void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slot_name,
                           const char htype, const short oflag)
 {
        GHashIterator it;
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
        BMElemF *ele_f;
 
-       BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
 
        /* sanity check */
        if (!slot->data.ghash) return;
@@ -625,18 +625,18 @@ void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname,
        }
 }
 
-static void *bmo_slot_buffer_alloc(BMOperator *op, const char *slotname, int len)
+void *BMO_slot_buffer_alloc(BMOperator *op, const char *slot_name, const int len)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
-       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
 
        /* check if its actually a buffer */
-       if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF)
+       if (slot->slot_type != BMO_OP_SLOT_ELEMENT_BUF)
                return NULL;
        
        slot->len = len;
        if (len)
-               slot->data.buf = BLI_memarena_alloc(op->arena, BMO_OPSLOT_TYPEINFO[slot->slottype] * len);
+               slot->data.buf = BLI_memarena_alloc(op->arena, BMO_OPSLOT_TYPEINFO[slot->slot_type] * len);
        return slot->data.buf;
 }
 
@@ -645,9 +645,9 @@ static void *bmo_slot_buffer_alloc(BMOperator *op, const char *slotname, int len
  *
  * Copies all elements of a certain type into an operator slot.
  */
-static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slotname, const char htype)
+void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot_name, const char htype)
 {
-       BMOpSlot *output = BMO_slot_get(op, slotname);
+       BMOpSlot *output = BMO_slot_get(op, slot_name);
        int totelement = 0, i = 0;
        
        if (htype & BM_VERT) totelement += bm->totvert;
@@ -658,7 +658,7 @@ static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot
                BMIter iter;
                BMHeader *ele;
 
-               bmo_slot_buffer_alloc(op, slotname, totelement);
+               BMO_slot_buffer_alloc(op, slot_name, totelement);
 
                /* TODO - collapse these loops into one */
 
@@ -691,11 +691,11 @@ static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot
  * Copies elements of a certain type, which have a certain header flag
  * enabled/disabled into a slot for an operator.
  */
-static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *slotname,
+static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *slot_name,
                                        const char htype, const char hflag,
                                        const short test_for_enabled)
 {
-       BMOpSlot *output = BMO_slot_get(op, slotname);
+       BMOpSlot *output = BMO_slot_get(op, slot_name);
        int totelement = 0, i = 0;
 
        BLI_assert(ELEM(test_for_enabled, TRUE, FALSE));
@@ -709,7 +709,7 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
                BMIter iter;
                BMElem *ele;
 
-               bmo_slot_buffer_alloc(op, slotname, totelement);
+               BMO_slot_buffer_alloc(op, slot_name, totelement);
 
                /* TODO - collapse these loops into one */
 
@@ -751,16 +751,16 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
        }
 }
 
-void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op, const char *slot_name,
                                         const char htype, const char hflag)
 {
-       bmo_slot_buffer_from_hflag(bm, op, slotname, htype, hflag, TRUE);
+       bmo_slot_buffer_from_hflag(bm, op, slot_name, htype, hflag, TRUE);
 }
 
-void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op, const char *slot_name,
                                          const char htype, const char hflag)
 {
-       bmo_slot_buffer_from_hflag(bm, op, slotname, htype, hflag, FALSE);
+       bmo_slot_buffer_from_hflag(bm, op, slot_name, htype, hflag, FALSE);
 }
 
 /**
@@ -772,15 +772,15 @@ void BMO_slot_buffer_append(BMOperator *output_op, const char *output_slot_name,
        BMOpSlot *output_slot = BMO_slot_get(output_op, output_slot_name);
        BMOpSlot *other_slot = BMO_slot_get(other_op, other_slot_name);
 
-       BLI_assert(output_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF &&
-                  other_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+       BLI_assert(output_slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF &&
+                  other_slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
 
        if (output_slot->len == 0) {
                /* output slot is empty, copy rather than append */
                BMO_slot_copy(other_op, output_op, other_slot_name, output_slot_name);
        }
        else if (other_slot->len != 0) {
-               int elem_size = BMO_OPSLOT_TYPEINFO[output_slot->slottype];
+               int elem_size = BMO_OPSLOT_TYPEINFO[output_slot->slot_type];
                int alloc_size = elem_size * (output_slot->len + other_slot->len);
                /* allocate new buffer */
                void *buf = BLI_memarena_alloc(output_op->arena, alloc_size);
@@ -800,11 +800,11 @@ void BMO_slot_buffer_append(BMOperator *output_op, const char *output_slot_name,
  * Copies elements of a certain type, which have a certain flag set
  * into an output slot for an operator.
  */
-static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slotname,
+static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slot_name,
                                       const char htype, const short oflag,
                                       const short test_for_enabled)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
        int totelement, i = 0;
 
        BLI_assert(ELEM(TRUE, FALSE, test_for_enabled));
@@ -814,14 +814,14 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
        else
                totelement = BMO_mesh_disabled_flag_count(bm, htype, oflag);
 
-       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
 
        if (totelement) {
                BMIter iter;
                BMHeader *ele;
                BMHeader **ele_array;
 
-               bmo_slot_buffer_alloc(op, slotname, totelement);
+               BMO_slot_buffer_alloc(op, slot_name, totelement);
 
                ele_array = (BMHeader **)slot->data.p;
 
@@ -859,16 +859,16 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
        }
 }
 
-void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, const char *slot_name,
                                        const char htype, const short oflag)
 {
-       bmo_slot_buffer_from_flag(bm, op, slotname, htype, oflag, TRUE);
+       bmo_slot_buffer_from_flag(bm, op, slot_name, htype, oflag, TRUE);
 }
 
-void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *slot_name,
                                         const char htype, const short oflag)
 {
-       bmo_slot_buffer_from_flag(bm, op, slotname, htype, oflag, FALSE);
+       bmo_slot_buffer_from_flag(bm, op, slot_name, htype, oflag, FALSE);
 }
 
 /**
@@ -877,16 +877,16 @@ void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *s
  * Header Flags elements in a slots buffer, automatically
  * using the selection API where appropriate.
  */
-void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slot_name,
                                   const char htype, const char hflag, const char do_flush)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
        BMElem **data =  slot->data.p;
        int i;
        const char do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT));
        const char do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN));
 
-       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
 
        for (i = 0; i < slot->len; i++, data++) {
                if (!(htype & (*data)->head.htype))
@@ -910,16 +910,16 @@ void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slotnam
  * Removes flags from elements in a slots buffer, automatically
  * using the selection API where appropriate.
  */
-void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slot_name,
                                    const char htype, const char hflag, const char do_flush)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
        BMElem **data =  slot->data.p;
        int i;
        const char do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT));
        const char do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN));
 
-       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
 
        for (i = 0; i < slot->len; i++, data++) {
                if (!(htype & (*data)->head.htype))
@@ -961,14 +961,14 @@ int BMO_vert_edge_flags_count(BMesh *bm, BMVert *v, const short oflag)
  *
  * Flags elements in a slots buffer
  */
-void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slot_name,
                                  const char htype, const short oflag)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
        BMHeader **data =  slot->data.p;
        int i;
 
-       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
 
        for (i = 0; i < slot->len; i++) {
                if (!(htype & data[i]->htype))
@@ -983,14 +983,14 @@ void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slotname
  *
  * Removes flags from elements in a slots buffer
  */
-void BMO_slot_buffer_flag_disable(BMesh *bm, BMOperator *op, const char *slotname,
+void BMO_slot_buffer_flag_disable(BMesh *bm, BMOperator *op, const char *slot_name,
                                   const char htype, const short oflag)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
        BMHeader **data =  slot->data.p;
        int i;
 
-       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+       BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
 
        for (i = 0; i < slot->len; i++) {
                if (!(htype & data[i]->htype))
@@ -1131,11 +1131,11 @@ static void bmo_flag_layer_clear(BMesh *bm)
        bm->elem_index_dirty &= ~(BM_VERT | BM_EDGE | BM_FACE);
 }
 
-void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slotname)
+void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slot_name)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
        
-       if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF)
+       if (slot->slot_type != BMO_OP_SLOT_ELEMENT_BUF)
                return NULL;
 
        return slot->data.buf ? *(void **)slot->data.buf : NULL;
@@ -1148,9 +1148,9 @@ void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slotname)
  * (e.g. combination of BM_VERT, BM_EDGE, BM_FACE), if iterating
  * over an element buffer (not a mapping). */
 void *BMO_iter_new(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
-                   const char *slotname, const char restrictmask)
+                   const char *slot_name, const char restrictmask)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slot_name);
 
        memset(iter, 0, sizeof(BMOIter));
 
@@ -1158,7 +1158,7 @@ void *BMO_iter_new(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
        iter->cur = 0;
        iter->restrictmask = restrictmask;
 
-       if (iter->slot->slottype == BMO_OP_SLOT_MAPPING) {
+       if (iter->slot->slot_type == BMO_OP_SLOT_MAPPING) {
                if (iter->slot->data.ghash) {
                        BLI_ghashIterator_init(&iter->giter, slot->data.ghash);
                }
@@ -1172,7 +1172,7 @@ void *BMO_iter_new(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
 
 void *BMO_iter_step(BMOIter *iter)
 {
-       if (iter->slot->slottype == BMO_OP_SLOT_ELEMENT_BUF) {
+       if (iter->slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF) {
                BMHeader *h;
 
                if (iter->cur >= iter->slot->len) {
@@ -1190,7 +1190,7 @@ void *BMO_iter_step(BMOIter *iter)
 
                return h;
        }
-       else if (iter->slot->slottype == BMO_OP_SLOT_MAPPING) {
+       else if (iter->slot->slot_type == BMO_OP_SLOT_MAPPING) {
                BMOElemMapping *map;
                void *ret = BLI_ghashIterator_getKey(&iter->giter);
                map = BLI_ghashIterator_getValue(&iter->giter);
@@ -1286,8 +1286,8 @@ static int bmo_name_to_slotcode(BMOpDefine *def, const char *name)
 {
        int i;
 
-       for (i = 0; def->slottypes[i].type; i++) {
-               if (!strncmp(name, def->slottypes[i].name, MAX_SLOTNAME)) {
+       for (i = 0; def->slot_types[i].type; i++) {
+               if (!strncmp(name, def->slot_types[i].name, MAX_SLOTNAME)) {
                        return i;
                }
        }
@@ -1320,7 +1320,7 @@ static int bmo_opname_to_opcode(const char *opname)
 }
 
 /* Example:
- * BMO_op_callf(bm, "del %i %hv", DEL_ONLYFACES, BM_ELEM_SELECT);
+ * BMO_op_callf(bm, "delete %i %hv", DEL_ONLYFACES, BM_ELEM_SELECT);
  *
  *  i - int
  *  b - boolean (same as int but 1/0 only)
@@ -1331,14 +1331,17 @@ static int bmo_opname_to_opcode(const char *opname)
  *  fv - flagged verts (oflag)
  *  fe - flagged edges (oflag)
  *  ff - flagged faces (oflag)
+ *
+ * capitals - H, F to use the flag flipped (when the flag is off)
+ * Hv, He, Hf, Fv, Fe, Ff,
  */
 
 int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
 {
        BMOpDefine *def;
        char *opname, *ofmt, *fmt;
-       char slotname[64] = {0};
-       int i /*, n = strlen(fmt) */, stop /*, slotcode = -1 */, type, state;
+       char slot_name[64] = {0};
+       int i /*, n = strlen(fmt) */, stop /*, slot_code = -1 */, type, state;
        char htype;
        int noslot = 0;
 
@@ -1377,7 +1380,7 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
        def = opdefines[i];
        
        i = 0;
-       state = 1; /* 0: not inside slotcode name, 1: inside slotcode name */
+       state = 1; /* 0: not inside slot_code name, 1: inside slot_code name */
 
        while (*fmt) {
                if (state) {
@@ -1401,7 +1404,7 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
                                GOTO_ERROR("name to slot code check failed");
                        }
                        
-                       BLI_strncpy(slotname, fmt, sizeof(slotname));
+                       BLI_strncpy(slot_name, fmt, sizeof(slot_name));
                        
                        state = 0;
                        fmt += i;
@@ -1422,18 +1425,18 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
                                        else if (c == '4') size = 4;
                                        else GOTO_ERROR("matrix size was not 3 or 4");
 
-                                       BMO_slot_mat_set(op, slotname, va_arg(vlist, void *), size);
+                                       BMO_slot_mat_set(op, slot_name, va_arg(vlist, void *), size);
                                        state = 1;
                                        break;
                                }
                                case 'v': {
-                                       BMO_slot_vec_set(op, slotname, va_arg(vlist, float *));
+                                       BMO_slot_vec_set(op, slot_name, va_arg(vlist, float *));
                                        state = 1;
                                        break;
                                }
                                case 'e': {
                                        BMHeader *ele = va_arg(vlist, void *);
-                                       BMOpSlot *slot = BMO_slot_get(op, slotname);
+                                       BMOpSlot *slot = BMO_slot_get(op, slot_name);
 
                                        slot->data.buf = BLI_memarena_alloc(op->arena, sizeof(void *) * 4);
                                        slot->len = 1;
@@ -1444,22 +1447,22 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
                                }
                                case 's': {
                                        BMOperator *op2 = va_arg(vlist, void *);
-                                       const char *slotname2 = va_arg(vlist, char *);
+                                       const char *slot_name2 = va_arg(vlist, char *);
 
-                                       BMO_slot_copy(op2, op, slotname2, slotname);
+                                       BMO_slot_copy(op2, op, slot_name2, slot_name);
                                        state = 1;
                                        break;
                                }
                                case 'i':
-                                       BMO_slot_int_set(op, slotname, va_arg(vlist, int));
+                                       BMO_slot_int_set(op, slot_name, va_arg(vlist, int));
                                        state = 1;
                                        break;
                                case 'b':
-                                       BMO_slot_bool_set(op, slotname, va_arg(vlist, int));
+                                       BMO_slot_bool_set(op, slot_name, va_arg(vlist, int));
                                        state = 1;
                                        break;
                                case 'p':
-                                       BMO_slot_ptr_set(op, slotname, va_arg(vlist, void *));
+                                       BMO_slot_ptr_set(op, slot_name, va_arg(vlist, void *));
                                        state = 1;
                                        break;
                                case 'f':
@@ -1470,7 +1473,7 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
                                        type = *fmt;
 
                                        if (NEXT_CHAR(fmt) == ' ' || NEXT_CHAR(fmt) == '\0') {
-                                               BMO_slot_float_set(op, slotname, va_arg(vlist, double));
+                                               BMO_slot_float_set(op, slot_name, va_arg(vlist, double));
                                        }
                                        else {
                                                htype = 0;
@@ -1492,19 +1495,19 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
                                                }
 
                                                if (type == 'h') {
-                                                       BMO_slot_buffer_from_enabled_hflag(bm, op, slotname, htype, va_arg(vlist, int));
+                                                       BMO_slot_buffer_from_enabled_hflag(bm, op, slot_name, htype, va_arg(vlist, int));
                                                }
                                                else if (type == 'H') {
-                                                       BMO_slot_buffer_from_disabled_hflag(bm, op, slotname, htype, va_arg(vlist, int));
+                                                       BMO_slot_buffer_from_disabled_hflag(bm, op, slot_name, htype, va_arg(vlist, int));
                                                }
                                                else if (type == 'a') {
-                                                       BMO_slot_buffer_from_all(bm, op, slotname, htype);
+                                                       BMO_slot_buffer_from_all(bm, op, slot_name, htype);
                                                }
                                                else if (type == 'f') {
-                                                       BMO_slot_buffer_from_enabled_flag(bm, op, slotname, htype, va_arg(vlist, int));
+                                                       BMO_slot_buffer_from_enabled_flag(bm, op, slot_name, htype, va_arg(vlist, int));
                                                }
                                                else if (type == 'F') {
-                                                       BMO_slot_buffer_from_disabled_flag(bm, op, slotname, htype, va_arg(vlist, int));
+                                                       BMO_slot_buffer_from_disabled_flag(bm, op, slot_name, htype, va_arg(vlist, int));
                                                }
                                        }
 
index baccb3e9a1078305fb6b4d276d38d11770ca601d..dc1bdaa468902729007c1bd9c7d2025396f9af14 100644 (file)
@@ -33,74 +33,74 @@ struct BMOperator;
 void BMO_push(BMesh *bm, BMOperator *op);
 void BMO_pop(BMesh *bm);
 
-void bmo_split_exec(BMesh *bm, BMOperator *op);
-void bmo_spin_exec(BMesh *bm, BMOperator *op);
-void bmo_dupe_exec(BMesh *bm, BMOperator *op);
-void bmo_del_exec(BMesh *bm, BMOperator *op);
-void bmo_esubd_exec(BMesh *bm, BMOperator *op);
-void bmo_triangulate_exec(BMesh *bm, BMOperator *op);
+void bmo_automerge_exec(BMesh *bm, BMOperator *op);
+void bmo_average_vert_facedata_exec(BMesh *bm, BMOperator *op);
+void bmo_beautify_fill_exec(BMesh *bm, BMOperator *op);
+void bmo_bevel_exec(BMesh *bm, BMOperator *op);
+void bmo_bisect_edges_exec(BMesh *bm, BMOperator *op);
+void bmo_bmesh_to_mesh_exec(BMesh *bm, BMOperator *op);
+void bmo_bridge_loops_exec(BMesh *bm, BMOperator *op);
+void bmo_collapse_exec(BMesh *bm, BMOperator *op);
+void bmo_collapse_uvs_exec(BMesh *bm, BMOperator *op);
+void bmo_connect_verts_exec(BMesh *bm, BMOperator *op);
+void bmo_contextual_create_exec(BMesh *bm, BMOperator *op);
+void bmo_convex_hull_exec(BMesh *bm, BMOperator *op);
+void bmo_create_circle_exec(BMesh *bm, BMOperator *op);
+void bmo_create_cone_exec(BMesh *bm, BMOperator *op);
+void bmo_create_cube_exec(BMesh *bm, BMOperator *op);
+void bmo_create_grid_exec(BMesh *bm, BMOperator *op);
+void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op);
+void bmo_create_monkey_exec(BMesh *bm, BMOperator *op);
+void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op);
+void bmo_create_vert_exec(BMesh *bm, BMOperator *op);
+void bmo_delete_exec(BMesh *bm, BMOperator *op);
+void bmo_dissolve_edgeloop_exec(BMesh *bm, BMOperator *op);
+void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op);
 void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op);
-void bmo_dissolve_verts_exec(BMesh *bm, BMOperator *op);
 void bmo_dissolve_limit_exec(BMesh *bm, BMOperator *op);
+void bmo_dissolve_verts_exec(BMesh *bm, BMOperator *op);
+void bmo_duplicate_exec(BMesh *bm, BMOperator *op);
+void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op);
+void bmo_edgenet_prepare(BMesh *bm, BMOperator *op);
+void bmo_extrude_discrete_faces_exec(BMesh *bm, BMOperator *op);
+void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op);
 void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op);
-void bmo_vertex_slide_exec(BMesh *bm, BMOperator *op);
-void bmo_connectverts_exec(BMesh *bm, BMOperator *op);
 void bmo_extrude_vert_indiv_exec(BMesh *bm, BMOperator *op);
+void bmo_find_doubles_exec(BMesh *bm, BMOperator *op);
+void bmo_inset_exec(BMesh *bm, BMOperator *op);
+void bmo_join_triangles_exec(BMesh *bm, BMOperator *op);
 void bmo_mesh_to_bmesh_exec(BMesh *bm, BMOperator *op);
-void bmo_bmesh_to_mesh_exec(BMesh *bm, BMOperator *op);
-void bmo_translate_exec(BMesh *bm, BMOperator *op);
-void bmo_transform_exec(BMesh *bm, BMOperator *op);
-void bmo_contextual_create_exec(BMesh *bm, BMOperator *op);
-void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op);
-void bmo_rotate_exec(BMesh *bm, BMOperator *op);
-void bmo_makevert_exec(BMesh *bm, BMOperator *op);
-void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op);
-void bmo_dissolve_edgeloop_exec(BMesh *bm, BMOperator *op);
-void bmo_weldverts_exec(BMesh *bm, BMOperator *op);
-void bmo_remove_doubles_exec(BMesh *bm, BMOperator *op);
-void bmo_finddoubles_exec(BMesh *bm, BMOperator *op);
 void bmo_mirror_exec(BMesh *bm, BMOperator *op);
-void bmo_edgebisect_exec(BMesh *bm, BMOperator *op);
-void bmo_reversefaces_exec(BMesh *bm, BMOperator *op);
-void bmo_edgerotate_exec(BMesh *bm, BMOperator *op);
-void bmo_regionextend_exec(BMesh *bm, BMOperator *op);
-void bmo_righthandfaces_exec(BMesh *bm, BMOperator *op);
-void bmo_vertexsmooth_exec(BMesh *bm, BMOperator *op);
-void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op);
-void bmo_extrude_face_indiv_exec(BMesh *bm, BMOperator *op);
-void bmo_collapse_uvs_exec(BMesh *bm, BMOperator *op);
+void bmo_object_load_bmesh_exec(BMesh *bm, BMOperator *op);
 void bmo_pointmerge_exec(BMesh *bm, BMOperator *op);
-void bmo_collapse_exec(BMesh *bm, BMOperator *op);
-void bmo_similarfaces_exec(BMesh *bm, BMOperator *op);
-void bmo_similaredges_exec(BMesh *bm, BMOperator *op);
-void bmo_similarverts_exec(BMesh *bm, BMOperator *op);
 void bmo_pointmerge_facedata_exec(BMesh *bm, BMOperator *op);
-void bmo_vert_average_facedata_exec(BMesh *bm, BMOperator *op);
-void bmo_face_rotateuvs_exec(BMesh *bm, BMOperator *op);
-void bmo_object_load_bmesh_exec(BMesh *bm, BMOperator *op);
-void bmo_face_reverseuvs_exec(BMesh *bm, BMOperator *op);
-void bmo_edgenet_prepare(BMesh *bm, BMOperator *op);
-void bmo_rotatecolors_exec(BMesh *bm, BMOperator *op);
-void bmo_face_reversecolors_exec(BMesh *bm, BMOperator *op);
-void bmo_vertexshortestpath_exec(BMesh *bm, BMOperator *op);
+void bmo_recalc_face_normals_exec(BMesh *bm, BMOperator *op);
+void bmo_region_extend_exec(BMesh *bm, BMOperator *op);
+void bmo_remove_doubles_exec(BMesh *bm, BMOperator *op);
+void bmo_reverse_colors_exec(BMesh *bm, BMOperator *op);
+void bmo_reverse_faces_exec(BMesh *bm, BMOperator *op);
+void bmo_reverse_uvs_exec(BMesh *bm, BMOperator *op);
+void bmo_rotate_colors_exec(BMesh *bm, BMOperator *op);
+void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op);
+void bmo_rotate_exec(BMesh *bm, BMOperator *op);
+void bmo_rotate_uvs_exec(BMesh *bm, BMOperator *op);
 void bmo_scale_exec(BMesh *bm, BMOperator *op);
-void bmo_edgesplit_exec(BMesh *bm, BMOperator *op);
-void bmo_automerge_exec(BMesh *bm, BMOperator *op);
-void bmo_create_cone_exec(BMesh *bm, BMOperator *op);
-void bmo_create_monkey_exec(BMesh *bm, BMOperator *op);
-void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op);
-void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op);
-void bmo_create_grid_exec(BMesh *bm, BMOperator *op);
-void bmo_create_cube_exec(BMesh *bm, BMOperator *op);
-void bmo_join_triangles_exec(BMesh *bm, BMOperator *op);
-void bmo_bevel_exec(BMesh *bm, BMOperator *op);
-void bmo_beautify_fill_exec(BMesh *bm, BMOperator *op);
-void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op);
-void bmo_create_circle_exec(BMesh *bm, BMOperator *op);
-void bmo_bridge_loops_exec(BMesh *bm, BMOperator *op);
+void bmo_shortest_path_exec(BMesh *bm, BMOperator *op);
+void bmo_similar_edges_exec(BMesh *bm, BMOperator *op);
+void bmo_similar_faces_exec(BMesh *bm, BMOperator *op);
+void bmo_similar_verts_exec(BMesh *bm, BMOperator *op);
+void bmo_slide_vert_exec(BMesh *bm, BMOperator *op);
+void bmo_smooth_vert_exec(BMesh *bm, BMOperator *op);
 void bmo_solidify_face_region_exec(BMesh *bm, BMOperator *op);
-void bmo_inset_exec(BMesh *bm, BMOperator *op);
+void bmo_spin_exec(BMesh *bm, BMOperator *op);
+void bmo_split_edges_exec(BMesh *bm, BMOperator *op);
+void bmo_split_exec(BMesh *bm, BMOperator *op);
+void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op);
+void bmo_transform_exec(BMesh *bm, BMOperator *op);
+void bmo_translate_exec(BMesh *bm, BMOperator *op);
+void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op);
+void bmo_triangulate_exec(BMesh *bm, BMOperator *op);
+void bmo_weld_verts_exec(BMesh *bm, BMOperator *op);
 void bmo_wireframe_exec(BMesh *bm, BMOperator *op);
-void bmo_convex_hull_exec(BMesh *bm, BMOperator *op);
 
 #endif /* __BMESH_OPERATORS_PRIVATE_H__ */
index f02b88c5b05c43be380b54a0b736bf0cca85564d..0b036c6ff2bff33473491529dcfd89f74c759fb8 100644 (file)
@@ -865,7 +865,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
        }
 #endif
 
-       BMO_op_callf(bm, "del geom=%fv context=%i", BEVEL_DEL, DEL_VERTS);
+       BMO_op_callf(bm, "delete geom=%fv context=%i", BEVEL_DEL, DEL_VERTS);
 
        /* clean up any edges that might not get properly delete */
        BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
@@ -873,8 +873,8 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
                        BMO_elem_flag_enable(bm, e, BEVEL_DEL);
        }
 
-       BMO_op_callf(bm, "del geom=%fe context=%i", BEVEL_DEL, DEL_EDGES);
-       BMO_op_callf(bm, "del geom=%ff context=%i", BEVEL_DEL, DEL_FACES);
+       BMO_op_callf(bm, "delete geom=%fe context=%i", BEVEL_DEL, DEL_EDGES);
+       BMO_op_callf(bm, "delete geom=%ff context=%i", BEVEL_DEL, DEL_FACES);
        
        BLI_smallhash_release(&hash);
        BLI_array_free(tags);
index 653bbaf860249ca20851267d95f42c51b82d0004..7418be3565cbd4fc2ced99561746d47e60cf2a4b 100644 (file)
@@ -40,7 +40,7 @@
 #define EDGE_MARK      4
 #define EDGE_DONE      8
 
-void bmo_connectverts_exec(BMesh *bm, BMOperator *op)
+void bmo_connect_verts_exec(BMesh *bm, BMOperator *op)
 {
        BMIter iter, liter;
        BMFace *f, *nf;
index 1451625d3bb143b3195056890797d62d1a3fe0aa..8e69696f771a2ef0303669dc8f513be67d4f2c08 100644 (file)
@@ -164,7 +164,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
 
        }
 
-       BMO_op_callf(bm, "del geom=%ff context=%i", FACE_ORIG, DEL_FACES);
+       BMO_op_callf(bm, "delete geom=%ff context=%i", FACE_ORIG, DEL_FACES);
 
 
        if (use_verts) {
index 6e6037239b9f3252939961b958805f26bc795b20..1421ae294bc76e853db242b4d7b3e4fdb48f660b 100644 (file)
@@ -314,7 +314,7 @@ static void BKE_mesh_copy(BMOperator *op, BMesh *source, BMesh *target)
  * BMOP_DUPE_FNEW: Buffer containing pointers to the new mesh faces
  */
 
-void bmo_dupe_exec(BMesh *bm, BMOperator *op)
+void bmo_duplicate_exec(BMesh *bm, BMOperator *op)
 {
        BMOperator *dupeop = op;
        BMesh *bm2 = BMO_slot_ptr_get(op, "dest");
@@ -345,7 +345,7 @@ void BMO_dupe_from_flag(BMesh *bm, int htype, const char hflag)
 {
        BMOperator dupeop;
 
-       BMO_op_init(bm, &dupeop, "dupe");
+       BMO_op_init(bm, &dupeop, "duplicate");
        BMO_slot_buffer_from_enabled_hflag(bm, &dupeop, "geom", htype, hflag);
 
        BMO_op_exec(bm, &dupeop);
@@ -381,8 +381,8 @@ void bmo_split_exec(BMesh *bm, BMOperator *op)
        const short use_only_faces = BMO_slot_bool_get(op, "use_only_faces");
 
        /* initialize our sub-operator */
-       BMO_op_init(bm, &dupeop, "dupe");
-       BMO_op_init(bm, &delop, "del");
+       BMO_op_init(bm, &dupeop, "duplicate");
+       BMO_op_init(bm, &delop, "delete");
        
        BMO_slot_copy(splitop, &dupeop, "geom", "geom");
        BMO_op_exec(bm, &dupeop);
@@ -443,7 +443,7 @@ void bmo_split_exec(BMesh *bm, BMOperator *op)
 }
 
 
-void bmo_del_exec(BMesh *bm, BMOperator *op)
+void bmo_delete_exec(BMesh *bm, BMOperator *op)
 {
 #define DEL_INPUT 1
 
@@ -487,7 +487,7 @@ void bmo_spin_exec(BMesh *bm, BMOperator *op)
        BMO_slot_copy(op, op, "geom", "lastout");
        for (a = 0; a < steps; a++) {
                if (do_dupli) {
-                       BMO_op_initf(bm, &dupop, "dupe geom=%s", op, "lastout");
+                       BMO_op_initf(bm, &dupop, "duplicate geom=%s", op, "lastout");
                        BMO_op_exec(bm, &dupop);
                        BMO_op_callf(bm, "rotate cent=%v mat=%m3 verts=%s",
                                     cent, rmat, &dupop, "newout");
index ccbcb2939151358e86bb2d2f9b448b614c4f503a..1f6689ed06c51a3cf6759d9fb7f9576c1c51c894 100644 (file)
@@ -100,7 +100,7 @@ static void bm_edgesplit_validate_seams(BMesh *bm, BMOperator *op)
 }
 
 /* keep this operator fast, its used in a modifier */
-void bmo_edgesplit_exec(BMesh *bm, BMOperator *op)
+void bmo_split_edges_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter siter;
        BMEdge *e;
index 09b79376ff6f676f54a346e5dec6753f477b6b96..b8993b41caf70d7d764524241c4976a072bb0a6b 100644 (file)
@@ -49,7 +49,7 @@ enum {
 #define VERT_NONMAN 2
 #define EDGE_NONMAN 2
 
-void bmo_extrude_face_indiv_exec(BMesh *bm, BMOperator *op)
+void bmo_extrude_discrete_faces_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter siter;
        BMIter liter, liter2;
@@ -118,7 +118,7 @@ void bmo_extrude_face_indiv_exec(BMesh *bm, BMOperator *op)
 
        BLI_array_free(edges);
 
-       BMO_op_callf(bm, "del geom=%ff context=%i", EXT_DEL, DEL_ONLYFACES);
+       BMO_op_callf(bm, "delete geom=%ff context=%i", EXT_DEL, DEL_ONLYFACES);
        BMO_slot_buffer_from_enabled_flag(bm, op, "faceout", BM_FACE, EXT_KEEP);
 }
 
@@ -172,7 +172,7 @@ static void bm_extrude_copy_face_loop_attributes(BMesh *bm, BMFace *f, BMEdge *e
 }
 
 /* Disable the skin root flag on the input vert, assumes that the vert
  data includes an CD_MVERT_SKIN layer */
* data includes an CD_MVERT_SKIN layer */
 static void bm_extrude_disable_skin_root(BMesh *bm, BMVert *v)
 {
        MVertSkin *vs;
@@ -195,7 +195,7 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op)
                BMO_elem_flag_enable(bm, e->v2, EXT_INPUT);
        }
 
-       BMO_op_initf(bm, &dupeop, "dupe geom=%fve", EXT_INPUT);
+       BMO_op_initf(bm, &dupeop, "duplicate geom=%fve", EXT_INPUT);
        BMO_op_exec(bm, &dupeop);
 
        /* disable root flag on all new skin nodes */
@@ -273,7 +273,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
        int found, fwd, delorig = FALSE;
 
        /* initialize our sub-operators */
-       BMO_op_init(bm, &dupeop, "dupe");
+       BMO_op_init(bm, &dupeop, "duplicate");
        
        BMO_slot_buffer_flag_enable(bm, op, "edgefacein", BM_EDGE | BM_FACE, EXT_INPUT);
        
@@ -341,7 +341,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
        }
 
        if (delorig == TRUE) {
-               BMO_op_initf(bm, &delop, "del geom=%fvef context=%i",
+               BMO_op_initf(bm, &delop, "delete geom=%fvef context=%i",
                             EXT_DEL, DEL_ONLYTAGGED);
        }
 
@@ -647,7 +647,7 @@ void bmo_solidify_face_region_exec(BMesh *bm, BMOperator *op)
        thickness = BMO_slot_float_get(op, "thickness");
 
        /* Flip original faces (so the shell is extruded inward) */
-       BMO_op_init(bm, &reverseop, "reversefaces");
+       BMO_op_init(bm, &reverseop, "reverse_faces");
        BMO_slot_copy(op, &reverseop, "geom", "faces");
        BMO_op_exec(bm, &reverseop);
        BMO_op_finish(bm, &reverseop);
index cfff3d63ca10c76d7ddc746f3095710806a57376..1bd2f41209b845fdc5f187cd9722be3433a0d08b 100644 (file)
@@ -141,8 +141,8 @@ static void hull_add_triangle(BMesh *bm, GHash *hull_triangles, BLI_mempool *poo
 static int hull_point_tri_side(const HullTriangle *t, const float co[3])
 {
        /* Added epsilon to fix bug [#31941], improves output when some
-          vertices are nearly coplanar. Might need further tweaking for
-          other cases though. */
+        * vertices are nearly coplanar. Might need further tweaking for
+        * other cases though. */
        float p[3], d, epsilon = 0.0001;
        sub_v3_v3v3(p, co, t->v[0]->co);
        d = dot_v3v3(t->no, p);
index 53c51dfd483cc468661eaf021e36f2b2eb61ef11..1ab439b38bb93c9d3c2a44dd9f43177fdde4f79c 100644 (file)
@@ -62,7 +62,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
        BMO_slot_mat4_get(op, "mat", mtx);
        invert_m4_m4(imtx, mtx);
        
-       BMO_op_initf(bm, &dupeop, "dupe geom=%s", op, "geom");
+       BMO_op_initf(bm, &dupeop, "duplicate geom=%s", op, "geom");
        BMO_op_exec(bm, &dupeop);
        
        BMO_slot_buffer_flag_enable(bm, &dupeop, "newout", BM_ALL, ELE_NEW);
@@ -84,7 +84,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
        BMO_op_callf(bm, "scale verts=%fv vec=%v", ELE_NEW, scale);
        BMO_op_callf(bm, "transform verts=%fv mat=%m4", ELE_NEW, imtx);
        
-       BMO_op_init(bm, &weldop, "weldverts");
+       BMO_op_init(bm, &weldop, "weld_verts");
 
        v = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
        for (i = 0; i < ototvert; i++) {
index 49b0679be3d94a5c9afe946fe10926eb245c19c0..d59a90ba3a1a98176e10aef36d8d23198336707c 100644 (file)
@@ -427,7 +427,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
                BMOperator bmop;
 
                BMO_op_initf(bm, &bmop,
-                            "esubd edges=%fe "
+                            "subdivide_edges edges=%fe "
                             "smooth=%f "
                             "numcuts=%i "
                             "use_gridfill=%b use_sphere=%b",
index 296d598ae3b425520c58afd0d6d8d0e0b4848e2d..b3c348a330cec5951bad97d80cb4e3ed93e49567 100644 (file)
@@ -96,7 +96,7 @@ int remdoubles_face_overlaps(BMesh *bm, BMVert **varr,
 }
 #endif
 
-void bmo_weldverts_exec(BMesh *bm, BMOperator *op)
+void bmo_weld_verts_exec(BMesh *bm, BMOperator *op)
 {
        BMIter iter, liter;
        BMVert *v, *v2;
@@ -227,7 +227,7 @@ void bmo_weldverts_exec(BMesh *bm, BMOperator *op)
                }
        }
 
-       BMO_op_callf(bm, "del geom=%fvef context=%i", ELE_DEL, DEL_ONLYTAGGED);
+       BMO_op_callf(bm, "delete geom=%fvef context=%i", ELE_DEL, DEL_ONLYTAGGED);
 
        BLI_array_free(edges);
        BLI_array_free(loops);
@@ -301,7 +301,7 @@ void bmo_pointmerge_facedata_exec(BMesh *bm, BMOperator *op)
        }
 }
 
-void bmo_vert_average_facedata_exec(BMesh *bm, BMOperator *op)
+void bmo_average_vert_facedata_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter siter;
        BMIter iter;
@@ -345,10 +345,10 @@ void bmo_pointmerge_exec(BMesh *bm, BMOperator *op)
        BMVert *v, *snapv = NULL;
        float vec[3];
        
-       BMO_slot_vec_get(op, "mergeco", vec);
+       BMO_slot_vec_get(op, "merge_co", vec);
 
        //BMO_op_callf(bm, "collapse_uvs edges=%s", op, "edges");
-       BMO_op_init(bm, &weldop, "weldverts");
+       BMO_op_init(bm, &weldop, "weld_verts");
        
        BMO_ITER (v, &siter, bm, op, "verts", BM_VERT) {
                if (!snapv) {
@@ -375,7 +375,7 @@ void bmo_collapse_exec(BMesh *bm, BMOperator *op)
        int i, tot;
        
        BMO_op_callf(bm, "collapse_uvs edges=%s", op, "edges");
-       BMO_op_init(bm, &weldop, "weldverts");
+       BMO_op_init(bm, &weldop, "weld_verts");
 
        BMO_slot_buffer_flag_enable(bm, op, "edges", BM_EDGE, EDGE_MARK);
 
@@ -487,7 +487,7 @@ void bmo_collapse_uvs_exec(BMesh *bm, BMOperator *op)
        }
 }
 
-void bmesh_finddoubles_common(BMesh *bm, BMOperator *op, BMOperator *optarget, const char *targetmapname)
+void bmesh_find_doubles_common(BMesh *bm, BMOperator *op, BMOperator *optarget, const char *targetmapname)
 {
        BMOIter oiter;
        BMVert *v, *v2;
@@ -505,17 +505,17 @@ void bmesh_finddoubles_common(BMesh *bm, BMOperator *op, BMOperator *optarget, c
                verts[i++] = v;
        }
 
-       /* Test whether keepverts arg exists and is non-empty */
-       if (BMO_slot_exists(op, "keepverts")) {
-               keepvert = BMO_iter_new(&oiter, bm, op, "keepverts", BM_VERT) != NULL;
+       /* Test whether keep_verts arg exists and is non-empty */
+       if (BMO_slot_exists(op, "keep_verts")) {
+               keepvert = BMO_iter_new(&oiter, bm, op, "keep_verts", BM_VERT) != NULL;
        }
 
        /* sort by vertex coordinates added together */
        qsort(verts, BLI_array_count(verts), sizeof(void *), vergaverco);
 
-       /* Flag keepverts */
+       /* Flag keep_verts */
        if (keepvert) {
-               BMO_slot_buffer_flag_enable(bm, op, "keepverts", BM_VERT, VERT_KEEP);
+               BMO_slot_buffer_flag_enable(bm, op, "keep_verts", BM_VERT, VERT_KEEP);
        }
 
        len = BLI_array_count(verts);
@@ -561,16 +561,16 @@ void bmo_remove_doubles_exec(BMesh *bm, BMOperator *op)
 {
        BMOperator weldop;
 
-       BMO_op_init(bm, &weldop, "weldverts");
-       bmesh_finddoubles_common(bm, op, &weldop, "targetmap");
+       BMO_op_init(bm, &weldop, "weld_verts");
+       bmesh_find_doubles_common(bm, op, &weldop, "targetmap");
        BMO_op_exec(bm, &weldop);
        BMO_op_finish(bm, &weldop);
 }
 
 
-void bmo_finddoubles_exec(BMesh *bm, BMOperator *op)
+void bmo_find_doubles_exec(BMesh *bm, BMOperator *op)
 {
-       bmesh_finddoubles_common(bm, op, op, "targetmapout");
+       bmesh_find_doubles_common(bm, op, op, "targetmapout");
 }
 
 void bmo_automerge_exec(BMesh *bm, BMOperator *op)
@@ -591,12 +591,12 @@ void bmo_automerge_exec(BMesh *bm, BMOperator *op)
 
        /* Search for doubles among all vertices, but only merge non-VERT_KEEP
         * vertices into VERT_KEEP vertices. */
-       BMO_op_initf(bm, &findop, "finddoubles verts=%av keepverts=%fv", VERT_KEEP);
+       BMO_op_initf(bm, &findop, "find_doubles verts=%av keep_verts=%fv", VERT_KEEP);
        BMO_slot_copy(op, &findop, "dist", "dist");
        BMO_op_exec(bm, &findop);
 
        /* weld the vertices */
-       BMO_op_init(bm, &weldop, "weldverts");
+       BMO_op_init(bm, &weldop, "weld_verts");
        BMO_slot_copy(&findop, &weldop, "targetmapout", "targetmap");
        BMO_op_exec(bm, &weldop);
 
index 238cc5ac66fbdb1931e48a935be6b75c032c1df4..0036f095d0070b722c76c4d103b5bf2646df59f9 100644 (file)
@@ -40,7 +40,7 @@
  * Slides a vertex along a connected edge
  *
  */
-void bmo_vertex_slide_exec(BMesh *bm, BMOperator *op)
+void bmo_slide_vert_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter oiter;
        BMIter iter;
@@ -61,7 +61,7 @@ void bmo_vertex_slide_exec(BMesh *bm, BMOperator *op)
 
        if (!vertex) {
                if (G.debug & G_DEBUG) {
-                       fprintf(stderr, "vertex_slide: No vertex selected...");
+                       fprintf(stderr, "slide_vert: No vertex selected...");
                }
                BMO_error_raise(bm, op, BMERR_INVALID_SELECTION, "Vertex Slide Error: Invalid selection.");
                return;
@@ -81,7 +81,7 @@ void bmo_vertex_slide_exec(BMesh *bm, BMOperator *op)
        /* Only allow sliding if an edge is selected */
        if (selected_edges == 0) {
                if (G.debug & G_DEBUG) {
-                       fprintf(stderr, "vertex_slide: select a single edge\n");
+                       fprintf(stderr, "slide_vert: select a single edge\n");
                }
                BMO_error_raise(bm, op, BMERR_INVALID_SELECTION, "Vertex Slide Error: Invalid selection.");
                return;
index 03a691e3e9cd7f2d19fd44267bc890ab059c29bf..ee3e34c527f65700f0c06553612b2d4fea4494ef 100644 (file)
@@ -672,7 +672,7 @@ typedef struct SubDFaceData {
        BMFace *face;
 } SubDFaceData;
 
-void bmo_esubd_exec(BMesh *bm, BMOperator *op)
+void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
 {
        BMOpSlot *einput;
        SubDPattern *pat;
@@ -1038,7 +1038,7 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag,
        
        /* use_sphere isnt exposed here since its only used for new primitives */
        BMO_op_initf(bm, &op,
-                    "esubd edges=%he "
+                    "subdivide_edges edges=%he "
                     "smooth=%f fractal=%f along_normal=%f "
                     "numcuts=%i "
                     "quadcornertype=%i "
@@ -1096,7 +1096,7 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag,
        BMO_op_finish(bm, &op);
 }
 
-void bmo_edgebisect_exec(BMesh *bm, BMOperator *op)
+void bmo_bisect_edges_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter siter;
        BMEdge *e;
index e0cd3e2ba90dfb321a54de317234f01e75f0e9b9..7d6e34b3a05f49fcb1df17ba35abef38813aa39a 100644 (file)
@@ -41,7 +41,7 @@
 
 #include "intern/bmesh_operators_private.h" /* own include */
 
-void bmo_makevert_exec(BMesh *bm, BMOperator *op)
+void bmo_create_vert_exec(BMesh *bm, BMOperator *op)
 {
        float vec[3];
 
@@ -108,7 +108,7 @@ void bmo_rotate_exec(BMesh *bm, BMOperator *op)
        BMO_op_callf(bm, "translate verts=%s vec=%v", op, "verts", vec);
 }
 
-void bmo_reversefaces_exec(BMesh *bm, BMOperator *op)
+void bmo_reverse_faces_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter siter;
        BMFace *f;
@@ -118,7 +118,7 @@ void bmo_reversefaces_exec(BMesh *bm, BMOperator *op)
        }
 }
 
-void bmo_edgerotate_exec(BMesh *bm, BMOperator *op)
+void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter siter;
        BMEdge *e, *e2;
@@ -172,7 +172,7 @@ void bmo_edgerotate_exec(BMesh *bm, BMOperator *op)
 #define SEL_FLAG       1
 #define SEL_ORIG       2
 
-static void bmo_regionextend_extend(BMesh *bm, BMOperator *op, int usefaces)
+static void bmo_region_extend_extend(BMesh *bm, BMOperator *op, int usefaces)
 {
        BMVert *v;
        BMEdge *e;
@@ -211,7 +211,7 @@ static void bmo_regionextend_extend(BMesh *bm, BMOperator *op, int usefaces)
        }
 }
 
-static void bmo_regionextend_constrict(BMesh *bm, BMOperator *op, int usefaces)
+static void bmo_region_extend_constrict(BMesh *bm, BMOperator *op, int usefaces)
 {
        BMVert *v;
        BMEdge *e;
@@ -253,7 +253,7 @@ static void bmo_regionextend_constrict(BMesh *bm, BMOperator *op, int usefaces)
        }
 }
 
-void bmo_regionextend_exec(BMesh *bm, BMOperator *op)
+void bmo_region_extend_exec(BMesh *bm, BMOperator *op)
 {
        int use_faces = BMO_slot_bool_get(op, "use_faces");
        int constrict = BMO_slot_bool_get(op, "constrict");
@@ -261,9 +261,9 @@ void bmo_regionextend_exec(BMesh *bm, BMOperator *op)
        BMO_slot_buffer_flag_enable(bm, op, "geom", BM_ALL, SEL_ORIG);
 
        if (constrict)
-               bmo_regionextend_constrict(bm, op, use_faces);
+               bmo_region_extend_constrict(bm, op, use_faces);
        else
-               bmo_regionextend_extend(bm, op, use_faces);
+               bmo_region_extend_extend(bm, op, use_faces);
 
        BMO_slot_buffer_from_enabled_flag(bm, op, "geomout", BM_ALL, SEL_FLAG);
 }
@@ -275,7 +275,7 @@ void bmo_regionextend_exec(BMesh *bm, BMOperator *op)
 #define FACE_MARK      4
 #define FACE_FLIP      8
 
-/* NOTE: these are the original righthandfaces comment in editmesh_mods.c,
+/* NOTE: these are the original recalc_face_normals comment in editmesh_mods.c,
  *       copied here for reference. */
 
 /* based at a select-connected to witness loose objects */
@@ -296,7 +296,7 @@ void bmo_regionextend_exec(BMesh *bm, BMOperator *op)
 
 /* NOTE: BM_ELEM_TAG is used on faces to tell if they are flipped. */
 
-void bmo_righthandfaces_exec(BMesh *bm, BMOperator *op)
+void bmo_recalc_face_normals_exec(BMesh *bm, BMOperator *op)
 {
        BMIter liter, liter2;
        BMOIter siter;
@@ -397,13 +397,13 @@ void bmo_righthandfaces_exec(BMesh *bm, BMOperator *op)
        /* check if we have faces yet to do.  if so, recurse */
        BMO_ITER (f, &siter, bm, op, "faces", BM_FACE) {
                if (!BMO_elem_flag_test(bm, f, FACE_VIS)) {
-                       bmo_righthandfaces_exec(bm, op);
+                       bmo_recalc_face_normals_exec(bm, op);
                        break;
                }
        }
 }
 
-void bmo_vertexsmooth_exec(BMesh *bm, BMOperator *op)
+void bmo_smooth_vert_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter siter;
        BMIter iter;
@@ -511,7 +511,7 @@ typedef struct SimSel_FaceExt {
  * Select similar faces, the choices are in the enum in source/blender/bmesh/bmesh_operators.h
  * We select either similar faces based on material, image, area, perimeter, normal, or the coplanar faces
  */
-void bmo_similarfaces_exec(BMesh *bm, BMOperator *op)
+void bmo_similar_faces_exec(BMesh *bm, BMOperator *op)
 {
        BMIter fm_iter;
        BMFace *fs, *fm;
@@ -684,7 +684,7 @@ typedef struct SimSel_EdgeExt {
  * select similar edges: the choices are in the enum in source/blender/bmesh/bmesh_operators.h
  * choices are length, direction, face, ...
  */
-void bmo_similaredges_exec(BMesh *bm, BMOperator *op)
+void bmo_similar_edges_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter es_iter;        /* selected edges iterator */
        BMIter e_iter;          /* mesh edges iterator */
@@ -882,7 +882,7 @@ typedef struct SimSel_VertExt {
  * select similar vertices: the choices are in the enum in source/blender/bmesh/bmesh_operators.h
  * choices are normal, face, vertex group...
  */
-void bmo_similarverts_exec(BMesh *bm, BMOperator *op)
+void bmo_similar_verts_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter vs_iter;        /* selected verts iterator */
        BMIter v_iter;          /* mesh verts iterator */
@@ -996,7 +996,7 @@ void bmo_similarverts_exec(BMesh *bm, BMOperator *op)
  * Cycle UVs for a face
  **************************************************************************** */
 
-void bmo_face_rotateuvs_exec(BMesh *bm, BMOperator *op)
+void bmo_rotate_uvs_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter fs_iter;        /* selected faces iterator */
        BMFace *fs;     /* current face */
@@ -1063,7 +1063,7 @@ void bmo_face_rotateuvs_exec(BMesh *bm, BMOperator *op)
  * Reverse UVs for a face
  **************************************************************************** */
 
-void bmo_face_reverseuvs_exec(BMesh *bm, BMOperator *op)
+void bmo_reverse_uvs_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter fs_iter;        /* selected faces iterator */
        BMFace *fs;             /* current face */
@@ -1103,7 +1103,7 @@ void bmo_face_reverseuvs_exec(BMesh *bm, BMOperator *op)
  * Cycle colors for a face
  **************************************************************************** */
 
-void bmo_rotatecolors_exec(BMesh *bm, BMOperator *op)
+void bmo_rotate_colors_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter fs_iter;        /* selected faces iterator */
        BMFace *fs;     /* current face */
@@ -1169,7 +1169,7 @@ void bmo_rotatecolors_exec(BMesh *bm, BMOperator *op)
  * Reverse colors for a face
  *************************************************************************** */
 
-void bmo_face_reversecolors_exec(BMesh *bm, BMOperator *op)
+void bmo_reverse_colors_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter fs_iter;        /* selected faces iterator */
        BMFace *fs;             /* current face */
@@ -1213,7 +1213,7 @@ typedef struct ElemNode {
        HeapNode *hn;   /* heap node */
 } ElemNode;
 
-void bmo_vertexshortestpath_exec(BMesh *bm, BMOperator *op)
+void bmo_shortest_path_exec(BMesh *bm, BMOperator *op)
 {
        BMOIter vs_iter /* , vs2_iter */;       /* selected verts iterator */
        BMIter v_iter;          /* mesh verts iterator */
index 4d8c83a5b2d335921781eee792c1cb0ad256e44f..86390e5650aadb3201ff8c18c5ebd5eaee14d097 100644 (file)
@@ -224,7 +224,7 @@ extern "C" {
  * For every CPUcore a working thread is created. These working threads will ask the WorkScheduler if there is work
  * for a specific Device.
  * the workscheduler will find work for the device and the device will be asked to execute the WorkPackage
-
+ *
  * @subsection singlethread Single threaded
  * For debugging reasons the multi-threading can be disabled. This is done by changing the COM_CURRENT_THREADING_MODEL
  * to COM_TM_NOTHREAD. When compiling the workscheduler
@@ -268,7 +268,7 @@ extern "C" {
  *
  * @section executePixel executing a pixel
  * Finally the last step, the node functionality :)
-
+ *
  * @page newnode Creating new nodes
  */
 
index 6cf22a1e2a4dcd78a37a5de451cdc5b0e52fa392..dbe98871c506cddcc5b52480ac54138bc93019ef 100644 (file)
@@ -60,7 +60,7 @@ public:
         *
         * @note Conversion logic is implemented in this method
         * @see InputSocketResizeMode for the possible conversions.
-
+        *
         * @param connection the SocketConnection what needs conversion
         * @param system the ExecutionSystem to add the conversion to.
         * @see SocketConnection - a link between two sockets
index c3c115b7c3b31806318819e73ed1a591e7c456a7..e5a145bab2e8303514a74b6429b2e63cdb5609de 100644 (file)
@@ -781,10 +781,10 @@ static void do_allEdgeDetection(unsigned int t, unsigned int rw, unsigned int *l
                        if (!limask[a]) {             // if the inner mask is empty
                                if (lomask[a]) {          // if the outer mask is full
                                        /*
-                                          Next we test all 4 directions around the current pixel: next/prev/up/down
-                                          The test ensures that the outer mask is empty and that the inner mask
-                                          is also empty. If both conditions are true for any one of the 4 adjacent pixels
-                                          then the current pixel is counted as being a true outer edge pixel.
+                                        * Next we test all 4 directions around the current pixel: next/prev/up/down
+                                        * The test ensures that the outer mask is empty and that the inner mask
+                                        * is also empty. If both conditions are true for any one of the 4 adjacent pixels
+                                        * then the current pixel is counted as being a true outer edge pixel.
                                         */
                                        if ((!lomask[pix_nextCol] && !limask[pix_nextCol]) ||
                                            (!lomask[pix_prevCol] && !limask[pix_prevCol]) ||
@@ -843,10 +843,10 @@ static void do_adjacentEdgeDetection(unsigned int t, unsigned int rw, unsigned i
                        if (!limask[a]) {                    // if the inner mask is empty
                                if (lomask[a]) {                 // if the outer mask is full
                                        /*
-                                          Next we test all 4 directions around the current pixel: next/prev/up/down
-                                          The test ensures that the outer mask is empty and that the inner mask
-                                          is also empty. If both conditions are true for any one of the 4 adjacent pixels
-                                          then the current pixel is counted as being a true outer edge pixel.
+                                        * Next we test all 4 directions around the current pixel: next/prev/up/down
+                                        * The test ensures that the outer mask is empty and that the inner mask
+                                        * is also empty. If both conditions are true for any one of the 4 adjacent pixels
+                                        * then the current pixel is counted as being a true outer edge pixel.
                                         */
                                        if ((!lomask[pix_nextCol] && !limask[pix_nextCol]) ||
                                            (!lomask[pix_prevCol] && !limask[pix_prevCol]) ||
@@ -902,65 +902,65 @@ static void do_createEdgeLocationBuffer(unsigned int t, unsigned int rw, unsigne
        unsigned int outerAccum = 0;       // for looping outer edge pixel indexes, represents current position from offset
        unsigned int gradientAccum = 0;    // for looping gradient pixel indexes, represents current position from offset
        /*
-          Here we compute the size of buffer needed to hold (row,col) coordinates
-          for each pixel previously determined to be either gradient, inner edge,
-          or outer edge.
-
-          Allocation is done by requesting 4 bytes "sizeof(int)" per pixel, even
-          though gbuf[] is declared as unsigned short* (2 bytes) because we don't
-          store the pixel indexes, we only store x,y location of pixel in buffer.
-
-          This does make the assumption that x and y can fit in 16 unsigned bits
-          so if Blender starts doing renders greater than 65536 in either direction
-          this will need to allocate gbuf[] as unsigned int *and allocate 8 bytes
-          per flagged pixel.
-
-          In general, the buffer on-screen:
-
-          Example:  9 by 9 pixel block
-
-          . = pixel non-white in both outer and inner mask
-          o = pixel white in outer, but not inner mask, adjacent to "." pixel
-          g = pixel white in outer, but not inner mask, not adjacent to "." pixel
-          i = pixel white in inner mask, adjacent to "g" or "." pixel
-          F = pixel white in inner mask, only adjacent to other pixels white in the inner mask
-
-
-          .........   <----- pixel #80
-          ..oooo...
-          .oggggo..
-          .oggiggo.
-          .ogiFigo.
-          .oggiggo.
-          .oggggo..
-          ..oooo...
-          pixel #00 -----> .........
-
-          gsz = 18   (18 "g" pixels above)
-          isz = 4    (4 "i" pixels above)
-          osz = 18   (18 "o" pixels above)
-
-
-          The memory in gbuf[] after filling will look like this:
-
-          gradientFillOffset (0 pixels)                   innerEdgeOffset (18 pixels)    outerEdgeOffset (22 pixels)
-          /                                               /                              /
-          /                                               /                              /
-          |X   Y   X   Y   X   Y   X   Y   >     <X   Y   X   Y   >     <X   Y   X   Y   X   Y   >     <X   Y   X   Y   | <- (x,y)
-          +-------------------------------->     <---------------->     <------------------------>     <----------------+
-          |0   2   4   6   8   10  12  14  > ... <68  70  72  74  > ... <80  82  84  86  88  90  > ... <152 154 156 158 | <- bytes
-          +-------------------------------->     <---------------->     <------------------------>     <----------------+
-          |g0  g0  g1  g1  g2  g2  g3  g3  >     <g17 g17 i0  i0  >     <i2  i2  i3  i3  o0  o0  >     <o16 o16 o17 o17 | <- pixel
-                /                              /                              /
-               /                              /                              /
-                 /                              /                              /
-          +---------- gradientAccum (18) ---------+      +--- innerAccum (22) ---+      +--- outerAccum (40) ---+
-
-
-          Ultimately we do need the pixel's memory buffer index to set the output
-          pixel color, but it's faster to reconstruct the memory buffer location
-          each iteration of the final gradient calculation than it is to deconstruct
-          a memory location into x,y pairs each round.
+        * Here we compute the size of buffer needed to hold (row,col) coordinates
+        * for each pixel previously determined to be either gradient, inner edge,
+        * or outer edge.
+        *
+        * Allocation is done by requesting 4 bytes "sizeof(int)" per pixel, even
+        * though gbuf[] is declared as unsigned short* (2 bytes) because we don't
+        * store the pixel indexes, we only store x,y location of pixel in buffer.
+        *
+        * This does make the assumption that x and y can fit in 16 unsigned bits
+        * so if Blender starts doing renders greater than 65536 in either direction
+        * this will need to allocate gbuf[] as unsigned int *and allocate 8 bytes
+        * per flagged pixel.
+        *
+        * In general, the buffer on-screen:
+        *
+        * Example:  9 by 9 pixel block
+        *
+        * . = pixel non-white in both outer and inner mask
+        * o = pixel white in outer, but not inner mask, adjacent to "." pixel
+        * g = pixel white in outer, but not inner mask, not adjacent to "." pixel
+        * i = pixel white in inner mask, adjacent to "g" or "." pixel
+        * F = pixel white in inner mask, only adjacent to other pixels white in the inner mask
+        *
+        *
+        * .........   <----- pixel #80
+        * ..oooo...
+        * .oggggo..
+        * .oggiggo.
+        * .ogiFigo.
+        * .oggiggo.
+        * .oggggo..
+        * ..oooo...
+        * pixel #00 -----> .........
+        *
+        * gsz = 18   (18 "g" pixels above)
+        * isz = 4    (4 "i" pixels above)
+        * osz = 18   (18 "o" pixels above)
+        *
+        *
+        * The memory in gbuf[] after filling will look like this:
+        *
+        * gradientFillOffset (0 pixels)                   innerEdgeOffset (18 pixels)    outerEdgeOffset (22 pixels)
+        * /                                               /                              /
+        * /                                               /                              /
+        * |X   Y   X   Y   X   Y   X   Y   >     <X   Y   X   Y   >     <X   Y   X   Y   X   Y   >     <X   Y   X   Y   | <- (x,y)
+        * +-------------------------------->     <---------------->     <------------------------>     <----------------+
+        * |0   2   4   6   8   10  12  14  > ... <68  70  72  74  > ... <80  82  84  86  88  90  > ... <152 154 156 158 | <- bytes
+        * +-------------------------------->     <---------------->     <------------------------>     <----------------+
+        * |g0  g0  g1  g1  g2  g2  g3  g3  >     <g17 g17 i0  i0  >     <i2  i2  i3  i3  o0  o0  >     <o16 o16 o17 o17 | <- pixel
+        *       /                              /                              /
+        *      /                              /                              /
+        *        /                              /                              /
+        * +---------- gradientAccum (18) ---------+      +--- innerAccum (22) ---+      +--- outerAccum (40) ---+
+        *
+        *
+        * Ultimately we do need the pixel's memory buffer index to set the output
+        * pixel color, but it's faster to reconstruct the memory buffer location
+        * each iteration of the final gradient calculation than it is to deconstruct
+        * a memory location into x,y pairs each round.
         */
 
 
index 694aa26bcde40741370b76200aeba25eb3ec0511..cb4c27a4c80bfe20f728c01c5c43ae0f218870d2 100644 (file)
@@ -120,8 +120,8 @@ static void FHT(fREAL *data, unsigned int M, unsigned int inverse)
 }
 //------------------------------------------------------------------------------
 /* 2D Fast Hartley Transform, Mx/My -> log2 of width/height,
   nzp -> the row where zero pad data starts,
   inverse -> see above */
* nzp -> the row where zero pad data starts,
* inverse -> see above */
 static void FHT2D(fREAL *data, unsigned int Mx, unsigned int My,
                   unsigned int nzp, unsigned int inverse)
 {
index bffcdb9687781b1354a7edab07ceaaf8bcfddabf..1a8e71a306b1ae040697183112e32b115788870c 100644 (file)
@@ -27,8 +27,8 @@
 #include "COM_NodeOperation.h"
 
 /**
 * Class with implementation of black/white clipping for keying node
 */
+ * Class with implementation of black/white clipping for keying node
+ */
 class KeyingClipOperation : public NodeOperation {
 protected:
        float m_clipBlack;
index 879ee0acaca87033abb677ec647004fef557f901..4fea9b578a117876b0ff1f7932894f9da1d4bdbb 100644 (file)
@@ -27,8 +27,8 @@
 #include "COM_NodeOperation.h"
 
 /**
 * Class with implementation of keying despill node
 */
+ * Class with implementation of keying despill node
+ */
 class KeyingDespillOperation : public NodeOperation {
 protected:
        SocketReader *m_pixelReader;
index 61036bead80647b960d06d854791d00c31a7301c..736db54850ab3cd0c1cfa7c4f706eca162dc3fab 100644 (file)
@@ -32,8 +32,8 @@
 #include "BLI_listbase.h"
 
 /**
 * Class with implementation of keying node
 */
+ * Class with implementation of keying node
+ */
 class KeyingOperation : public NodeOperation {
 protected:
        SocketReader *m_pixelReader;
index 898399f723d4ad88144eb8a0ad05026bcfd368c0..2ceb8aeef269255f50a213980294e6851efc71bf 100644 (file)
@@ -2007,9 +2007,9 @@ static void knifenet_fill_faces(KnifeTool_OpData *kcd)
        remerge_faces(kcd);
 
        /* delete left over faces */
-       BMO_op_callf(bm, "del geom=%ff context=%i", DEL, DEL_ONLYFACES);
-       BMO_op_callf(bm, "del geom=%fe context=%i", DEL, DEL_EDGES);
-       BMO_op_callf(bm, "del geom=%fv context=%i", DEL, DEL_VERTS);
+       BMO_op_callf(bm, "delete geom=%ff context=%i", DEL, DEL_ONLYFACES);
+       BMO_op_callf(bm, "delete geom=%fe context=%i", DEL, DEL_EDGES);
+       BMO_op_callf(bm, "delete geom=%fv context=%i", DEL, DEL_VERTS);
 
        if (face_nets) 
                MEM_freeN(face_nets);
index 1bcd5cee111c636d50af226cfdd1e6fdcb871f73..f71ec56ca5f0026e3bd92cc7daf459a879cf7ebe 100644 (file)
@@ -347,7 +347,7 @@ static int edbm_rip_call_edgesplit(BMEditMesh *em, wmOperator *op)
 {
        BMOperator bmop;
 
-       if (!EDBM_op_init(em, &bmop, op, "edgesplit edges=%he verts=%hv use_verts=%b",
+       if (!EDBM_op_init(em, &bmop, op, "split_edges edges=%he verts=%hv use_verts=%b",
                          BM_ELEM_TAG, BM_ELEM_SELECT, TRUE))
        {
                return FALSE;
index 0ef62e536fad38e468aed910bd06dcbc260b2445..5404eb3bea63d3c7bf2c63f95075bfdf9320f8ed 100644 (file)
@@ -710,7 +710,7 @@ static int similar_face_select_exec(bContext *C, wmOperator *op)
        float thresh = RNA_float_get(op->ptr, "threshold");
 
        /* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
-       EDBM_op_init(em, &bmop, op, "similarfaces faces=%hf type=%i thresh=%f", BM_ELEM_SELECT, type, thresh);
+       EDBM_op_init(em, &bmop, op, "similar_faces faces=%hf type=%i thresh=%f", BM_ELEM_SELECT, type, thresh);
 
        /* execute the operator */
        BMO_op_exec(em->bm, &bmop);
@@ -748,7 +748,7 @@ static int similar_edge_select_exec(bContext *C, wmOperator *op)
        float thresh = RNA_float_get(op->ptr, "threshold");
 
        /* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
-       EDBM_op_init(em, &bmop, op, "similaredges edges=%he type=%i thresh=%f", BM_ELEM_SELECT, type, thresh);
+       EDBM_op_init(em, &bmop, op, "similar_edges edges=%he type=%i thresh=%f", BM_ELEM_SELECT, type, thresh);
 
        /* execute the operator */
        BMO_op_exec(em->bm, &bmop);
@@ -789,7 +789,7 @@ static int similar_vert_select_exec(bContext *C, wmOperator *op)
        float thresh = RNA_float_get(op->ptr, "threshold");
 
        /* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
-       EDBM_op_init(em, &bmop, op, "similarverts verts=%hv type=%i thresh=%f", BM_ELEM_SELECT, type, thresh);
+       EDBM_op_init(em, &bmop, op, "similar_verts verts=%hv type=%i thresh=%f", BM_ELEM_SELECT, type, thresh);
 
        /* execute the operator */
        BMO_op_exec(em->bm, &bmop);
index a86a274eb70db158cb1ba8d1eee1e2709f000ae8..f08c229d38aa7eff74b78f1955ef2b57026e9683 100644 (file)
@@ -211,7 +211,7 @@ static void vtx_slide_confirm(bContext *C, wmOperator *op)
                if (other_d < vso->snap_threshold) {
                        BM_vert_select_set(bm, other, TRUE);
                        BM_vert_select_set(bm, vso->start_vtx, TRUE);
-                       EDBM_op_callf(em, op, "pointmerge verts=%hv mergeco=%v", BM_ELEM_SELECT, other->co);
+                       EDBM_op_callf(em, op, "pointmerge verts=%hv merge_co=%v", BM_ELEM_SELECT, other->co);
                        EDBM_flag_disable_all(em, BM_ELEM_SELECT);
                }
                else {
@@ -687,7 +687,7 @@ static int edbm_vertex_slide_exec(bContext *C, wmOperator *op)
 
        /* Prepare operator */
        if (!EDBM_op_init(em, &bmop, op,
-                         "vertex_slide vert=%e edge=%hev distance_t=%f",
+                         "slide_vert vert=%e edge=%hev distance_t=%f",
                          start_vert, BM_ELEM_SELECT, distance_t))
        {
                return OPERATOR_CANCELLED;
index 0f7d4c5c54745568020f9ac1c130d73cf0d3e046..8c77e8bec65e4473c62ada1660472e11f80a5516 100644 (file)
@@ -172,7 +172,7 @@ void EMBM_project_snap_verts(bContext *C, ARegion *ar, Object *obedit, BMEditMes
 
 /* individual face extrude */
 /* will use vertex normals for extrusion directions, so *nor is unaffected */
-static short edbm_extrude_face_indiv(BMEditMesh *em, wmOperator *op, const char hflag, float *UNUSED(nor))
+static short edbm_extrude_discrete_faces(BMEditMesh *em, wmOperator *op, const char hflag, float *UNUSED(nor))
 {
        BMOIter siter;
        BMIter liter;
@@ -180,7 +180,7 @@ static short edbm_extrude_face_indiv(BMEditMesh *em, wmOperator *op, const char
        BMLoop *l;
        BMOperator bmop;
 
-       EDBM_op_init(em, &bmop, op, "extrude_face_indiv faces=%hf", hflag);
+       EDBM_op_init(em, &bmop, op, "extrude_discrete_faces faces=%hf", hflag);
 
        /* deselect original verts */
        EDBM_flag_disable_all(em, BM_ELEM_SELECT);
@@ -473,7 +473,7 @@ static int edbm_extrude_mesh(Scene *scene, Object *obedit, BMEditMesh *em, wmOpe
        else if (nr == 1) transmode = edbm_extrude_edge(obedit, em, BM_ELEM_SELECT, nor);
        else if (nr == 4) transmode = edbm_extrude_verts_indiv(em, op, BM_ELEM_SELECT, nor);
        else if (nr == 3) transmode = edbm_extrude_edges_indiv(em, op, BM_ELEM_SELECT, nor);
-       else transmode = edbm_extrude_face_indiv(em, op, BM_ELEM_SELECT, nor);
+       else transmode = edbm_extrude_discrete_faces(em, op, BM_ELEM_SELECT, nor);
        
        if (transmode == 0) {
                BKE_report(op->reports, RPT_ERROR, "Not a valid selection for extrude");
@@ -614,7 +614,7 @@ static int edbm_extrude_faces_exec(bContext *C, wmOperator *op)
        BMEditMesh *em = BMEdit_FromObject(obedit);
        float nor[3];
 
-       edbm_extrude_face_indiv(em, op, BM_ELEM_SELECT, nor);
+       edbm_extrude_discrete_faces(em, op, BM_ELEM_SELECT, nor);
        
        EDBM_update_generic(C, em, TRUE);
        
@@ -853,7 +853,7 @@ static int edbm_dupli_extrude_cursor_invoke(bContext *C, wmOperator *op, wmEvent
                invert_m4_m4(vc.obedit->imat, vc.obedit->obmat);
                mul_m4_v3(vc.obedit->imat, min); // back in object space
                
-               EDBM_op_init(vc.em, &bmop, op, "makevert co=%v", min);
+