Merging r50602 through r50617 form trunk into soc-2011-tomato
authorSergey Sharybin <sergey.vfx@gmail.com>
Sat, 15 Sep 2012 06:24:48 +0000 (06:24 +0000)
committerSergey Sharybin <sergey.vfx@gmail.com>
Sat, 15 Sep 2012 06:24:48 +0000 (06:24 +0000)
106 files changed:
CMakeLists.txt
build_files/cmake/macros.cmake
intern/audaspace/intern/AUD_C-API.cpp
intern/audaspace/intern/AUD_C-API.h
intern/cycles/kernel/osl/nodes/CMakeLists.txt
intern/cycles/kernel/osl/nodes/node_object_info.osl [new file with mode: 0644]
intern/cycles/kernel/osl/nodes/node_particle_info.osl [new file with mode: 0644]
intern/cycles/kernel/osl/osl_globals.h
intern/cycles/kernel/osl/osl_services.cpp
intern/cycles/kernel/osl/osl_services.h
intern/ghost/intern/GHOST_WindowCarbon.cpp
intern/ghost/intern/GHOST_WindowWin32.cpp
intern/ghost/intern/GHOST_WindowWin32.h
intern/mikktspace/mikktspace.c
intern/raskter/raskter.c
intern/utfconv/utfconv.c
source/blender/blenkernel/BKE_colortools.h
source/blender/blenkernel/BKE_customdata.h
source/blender/blenkernel/BKE_mask.h
source/blender/blenkernel/CMakeLists.txt
source/blender/blenkernel/intern/blender.c
source/blender/blenkernel/intern/cloth.c
source/blender/blenkernel/intern/dynamicpaint.c
source/blender/blenkernel/intern/implicit.c
source/blender/blenkernel/intern/mask.c
source/blender/blenkernel/intern/mask_rasterize.c
source/blender/blenkernel/intern/movieclip.c
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/particle_system.c
source/blender/blenkernel/intern/seqmodifier.c
source/blender/blenkernel/intern/smoke.c
source/blender/blenkernel/intern/text.c
source/blender/blenkernel/intern/texture.c
source/blender/blenkernel/intern/tracking.c
source/blender/blenkernel/intern/writeffmpeg.c
source/blender/blenlib/BLI_math_color.h
source/blender/blenlib/intern/math_color.c
source/blender/blenlib/intern/md5.c
source/blender/blenlib/intern/pbvh.c
source/blender/blenlib/intern/voronoi.c
source/blender/blenlib/intern/winstuff.c
source/blender/blenloader/BLO_readfile.h
source/blender/blenloader/intern/readfile.c
source/blender/bmesh/operators/bmo_dissolve.c
source/blender/bmesh/operators/bmo_hull.c
source/blender/bmesh/operators/bmo_removedoubles.c
source/blender/bmesh/operators/bmo_wireframe.c
source/blender/bmesh/tools/BME_bevel.c
source/blender/collada/ImageExporter.cpp
source/blender/editors/animation/keyframing.c
source/blender/editors/armature/poseobject.c
source/blender/editors/include/ED_mask.h
source/blender/editors/include/ED_sequencer.h
source/blender/editors/include/ED_util.h
source/blender/editors/interface/interface_ops.c
source/blender/editors/io/io_ops.c
source/blender/editors/mask/mask_editaction.c
source/blender/editors/object/object_add.c
source/blender/editors/physics/physics_fluid.c
source/blender/editors/sculpt_paint/paint_image.c
source/blender/editors/sculpt_paint/paint_ops.c
source/blender/editors/sculpt_paint/paint_stroke.c
source/blender/editors/sculpt_paint/paint_vertex.c
source/blender/editors/sculpt_paint/sculpt_uv.c
source/blender/editors/space_clip/clip_graph_draw.c
source/blender/editors/space_clip/clip_graph_ops.c
source/blender/editors/space_image/image_ops.c
source/blender/editors/space_nla/nla_edit.c
source/blender/editors/space_node/drawnode.c
source/blender/editors/space_node/space_node.c
source/blender/editors/space_sequencer/sequencer_ops.c
source/blender/editors/space_sequencer/sequencer_view.c
source/blender/editors/space_view3d/drawmesh.c
source/blender/editors/space_view3d/view3d_select.c
source/blender/editors/uvedit/uvedit_ops.c
source/blender/imbuf/intern/divers.c
source/blender/imbuf/intern/indexer_dv.c
source/blender/imbuf/intern/util.c
source/blender/modifiers/intern/MOD_weightvgproximity.c
source/blender/nodes/intern/node_common.c
source/blender/nodes/intern/node_util.h
source/blender/nodes/texture/node_texture_util.h
source/blender/python/bmesh/bmesh_py_ops.c
source/blender/python/intern/CMakeLists.txt
source/blender/python/intern/bpy.c
source/blender/python/intern/bpy.h
source/blender/python/intern/bpy_app_ffmpeg.c
source/blender/python/intern/bpy_app_handlers.c
source/blender/python/intern/bpy_interface_atexit.c
source/blender/python/intern/bpy_library.c
source/blender/python/intern/bpy_library.h [new file with mode: 0644]
source/blender/python/intern/bpy_rna.c
source/blender/python/intern/bpy_rna.h
source/blender/python/intern/gpu.c
source/blender/python/intern/stubs.c
source/blender/render/intern/include/zbuf.h
source/blender/render/intern/source/convertblender.c
source/blender/render/intern/source/render_texture.c
source/blender/render/intern/source/strand.c
source/blender/render/intern/source/texture_ocean.c
source/blender/render/intern/source/zbuf.c
source/blender/windowmanager/WM_api.h
source/blender/windowmanager/intern/wm_init_exit.c
source/blender/windowmanager/intern/wm_operators.c
source/blender/windowmanager/intern/wm_playanim.c
source/creator/creator.c

index 39c1474529dafcb5ce08d279c500ad782ef39d7f..83e094b437532a4a5176f7e2315adbf3bbc10133 100644 (file)
@@ -1716,9 +1716,10 @@ if(CMAKE_COMPILER_IS_GNUCC)
        ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_CAST_ALIGN -Wcast-align)
        ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_ERROR_DECLARATION_AFTER_STATEMENT -Werror=declaration-after-statement)
        ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_ERROR_IMPLICIT_FUNCTION_DECLARATION -Werror=implicit-function-declaration)
-       ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_ERROR_RETURN_TYPE -Werror=return-type)
+       ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_ERROR_RETURN_TYPE  -Werror=return-type)
        # system headers sometimes do this, disable for now, was: -Werror=strict-prototypes
-       ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_STRICT_PROTOTYPES -Wstrict-prototypes)
+       ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_STRICT_PROTOTYPES  -Wstrict-prototypes)
+       ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_MISSING_PROTOTYPES -Wmissing-prototypes)
        ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_NO_CHAR_SUBSCRIPTS -Wno-char-subscripts)
        ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_NO_UNKNOWN_PRAGMAS -Wno-unknown-pragmas)
        ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_POINTER_ARITH -Wpointer-arith)
@@ -1752,10 +1753,13 @@ if(CMAKE_COMPILER_IS_GNUCC)
 
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 
+       # strange, clang complains these are not supported, but then yses them.
        ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_ALL -Wall)
        ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_NO_AUTOLOGICAL_COMPARE -Wno-tautological-compare)
        ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_NO_UNKNOWN_PRAGMAS -Wno-unknown-pragmas)
        ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_NO_CHAR_SUBSCRIPTS -Wno-char-subscripts)
+       ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_STRICT_PROTOTYPES  -Wstrict-prototypes)
+       ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_MISSING_PROTOTYPES -Wmissing-prototypes)
 
        ADD_CHECK_C_COMPILER_FLAG(CXX_WARNINGS C_WARN_ALL -Wall)
        ADD_CHECK_C_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_NO_AUTOLOGICAL_COMPARE -Wno-tautological-compare)
index ad5e3155368d0566d62f01c7039d142cea4787d7..43cfb31c03c48732af1dbc14499d954396667bd6 100644 (file)
@@ -476,6 +476,7 @@ macro(remove_strict_flags)
 
        if(CMAKE_COMPILER_IS_GNUCC)
                remove_cc_flag("-Wstrict-prototypes")
+               remove_cc_flag("-Wmissing-prototypes")
                remove_cc_flag("-Wunused-parameter")
                remove_cc_flag("-Wwrite-strings")
                remove_cc_flag("-Wundef")
index a7d37da042689279078d4f6f9002ddb552b8a08d..46bba237cffa683aa743a5ea0d38633704ee8c6d 100644 (file)
@@ -99,11 +99,11 @@ typedef AUD_Reference<AUD_SequencerEntry> AUD_SEntry;
 #include "AUD_C-API.h"
 
 #ifndef NULL
-#define NULL 0
+#  define NULL (void *)0
 #endif
 
 static AUD_Reference<AUD_IDevice> AUD_device;
-static AUD_I3DDeviceAUD_3ddevice;
+static AUD_I3DDevice *AUD_3ddevice;
 
 void AUD_initOnce()
 {
@@ -116,13 +116,12 @@ int AUD_init(AUD_DeviceType device, AUD_DeviceSpecs specs, int buffersize)
 {
        AUD_Reference<AUD_IDevice> dev;
 
-       if(!AUD_device.isNull())
+       if (!AUD_device.isNull()) {
                AUD_exit();
+       }
 
-       try
-       {
-               switch(device)
-               {
+       try {
+               switch(device) {
                case AUD_NULL_DEVICE:
                        dev = new AUD_NULLDevice();
                        break;
@@ -140,8 +139,7 @@ int AUD_init(AUD_DeviceType device, AUD_DeviceSpecs specs, int buffersize)
                case AUD_JACK_DEVICE:
 #ifdef __APPLE__
                        struct stat st;
-                       if(stat("/Library/Frameworks/Jackmp.framework", &st) != 0)
-                       {
+                       if (stat("/Library/Frameworks/Jackmp.framework", &st) != 0) {
                                printf("Warning: Jack Framework not installed\n");
                                // No break, fall through to default, to return false
                        }
@@ -159,7 +157,7 @@ int AUD_init(AUD_DeviceType device, AUD_DeviceSpecs specs, int buffersize)
                }
 
                AUD_device = dev;
-               AUD_3ddevice = dynamic_cast<AUD_I3DDevice*>(AUD_device.get());
+               AUD_3ddevice = dynamic_cast<AUD_I3DDevice *>(AUD_device.get());
 
                return true;
        }
@@ -176,48 +174,44 @@ void AUD_exit()
 }
 
 #ifdef WITH_PYTHON
-static PyObject* AUD_getCDevice(PyObject* self)
+static PyObject *AUD_getCDevice(PyObject *self)
 {
-       if(!AUD_device.isNull())
-       {
-               Device* device = (Device*)Device_empty();
-               if(device != NULL)
-               {
+       if (!AUD_device.isNull()) {
+               Device *device = (Device *)Device_empty();
+               if (device != NULL) {
                        device->device = new AUD_Reference<AUD_IDevice>(AUD_device);
-                       return (PyObject*)device;
+                       return (PyObject *)device;
                }
        }
 
        Py_RETURN_NONE;
 }
 
-static PyMethodDef meth_getcdevice[] = {{ "device", (PyCFunction)AUD_getCDevice, METH_NOARGS,
-                                                                                 "device()\n\n"
-                                                                                 "Returns the application's :class:`Device`.\n\n"
-                                                                                 ":return: The application's :class:`Device`.\n"
-                                                                                 ":rtype: :class:`Device`"}};
+static PyMethodDef meth_getcdevice[] = {
+    {"device", (PyCFunction)AUD_getCDevice, METH_NOARGS,
+     "device()\n\n"
+     "Returns the application's :class:`Device`.\n\n"
+     ":return: The application's :class:`Device`.\n"
+     ":rtype: :class:`Device`"}
+};
 
 extern "C" {
-extern void* sound_get_factory(void* sound);
+extern void *sound_get_factory(void *sound);
 }
 
-static PyObject* AUD_getSoundFromPointer(PyObject* self, PyObject* args)
+static PyObject *AUD_getSoundFromPointer(PyObject *self, PyObject *args)
 {
        long int lptr;
 
-       if(PyArg_Parse(args, "l:_sound_from_pointer", &lptr))
-       {
-               if(lptr)
-               {
-                       AUD_Reference<AUD_IFactory>* factory = (AUD_Reference<AUD_IFactory>*) sound_get_factory((void*) lptr);
+       if (PyArg_Parse(args, "l:_sound_from_pointer", &lptr)) {
+               if (lptr) {
+                       AUD_Reference<AUD_IFactory>* factory = (AUD_Reference<AUD_IFactory>*) sound_get_factory((void *) lptr);
 
-                       if(factory)
-                       {
-                               Factory* obj = (Factory*) Factory_empty();
-                               if(obj)
-                               {
+                       if (factory) {
+                               Factory *obj = (Factory *)Factory_empty();
+                               if (obj) {
                                        obj->factory = new AUD_Reference<AUD_IFactory>(*factory);
-                                       return (PyObject*) obj;
+                                       return (PyObject *) obj;
                                }
                        }
                }
@@ -226,44 +220,44 @@ static PyObject* AUD_getSoundFromPointer(PyObject* self, PyObject* args)
        Py_RETURN_NONE;
 }
 
-static PyMethodDef meth_sound_from_pointer[] = {{ "_sound_from_pointer", (PyCFunction)AUD_getSoundFromPointer, METH_O,
-                                                                                 "_sound_from_pointer(pointer)\n\n"
-                                                                                 "Returns the corresponding :class:`Factory` object.\n\n"
-                                                                                 ":arg pointer: The pointer to the bSound object as long.\n"
-                                                                                 ":type pointer: long\n"
-                                                                                 ":return: The corresponding :class:`Factory` object.\n"
-                                                                                 ":rtype: :class:`Factory`"}};
+static PyMethodDef meth_sound_from_pointer[] = {
+    {"_sound_from_pointer", (PyCFunction)AUD_getSoundFromPointer, METH_O,
+     "_sound_from_pointer(pointer)\n\n"
+     "Returns the corresponding :class:`Factory` object.\n\n"
+     ":arg pointer: The pointer to the bSound object as long.\n"
+     ":type pointer: long\n"
+     ":return: The corresponding :class:`Factory` object.\n"
+     ":rtype: :class:`Factory`"}
+};
 
-PyObjectAUD_initPython()
+PyObject *AUD_initPython()
 {
-       PyObjectmodule = PyInit_aud();
-       PyModule_AddObject(module, "device", (PyObject*)PyCFunction_New(meth_getcdevice, NULL));
-       PyModule_AddObject(module, "_sound_from_pointer", (PyObject*)PyCFunction_New(meth_sound_from_pointer, NULL));
+       PyObject *module = PyInit_aud();
+       PyModule_AddObject(module, "device", (PyObject *)PyCFunction_New(meth_getcdevice, NULL));
+       PyModule_AddObject(module, "_sound_from_pointer", (PyObject *)PyCFunction_New(meth_sound_from_pointer, NULL));
        PyDict_SetItemString(PyImport_GetModuleDict(), "aud", module);
 
        return module;
 }
 
-void* AUD_getPythonFactory(AUD_Sound* sound)
+void *AUD_getPythonFactory(AUD_Sound *sound)
 {
-       if(sound)
-       {
-               Factory* obj = (Factory*) Factory_empty();
-               if(obj)
-               {
+       if (sound) {
+               Factory *obj = (Factory *) Factory_empty();
+               if (obj) {
                        obj->factory = new AUD_Reference<AUD_IFactory>(*sound);
-                       return (PyObject*) obj;
+                       return (PyObject *) obj;
                }
        }
 
        return NULL;
 }
 
-AUD_Sound* AUD_getPythonSound(void* sound)
+AUD_Sound *AUD_getPythonSound(void *sound)
 {
-       Factoryfactory = checkFactory((PyObject *)sound);
+       Factory *factory = checkFactory((PyObject *)sound);
 
-       if(!factory)
+       if (!factory)
                return NULL;
 
        return new AUD_Reference<AUD_IFactory>(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(factory->factory));
@@ -281,7 +275,7 @@ void AUD_unlock()
        AUD_device->unlock();
 }
 
-AUD_SoundInfo AUD_getInfo(AUD_Soundsound)
+AUD_SoundInfo AUD_getInfo(AUD_Sound *sound)
 {
        assert(sound);
 
@@ -290,12 +284,10 @@ AUD_SoundInfo AUD_getInfo(AUD_Sound* sound)
        info.specs.rate = AUD_RATE_INVALID;
        info.length = 0.0f;
 
-       try
-       {
+       try {
                AUD_Reference<AUD_IReader> reader = (*sound)->createReader();
 
-               if(!reader.isNull())
-               {
+               if (!reader.isNull()) {
                        info.specs = reader->getSpecs();
                        info.length = reader->getLength() / (float) info.specs.rate;
                }
@@ -307,24 +299,23 @@ AUD_SoundInfo AUD_getInfo(AUD_Sound* sound)
        return info;
 }
 
-AUD_Sound* AUD_load(const char* filename)
+AUD_Sound *AUD_load(const char *filename)
 {
        assert(filename);
        return new AUD_Sound(new AUD_FileFactory(filename));
 }
 
-AUD_Sound* AUD_loadBuffer(unsigned char* buffer, int size)
+AUD_Sound *AUD_loadBuffer(unsigned char *buffer, int size)
 {
        assert(buffer);
        return new AUD_Sound(new AUD_FileFactory(buffer, size));
 }
 
-AUD_Sound* AUD_bufferSound(AUD_Sound* sound)
+AUD_Sound *AUD_bufferSound(AUD_Sound *sound)
 {
        assert(sound);
 
-       try
-       {
+       try {
                return new AUD_Sound(new AUD_StreamBufferFactory(*sound));
        }
        catch(AUD_Exception&)
@@ -333,12 +324,11 @@ AUD_Sound* AUD_bufferSound(AUD_Sound* sound)
        }
 }
 
-AUD_Sound* AUD_monoSound(AUD_Sound* sound)
+AUD_Sound *AUD_monoSound(AUD_Sound *sound)
 {
        assert(sound);
 
-       try
-       {
+       try {
                AUD_DeviceSpecs specs;
                specs.channels = AUD_CHANNELS_MONO;
                specs.rate = AUD_RATE_INVALID;
@@ -351,12 +341,11 @@ AUD_Sound* AUD_monoSound(AUD_Sound* sound)
        }
 }
 
-AUD_Sound* AUD_delaySound(AUD_Sound* sound, float delay)
+AUD_Sound *AUD_delaySound(AUD_Sound *sound, float delay)
 {
        assert(sound);
 
-       try
-       {
+       try {
                return new AUD_Sound(new AUD_DelayFactory(*sound, delay));
        }
        catch(AUD_Exception&)
@@ -365,12 +354,11 @@ AUD_Sound* AUD_delaySound(AUD_Sound* sound, float delay)
        }
 }
 
-AUD_Sound* AUD_limitSound(AUD_Sound* sound, float start, float end)
+AUD_Sound *AUD_limitSound(AUD_Sound *sound, float start, float end)
 {
        assert(sound);
 
-       try
-       {
+       try {
                return new AUD_Sound(new AUD_LimiterFactory(*sound, start, end));
        }
        catch(AUD_Exception&)
@@ -379,12 +367,11 @@ AUD_Sound* AUD_limitSound(AUD_Sound* sound, float start, float end)
        }
 }
 
-AUD_Sound* AUD_pingpongSound(AUD_Sound* sound)
+AUD_Sound *AUD_pingpongSound(AUD_Sound *sound)
 {
        assert(sound);
 
-       try
-       {
+       try {
                return new AUD_Sound(new AUD_PingPongFactory(*sound));
        }
        catch(AUD_Exception&)
@@ -393,12 +380,11 @@ AUD_Sound* AUD_pingpongSound(AUD_Sound* sound)
        }
 }
 
-AUD_Sound* AUD_loopSound(AUD_Sound* sound)
+AUD_Sound *AUD_loopSound(AUD_Sound *sound)
 {
        assert(sound);
 
-       try
-       {
+       try {
                return new AUD_Sound(new AUD_LoopFactory(*sound));
        }
        catch(AUD_Exception&)
@@ -407,12 +393,11 @@ AUD_Sound* AUD_loopSound(AUD_Sound* sound)
        }
 }
 
-int AUD_setLoop(AUD_Handlehandle, int loops)
+int AUD_setLoop(AUD_Handle *handle, int loops)
 {
        assert(handle);
 
-       try
-       {
+       try {
                return (*handle)->setLoopCount(loops);
        }
        catch(AUD_Exception&)
@@ -422,12 +407,11 @@ int AUD_setLoop(AUD_Handle* handle, int loops)
        return false;
 }
 
-AUD_Sound* AUD_rectifySound(AUD_Sound* sound)
+AUD_Sound *AUD_rectifySound(AUD_Sound *sound)
 {
        assert(sound);
 
-       try
-       {
+       try {
                return new AUD_Sound(new AUD_RectifyFactory(*sound));
        }
        catch(AUD_Exception&)
@@ -436,20 +420,20 @@ AUD_Sound* AUD_rectifySound(AUD_Sound* sound)
        }
 }
 
-void AUD_unload(AUD_Soundsound)
+void AUD_unload(AUD_Sound *sound)
 {
        assert(sound);
        delete sound;
 }
 
-AUD_Handle* AUD_play(AUD_Sound* sound, int keep)
+AUD_Handle *AUD_play(AUD_Sound *sound, int keep)
 {
        assert(sound);
-       try
-       {
+       try {
                AUD_Handle handle = AUD_device->play(*sound, keep);
-               if(!handle.isNull())
+               if (!handle.isNull()) {
                        return new AUD_Handle(handle);
+               }
        }
        catch(AUD_Exception&)
        {
@@ -457,19 +441,19 @@ AUD_Handle* AUD_play(AUD_Sound* sound, int keep)
        return NULL;
 }
 
-int AUD_pause(AUD_Handlehandle)
+int AUD_pause(AUD_Handle *handle)
 {
        assert(handle);
        return (*handle)->pause();
 }
 
-int AUD_resume(AUD_Handlehandle)
+int AUD_resume(AUD_Handle *handle)
 {
        assert(handle);
        return (*handle)->resume();
 }
 
-int AUD_stop(AUD_Handlehandle)
+int AUD_stop(AUD_Handle *handle)
 {
        assert(handle);
        int result = (*handle)->stop();
@@ -477,34 +461,33 @@ int AUD_stop(AUD_Handle* handle)
        return result;
 }
 
-int AUD_setKeep(AUD_Handlehandle, int keep)
+int AUD_setKeep(AUD_Handle *handle, int keep)
 {
        assert(handle);
        return (*handle)->setKeep(keep);
 }
 
-int AUD_seek(AUD_Handlehandle, float seekTo)
+int AUD_seek(AUD_Handle *handle, float seekTo)
 {
        assert(handle);
        return (*handle)->seek(seekTo);
 }
 
-float AUD_getPosition(AUD_Handlehandle)
+float AUD_getPosition(AUD_Handle *handle)
 {
        assert(handle);
        return (*handle)->getPosition();
 }
 
-AUD_Status AUD_getStatus(AUD_Handlehandle)
+AUD_Status AUD_getStatus(AUD_Handle *handle)
 {
        assert(handle);
        return (*handle)->getStatus();
 }
 
-int AUD_setListenerLocation(const float* location)
+int AUD_setListenerLocation(const float location[3])
 {
-       if(AUD_3ddevice)
-       {
+       if (AUD_3ddevice) {
                AUD_Vector3 v(location[0], location[1], location[2]);
                AUD_3ddevice->setListenerLocation(v);
                return true;
@@ -513,10 +496,9 @@ int AUD_setListenerLocation(const float* location)
        return false;
 }
 
-int AUD_setListenerVelocity(const float* velocity)
+int AUD_setListenerVelocity(const float velocity[3])
 {
-       if(AUD_3ddevice)
-       {
+       if (AUD_3ddevice) {
                AUD_Vector3 v(velocity[0], velocity[1], velocity[2]);
                AUD_3ddevice->setListenerVelocity(v);
                return true;
@@ -525,10 +507,9 @@ int AUD_setListenerVelocity(const float* velocity)
        return false;
 }
 
-int AUD_setListenerOrientation(const float* orientation)
+int AUD_setListenerOrientation(const float orientation[4])
 {
-       if(AUD_3ddevice)
-       {
+       if (AUD_3ddevice) {
                AUD_Quaternion q(orientation[3], orientation[0], orientation[1], orientation[2]);
                AUD_3ddevice->setListenerOrientation(q);
                return true;
@@ -539,8 +520,7 @@ int AUD_setListenerOrientation(const float* orientation)
 
 int AUD_setSpeedOfSound(float speed)
 {
-       if(AUD_3ddevice)
-       {
+       if (AUD_3ddevice) {
                AUD_3ddevice->setSpeedOfSound(speed);
                return true;
        }
@@ -550,8 +530,7 @@ int AUD_setSpeedOfSound(float speed)
 
 int AUD_setDopplerFactor(float factor)
 {
-       if(AUD_3ddevice)
-       {
+       if (AUD_3ddevice) {
                AUD_3ddevice->setDopplerFactor(factor);
                return true;
        }
@@ -561,8 +540,7 @@ int AUD_setDopplerFactor(float factor)
 
 int AUD_setDistanceModel(AUD_DistanceModel model)
 {
-       if(AUD_3ddevice)
-       {
+       if (AUD_3ddevice) {
                AUD_3ddevice->setDistanceModel(model);
                return true;
        }
@@ -570,13 +548,12 @@ int AUD_setDistanceModel(AUD_DistanceModel model)
        return false;
 }
 
-int AUD_setSourceLocation(AUD_Handle* handle, const float* location)
+int AUD_setSourceLocation(AUD_Handle *handle, const float location[3])
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                AUD_Vector3 v(location[0], location[1], location[2]);
                return h->setSourceLocation(v);
        }
@@ -584,13 +561,12 @@ int AUD_setSourceLocation(AUD_Handle* handle, const float* location)
        return false;
 }
 
-int AUD_setSourceVelocity(AUD_Handle* handle, const float* velocity)
+int AUD_setSourceVelocity(AUD_Handle *handle, const float velocity[3])
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                AUD_Vector3 v(velocity[0], velocity[1], velocity[2]);
                return h->setSourceVelocity(v);
        }
@@ -598,13 +574,12 @@ int AUD_setSourceVelocity(AUD_Handle* handle, const float* velocity)
        return false;
 }
 
-int AUD_setSourceOrientation(AUD_Handle* handle, const float* orientation)
+int AUD_setSourceOrientation(AUD_Handle *handle, const float orientation[4])
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                AUD_Quaternion q(orientation[3], orientation[0], orientation[1], orientation[2]);
                return h->setSourceOrientation(q);
        }
@@ -612,149 +587,137 @@ int AUD_setSourceOrientation(AUD_Handle* handle, const float* orientation)
        return false;
 }
 
-int AUD_setRelative(AUD_Handlehandle, int relative)
+int AUD_setRelative(AUD_Handle *handle, int relative)
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                return h->setRelative(relative);
        }
 
        return false;
 }
 
-int AUD_setVolumeMaximum(AUD_Handlehandle, float volume)
+int AUD_setVolumeMaximum(AUD_Handle *handle, float volume)
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                return h->setVolumeMaximum(volume);
        }
 
        return false;
 }
 
-int AUD_setVolumeMinimum(AUD_Handlehandle, float volume)
+int AUD_setVolumeMinimum(AUD_Handle *handle, float volume)
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                return h->setVolumeMinimum(volume);
        }
 
        return false;
 }
 
-int AUD_setDistanceMaximum(AUD_Handlehandle, float distance)
+int AUD_setDistanceMaximum(AUD_Handle *handle, float distance)
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                return h->setDistanceMaximum(distance);
        }
 
        return false;
 }
 
-int AUD_setDistanceReference(AUD_Handlehandle, float distance)
+int AUD_setDistanceReference(AUD_Handle *handle, float distance)
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                return h->setDistanceReference(distance);
        }
 
        return false;
 }
 
-int AUD_setAttenuation(AUD_Handlehandle, float factor)
+int AUD_setAttenuation(AUD_Handle *handle, float factor)
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                return h->setAttenuation(factor);
        }
 
        return false;
 }
 
-int AUD_setConeAngleOuter(AUD_Handlehandle, float angle)
+int AUD_setConeAngleOuter(AUD_Handle *handle, float angle)
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                return h->setConeAngleOuter(angle);
        }
 
        return false;
 }
 
-int AUD_setConeAngleInner(AUD_Handlehandle, float angle)
+int AUD_setConeAngleInner(AUD_Handle *handle, float angle)
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                return h->setConeAngleInner(angle);
        }
 
        return false;
 }
 
-int AUD_setConeVolumeOuter(AUD_Handlehandle, float volume)
+int AUD_setConeVolumeOuter(AUD_Handle *handle, float volume)
 {
        assert(handle);
        AUD_Reference<AUD_I3DHandle> h(*handle);
 
-       if(!h.isNull())
-       {
+       if (!h.isNull()) {
                return h->setConeVolumeOuter(volume);
        }
 
        return false;
 }
 
-int AUD_setSoundVolume(AUD_Handlehandle, float volume)
+int AUD_setSoundVolume(AUD_Handle *handle, float volume)
 {
        assert(handle);
-       try
-       {
+       try {
                return (*handle)->setVolume(volume);
        }
        catch(AUD_Exception&) {}
        return false;
 }
 
-int AUD_setSoundPitch(AUD_Handlehandle, float pitch)
+int AUD_setSoundPitch(AUD_Handle *handle, float pitch)
 {
        assert(handle);
-       try
-       {
+       try {
                return (*handle)->setPitch(pitch);
        }
        catch(AUD_Exception&) {}
        return false;
 }
 
-AUD_DeviceAUD_openReadDevice(AUD_DeviceSpecs specs)
+AUD_Device *AUD_openReadDevice(AUD_DeviceSpecs specs)
 {
-       try
-       {
+       try {
                return new AUD_Device(new AUD_ReadDevice(specs));
        }
        catch(AUD_Exception&)
@@ -763,16 +726,14 @@ AUD_Device* AUD_openReadDevice(AUD_DeviceSpecs specs)
        }
 }
 
-AUD_Handle* AUD_playDevice(AUD_Device* device, AUD_Sound* sound, float seek)
+AUD_Handle *AUD_playDevice(AUD_Device *device, AUD_Sound *sound, float seek)
 {
        assert(device);
        assert(sound);
 
-       try
-       {
+       try {
                AUD_Handle handle = (*device)->play(*sound);
-               if(!handle.isNull())
-               {
+               if (!handle.isNull()) {
                        handle->seek(seek);
                        return new AUD_Handle(handle);
                }
@@ -783,12 +744,11 @@ AUD_Handle* AUD_playDevice(AUD_Device* device, AUD_Sound* sound, float seek)
        return NULL;
 }
 
-int AUD_setDeviceVolume(AUD_Devicedevice, float volume)
+int AUD_setDeviceVolume(AUD_Device *device, float volume)
 {
        assert(device);
 
-       try
-       {
+       try {
                (*device)->setVolume(volume);
                return true;
        }
@@ -797,13 +757,12 @@ int AUD_setDeviceVolume(AUD_Device* device, float volume)
        return false;
 }
 
-int AUD_readDevice(AUD_Device* device, data_t* buffer, int length)
+int AUD_readDevice(AUD_Device *device, data_t *buffer, int length)
 {
        assert(device);
        assert(buffer);
 
-       try
-       {
+       try {
                return (*device)->read(buffer, length);
        }
        catch(AUD_Exception&)
@@ -812,12 +771,11 @@ int AUD_readDevice(AUD_Device* device, data_t* buffer, int length)
        }
 }
 
-void AUD_closeReadDevice(AUD_Devicedevice)
+void AUD_closeReadDevice(AUD_Device *device)
 {
        assert(device);
 
-       try
-       {
+       try {
                delete device;
        }
        catch(AUD_Exception&)
@@ -825,10 +783,10 @@ void AUD_closeReadDevice(AUD_Device* device)
        }
 }
 
-float* AUD_readSoundBuffer(const char* filename, float low, float high,
-                                                  float attack, float release, float threshold,
-                                                  int accumulate, int additive, int square,
-                                                  float sthreshold, double samplerate, int* length)
+float *AUD_readSoundBuffer(const char *filename, float low, float high,
+                           float attack, float release, float threshold,
+                           int accumulate, int additive, int square,
+                           float sthreshold, double samplerate, int *length)
 {
        AUD_Buffer buffer;
        AUD_DeviceSpecs specs;
@@ -840,33 +798,32 @@ float* AUD_readSoundBuffer(const char* filename, float low, float high,
 
        int position = 0;
 
-       try
-       {
+       try {
                AUD_Reference<AUD_IReader> reader = file->createReader();
 
                AUD_SampleRate rate = reader->getSpecs().rate;
 
                sound = new AUD_ChannelMapperFactory(file, specs);
 
-               if(high < rate)
+               if (high < rate)
                        sound = new AUD_LowpassFactory(sound, high);
-               if(low > 0)
+               if (low > 0)
                        sound = new AUD_HighpassFactory(sound, low);
 
                sound = new AUD_EnvelopeFactory(sound, attack, release, threshold, 0.1f);
                sound = new AUD_LinearResampleFactory(sound, specs);
 
-               if(square)
+               if (square)
                        sound = new AUD_SquareFactory(sound, sthreshold);
 
-               if(accumulate)
+               if (accumulate)
                        sound = new AUD_AccumulatorFactory(sound, additive);
-               else if(additive)
+               else if (additive)
                        sound = new AUD_SumFactory(sound);
 
                reader = sound->createReader();
 
-               if(reader.isNull())
+               if (reader.isNull())
                        return NULL;
 
                int len;
@@ -884,30 +841,28 @@ float* AUD_readSoundBuffer(const char* filename, float low, float high,
                return NULL;
        }
 
-       float* result = (float*)malloc(position * sizeof(float));
+       float * result = (float *)malloc(position * sizeof(float));
        memcpy(result, buffer.getBuffer(), position * sizeof(float));
        *length = position;
        return result;
 }
 
-static void pauseSound(AUD_Handlehandle)
+static void pauseSound(AUD_Handle *handle)
 {
        assert(handle);
        (*handle)->pause();
 }
 
-AUD_Handle* AUD_pauseAfter(AUD_Handle* handle, float seconds)
+AUD_Handle *AUD_pauseAfter(AUD_Handle *handle, float seconds)
 {
        AUD_Reference<AUD_IFactory> silence = new AUD_SilenceFactory;
        AUD_Reference<AUD_IFactory> limiter = new AUD_LimiterFactory(silence, 0, seconds);
 
        AUD_device->lock();
 
-       try
-       {
+       try {
                AUD_Handle handle2 = AUD_device->play(limiter);
-               if(!handle2.isNull())
-               {
+               if (!handle2.isNull()) {
                        handle2->setStopCallback((stopCallback)pauseSound, handle);
                        AUD_device->unlock();
                        return new AUD_Handle(handle2);
@@ -922,125 +877,127 @@ AUD_Handle* AUD_pauseAfter(AUD_Handle* handle, float seconds)
        return NULL;
 }
 
-AUD_SoundAUD_createSequencer(float fps, int muted)
+AUD_Sound *AUD_createSequencer(float fps, int muted)
 {
        // specs are changed at a later point!
        AUD_Specs specs;
        specs.channels = AUD_CHANNELS_STEREO;
        specs.rate = AUD_RATE_44100;
-       AUD_Soundsequencer = new AUD_Sound(AUD_Reference<AUD_SequencerFactory>(new AUD_SequencerFactory(specs, fps, muted)));
+       AUD_Sound *sequencer = new AUD_Sound(AUD_Reference<AUD_SequencerFactory>(new AUD_SequencerFactory(specs, fps, muted)));
        return sequencer;
 }
 
-void AUD_destroySequencer(AUD_Soundsequencer)
+void AUD_destroySequencer(AUD_Sound *sequencer)
 {
        delete sequencer;
 }
 
-void AUD_setSequencerMuted(AUD_Soundsequencer, int muted)
+void AUD_setSequencerMuted(AUD_Sound *sequencer, int muted)
 {
-       dynamic_cast<AUD_SequencerFactory*>(sequencer->get())->mute(muted);
+       dynamic_cast<AUD_SequencerFactory *>(sequencer->get())->mute(muted);
 }
 
-void AUD_setSequencerFPS(AUD_Soundsequencer, float fps)
+void AUD_setSequencerFPS(AUD_Sound *sequencer, float fps)
 {
-       dynamic_cast<AUD_SequencerFactory*>(sequencer->get())->setFPS(fps);
+       dynamic_cast<AUD_SequencerFactory *>(sequencer->get())->setFPS(fps);
 }
 
-AUD_SEntry* AUD_addSequence(AUD_Sound* sequencer, AUD_Sound* sound,
-                                                        float begin, float end, float skip)
+AUD_SEntry *AUD_addSequence(AUD_Sound *sequencer, AUD_Sound *sound,
+                            float begin, float end, float skip)
 {
-       if(!sound)
-               return new AUD_SEntry(((AUD_SequencerFactory*)sequencer->get())->add(AUD_Sound(), begin, end, skip));
-       return new AUD_SEntry(((AUD_SequencerFactory*)sequencer->get())->add(*sound, begin, end, skip));
+       if (!sound)
+               return new AUD_SEntry(((AUD_SequencerFactory *)sequencer->get())->add(AUD_Sound(), begin, end, skip));
+       return new AUD_SEntry(((AUD_SequencerFactory *)sequencer->get())->add(*sound, begin, end, skip));
 }
 
-void AUD_removeSequence(AUD_Sound* sequencer, AUD_SEntry* entry)
+void AUD_removeSequence(AUD_Sound *sequencer, AUD_SEntry *entry)
 {
-       dynamic_cast<AUD_SequencerFactory*>(sequencer->get())->remove(*entry);
+       dynamic_cast<AUD_SequencerFactory *>(sequencer->get())->remove(*entry);
        delete entry;
 }
 
-void AUD_moveSequence(AUD_SEntryentry, float begin, float end, float skip)
+void AUD_moveSequence(AUD_SEntry *entry, float begin, float end, float skip)
 {
        (*entry)->move(begin, end, skip);
 }
 
-void AUD_muteSequence(AUD_SEntryentry, char mute)
+void AUD_muteSequence(AUD_SEntry *entry, char mute)
 {
        (*entry)->mute(mute);
 }
 
-void AUD_setRelativeSequence(AUD_SEntryentry, char relative)
+void AUD_setRelativeSequence(AUD_SEntry *entry, char relative)
 {
        (*entry)->setRelative(relative);
 }
 
-void AUD_updateSequenceSound(AUD_SEntry* entry, AUD_Sound* sound)
+void AUD_updateSequenceSound(AUD_SEntry *entry, AUD_Sound *sound)
 {
-       if(sound)
+       if (sound)
                (*entry)->setSound(*sound);
        else
                (*entry)->setSound(AUD_Sound());
 }
 
-void AUD_setSequenceAnimData(AUD_SEntry* entry, AUD_AnimateablePropertyType type, int frame, float* data, char animated)
+void AUD_setSequenceAnimData(AUD_SEntry *entry, AUD_AnimateablePropertyType type, int frame, float *data, char animated)
 {
-       AUD_AnimateableProperty* prop = (*entry)->getAnimProperty(type);
-       if(animated)
-       {
-               if(frame >= 0)
+       AUD_AnimateableProperty *prop = (*entry)->getAnimProperty(type);
+       if (animated) {
+               if (frame >= 0)
                        prop->write(data, frame, 1);
        }
-       else
+       else {
                prop->write(data);
+       }
 }
 
-void AUD_setSequencerAnimData(AUD_Sound* sequencer, AUD_AnimateablePropertyType type, int frame, float* data, char animated)
+void AUD_setSequencerAnimData(AUD_Sound *sequencer, AUD_AnimateablePropertyType type, int frame, float *data, char animated)
 {
-       AUD_AnimateableProperty* prop = dynamic_cast<AUD_SequencerFactory*>(sequencer->get())->getAnimProperty(type);
-       if(animated)
-       {
-               if(frame >= 0)
+       AUD_AnimateableProperty *prop = dynamic_cast<AUD_SequencerFactory *>(sequencer->get())->getAnimProperty(type);
+       if (animated) {
+               if (frame >= 0) {
                        prop->write(data, frame, 1);
+               }
        }
-       else
+       else {
                prop->write(data);
+       }
 }
 
-void AUD_updateSequenceData(AUD_SEntryentry, float volume_max, float volume_min,
-                                                       float distance_max, float distance_reference, float attenuation,
-                                                       float cone_angle_outer, float cone_angle_inner, float cone_volume_outer)
+void AUD_updateSequenceData(AUD_SEntry *entry, float volume_max, float volume_min,
+                            float distance_max, float distance_reference, float attenuation,
+                            float cone_angle_outer, float cone_angle_inner, float cone_volume_outer)
 {
        (*entry)->updateAll(volume_max, volume_min, distance_max, distance_reference, attenuation,
-                                               cone_angle_outer, cone_angle_inner, cone_volume_outer);
+                           cone_angle_outer, cone_angle_inner, cone_volume_outer);
 }
 
-void AUD_updateSequencerData(AUD_Soundsequencer, float speed_of_sound,
-                                                        float factor, AUD_DistanceModel model)
+void AUD_updateSequencerData(AUD_Sound *sequencer, float speed_of_sound,
+                             float factor, AUD_DistanceModel model)
 {
-       AUD_SequencerFactory* f = dynamic_cast<AUD_SequencerFactory*>(sequencer->get());
+       AUD_SequencerFactory *f = dynamic_cast<AUD_SequencerFactory *>(sequencer->get());
        f->setSpeedOfSound(speed_of_sound);
        f->setDopplerFactor(factor);
        f->setDistanceModel(model);
 }
 
-void AUD_setSequencerDeviceSpecs(AUD_Soundsequencer)
+void AUD_setSequencerDeviceSpecs(AUD_Sound *sequencer)
 {
-       dynamic_cast<AUD_SequencerFactory*>(sequencer->get())->setSpecs(AUD_device->getSpecs().specs);
+       dynamic_cast<AUD_SequencerFactory *>(sequencer->get())->setSpecs(AUD_device->getSpecs().specs);
 }
 
-void AUD_setSequencerSpecs(AUD_Soundsequencer, AUD_Specs specs)
+void AUD_setSequencerSpecs(AUD_Sound *sequencer, AUD_Specs specs)
 {
-       dynamic_cast<AUD_SequencerFactory*>(sequencer->get())->setSpecs(specs);
+       dynamic_cast<AUD_SequencerFactory *>(sequencer->get())->setSpecs(specs);
 }
 
-void AUD_seekSequencer(AUD_Handlehandle, float time)
+void AUD_seekSequencer(AUD_Handle *handle, float time)
 {
 #ifdef WITH_JACK
-       AUD_JackDevice* device = dynamic_cast<AUD_JackDevice*>(AUD_device.get());
-       if(device)
+       AUD_JackDevice *device = dynamic_cast<AUD_JackDevice *>(AUD_device.get());
+       if (device) {
                device->seekPlayback(time);
+       }
        else
 #endif
        {
@@ -1049,12 +1006,13 @@ void AUD_seekSequencer(AUD_Handle* handle, float time)
        }
 }
 
-float AUD_getSequencerPosition(AUD_Handlehandle)
+float AUD_getSequencerPosition(AUD_Handle *handle)
 {
 #ifdef WITH_JACK
-       AUD_JackDevice* device = dynamic_cast<AUD_JackDevice*>(AUD_device.get());
-       if(device)
+       AUD_JackDevice *device = dynamic_cast<AUD_JackDevice *>(AUD_device.get());
+       if (device) {
                return device->getPlaybackPosition();
+       }
        else
 #endif
        {
@@ -1066,44 +1024,48 @@ float AUD_getSequencerPosition(AUD_Handle* handle)
 void AUD_startPlayback()
 {
 #ifdef WITH_JACK
-       AUD_JackDevice* device = dynamic_cast<AUD_JackDevice*>(AUD_device.get());
-       if(device)
+       AUD_JackDevice *device = dynamic_cast<AUD_JackDevice *>(AUD_device.get());
+       if (device) {
                device->startPlayback();
+       }
 #endif
 }
 
 void AUD_stopPlayback()
 {
 #ifdef WITH_JACK
-       AUD_JackDevice* device = dynamic_cast<AUD_JackDevice*>(AUD_device.get());
-       if(device)
+       AUD_JackDevice *device = dynamic_cast<AUD_JackDevice *>(AUD_device.get());
+       if (device) {
                device->stopPlayback();
+       }
 #endif
 }
 
 #ifdef WITH_JACK
-void AUD_setSyncCallback(AUD_syncFunction function, voiddata)
+void AUD_setSyncCallback(AUD_syncFunction function, void *data)
 {
-       AUD_JackDevice* device = dynamic_cast<AUD_JackDevice*>(AUD_device.get());
-       if(device)
+       AUD_JackDevice *device = dynamic_cast<AUD_JackDevice *>(AUD_device.get());
+       if (device) {
                device->setSyncCallback(function, data);
+       }
 }
 #endif
 
 int AUD_doesPlayback()
 {
 #ifdef WITH_JACK
-       AUD_JackDevice* device = dynamic_cast<AUD_JackDevice*>(AUD_device.get());
-       if(device)
+       AUD_JackDevice *device = dynamic_cast<AUD_JackDevice *>(AUD_device.get());
+       if (device) {
                return device->doesPlayback();
+       }
 #endif
        return -1;
 }
 
-int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length, int samples_per_second)
+int AUD_readSound(AUD_Sound *sound, sample_t *buffer, int length, int samples_per_second)
 {
        AUD_DeviceSpecs specs;
-       sample_tbuf;
+       sample_t *buf;
        AUD_Buffer aBuffer;
 
        specs.rate = AUD_RATE_INVALID;
@@ -1120,8 +1082,7 @@ int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length, int samples_pe
 
        overallmax = 0;
 
-       for(int i = 0; i < length; i++)
-       {
+       for (int i = 0; i < length; i++) {
                len = floor(samplejump * (i+1)) - floor(samplejump * i);
 
                aBuffer.assureSize(len * AUD_SAMPLE_SIZE(specs));
@@ -1131,11 +1092,10 @@ int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length, int samples_pe
 
                max = min = *buf;
                power = *buf * *buf;
-               for(int j = 1; j < len; j++)
-               {
-                       if(buf[j] < min)
+               for (int j = 1; j < len; j++) {
+                       if (buf[j] < min)
                                min = buf[j];
-                       if(buf[j] > max)
+                       if (buf[j] > max)
                                max = buf[j];
                        power += buf[j] * buf[j];
                }
@@ -1144,22 +1104,19 @@ int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length, int samples_pe
                buffer[i * 3 + 1] = max;
                buffer[i * 3 + 2] = sqrt(power) / len;
 
-               if(overallmax < max)
+               if (overallmax < max)
                        overallmax = max;
-               if(overallmax < -min)
+               if (overallmax < -min)
                        overallmax = -min;
 
-               if(eos)
-               {
+               if (eos) {
                        length = i;
                        break;
                }
        }
 
-       if(overallmax > 1.0f)
-       {
-               for(int i = 0; i < length * 3; i++)
-               {
+       if (overallmax > 1.0f) {
+               for (int i = 0; i < length * 3; i++) {
                        buffer[i] /= overallmax;
                }
        }
@@ -1167,48 +1124,46 @@ int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length, int samples_pe
        return length;
 }
 
-AUD_Sound* AUD_copy(AUD_Sound* sound)
+AUD_Sound *AUD_copy(AUD_Sound *sound)
 {
        return new AUD_Reference<AUD_IFactory>(*sound);
 }
 
-void AUD_freeHandle(AUD_Handlehandle)
+void AUD_freeHandle(AUD_Handle *handle)
 {
        delete handle;
 }
 
-voidAUD_createSet()
+void *AUD_createSet()
 {
-       return new std::set<void*>();
+       return new std::set<void *>();
 }
 
-void AUD_destroySet(voidset)
+void AUD_destroySet(void *set)
 {
-       delete reinterpret_cast<std::set<void*>*>(set);
+       delete reinterpret_cast<std::set<void *>*>(set);
 }
 
-char AUD_removeSet(void* set, void* entry)
+char AUD_removeSet(void *set, void *entry)
 {
-       if(set)
-               return reinterpret_cast<std::set<void*>*>(set)->erase(entry);
+       if (set)
+               return reinterpret_cast<std::set<void *>*>(set)->erase(entry);
        return 0;
 }
 
-void AUD_addSet(void* set, void* entry)
+void AUD_addSet(void *set, void *entry)
 {
-       if(entry)
-               reinterpret_cast<std::set<void*>*>(set)->insert(entry);
+       if (entry)
+               reinterpret_cast<std::set<void *>*>(set)->insert(entry);
 }
 
-void* AUD_getSet(void* set)
+void *AUD_getSet(void *set)
 {
-       if(set)
-       {
-               std::set<void*>* rset = reinterpret_cast<std::set<void*>*>(set);
-               if(!rset->empty())
-               {
-                       std::set<void*>::iterator it = rset->begin();
-                       void* result = *it;
+       if (set) {
+               std::set<void *>* rset = reinterpret_cast<std::set<void *>*>(set);
+               if (!rset->empty()) {
+                       std::set<void *>::iterator it = rset->begin();
+                       void *result = *it;
                        rset->erase(it);
                        return result;
                }
@@ -1217,11 +1172,10 @@ void* AUD_getSet(void* set)
        return NULL;
 }
 
-const char* AUD_mixdown(AUD_Sound* sound, unsigned int start, unsigned int length, unsigned int buffersize, const char* filename, AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate)
+const char *AUD_mixdown(AUD_Sound *sound, unsigned int start, unsigned int length, unsigned int buffersize, const char *filename, AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate)
 {
-       try
-       {
-               AUD_SequencerFactory* f = dynamic_cast<AUD_SequencerFactory*>(sound->get());
+       try {
+               AUD_SequencerFactory *f = dynamic_cast<AUD_SequencerFactory *>(sound->get());
 
                f->setSpecs(specs.specs);
                AUD_Reference<AUD_IReader> reader = f->createQualityReader();
@@ -1237,11 +1191,10 @@ const char* AUD_mixdown(AUD_Sound* sound, unsigned int start, unsigned int lengt
        }
 }
 
-const char* AUD_mixdown_per_channel(AUD_Sound* sound, unsigned int start, unsigned int length, unsigned int buffersize, const char* filename, AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate)
+const char *AUD_mixdown_per_channel(AUD_Sound *sound, unsigned int start, unsigned int length, unsigned int buffersize, const char *filename, AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate)
 {
-       try
-       {
-               AUD_SequencerFactory* f = dynamic_cast<AUD_SequencerFactory*>(sound->get());
+       try {
+               AUD_SequencerFactory *f = dynamic_cast<AUD_SequencerFactory *>(sound->get());
 
                f->setSpecs(specs.specs);
 
@@ -1250,19 +1203,22 @@ const char* AUD_mixdown_per_channel(AUD_Sound* sound, unsigned int start, unsign
                int channels = specs.channels;
                specs.channels = AUD_CHANNELS_MONO;
 
-               for(int i = 0; i < channels; i++)
-               {
+               for (int i = 0; i < channels; i++) {
                        std::stringstream stream;
                        std::string fn = filename;
                        size_t index = fn.find_last_of('.');
                        size_t index_slash = fn.find_last_of('/');
                        size_t index_backslash = fn.find_last_of('\\');
-                       if((index == std::string::npos) ||
-                                       ((index < index_slash) && (index_slash != std::string::npos)) ||
-                                       ((index < index_backslash) && (index_backslash != std::string::npos)))
+
+                       if ((index == std::string::npos) ||
+                           ((index < index_slash) && (index_slash != std::string::npos)) ||
+                           ((index < index_backslash) && (index_backslash != std::string::npos)))
+                       {
                                stream << filename << "_" << (i + 1);
-                       else
+                       }
+                       else {
                                stream << fn.substr(0, index) << "_" << (i + 1) << fn.substr(index);
+                       }
                        writers.push_back(AUD_FileWriter::createWriter(stream.str(), specs, format, codec, bitrate));
                }
 
@@ -1278,19 +1234,19 @@ const char* AUD_mixdown_per_channel(AUD_Sound* sound, unsigned int start, unsign
        }
 }
 
-AUD_Device* AUD_openMixdownDevice(AUD_DeviceSpecs specs, AUD_Sound* sequencer, float volume, float start)
+AUD_Device *AUD_openMixdownDevice(AUD_DeviceSpecs specs, AUD_Sound *sequencer, float volume, float start)
 {
-       try
-       {
-               AUD_ReadDevice* device = new AUD_ReadDevice(specs);
+       try {
+               AUD_ReadDevice *device = new AUD_ReadDevice(specs);
                device->setQuality(true);
                device->setVolume(volume);
 
-               dynamic_cast<AUD_SequencerFactory*>(sequencer->get())->setSpecs(specs.specs);
+               dynamic_cast<AUD_SequencerFactory *>(sequencer->get())->setSpecs(specs.specs);
 
                AUD_Handle handle = device->play(*sequencer);
-               if(!handle.isNull())
+               if (!handle.isNull()) {
                        handle->seek(start);
+               }
 
                return new AUD_Device(device);
        }
@@ -1305,7 +1261,7 @@ AUD_Reference<AUD_IDevice> AUD_getDevice()
        return AUD_device;
 }
 
-AUD_I3DDeviceAUD_get3DDevice()
+AUD_I3DDevice *AUD_get3DDevice()
 {
        return AUD_3ddevice;
 }
index 6af0c648d0e311ce03907e5e06fc55693cdd02bf..75e3456de9a21d0b62a1b633c5ebf4c4b3983f4c 100644 (file)
@@ -56,8 +56,8 @@ typedef struct
        typedef void AUD_Handle;
        typedef void AUD_Device;
        typedef void AUD_SEntry;
-       typedef float (*AUD_volumeFunction)(void*, void*, float);
-       typedef void (*AUD_syncFunction)(void*, int, float);
+       typedef float (*AUD_volumeFunction)(void *, void *, float);
+       typedef void (*AUD_syncFunction)(void *, int, float);
 #endif
 
 /**
@@ -94,14 +94,14 @@ extern void AUD_unlock(void);
  * \param sound The sound to get the info about.
  * \return The AUD_SoundInfo structure with filled in data.
  */
-extern AUD_SoundInfo AUD_getInfo(AUD_Soundsound);
+extern AUD_SoundInfo AUD_getInfo(AUD_Sound *sound);
 
 /**
  * Loads a sound file.
  * \param filename The filename of the sound file.
  * \return A handle of the sound file.
  */
-extern AUD_Sound* AUD_load(const char* filename);
+extern AUD_Sound *AUD_load(const char *filename);
 
 /**
  * Loads a sound file.
@@ -109,21 +109,21 @@ extern AUD_Sound* AUD_load(const char* filename);
  * \param size The size of the buffer.
  * \return A handle of the sound file.
  */
-extern AUD_Sound* AUD_loadBuffer(unsigned char* buffer, int size);
+extern AUD_Sound *AUD_loadBuffer(unsigned char *buffer, int size);
 
 /**
  * Buffers a sound.
  * \param sound The sound to buffer.
  * \return A handle of the sound buffer.
  */
-extern AUD_Sound* AUD_bufferSound(AUD_Sound* sound);
+extern AUD_Sound *AUD_bufferSound(AUD_Sound *sound);
 
 /**
  * Rechannels the sound to be mono.
  * \param sound The sound to rechannel.
  * \return The mono sound.
  */
-extern AUD_Sound* AUD_monoSound(AUD_Sound* sound);
+extern AUD_Sound *AUD_monoSound(AUD_Sound *sound);
 
 /**
  * Delays a sound.
@@ -131,7 +131,7 @@ extern AUD_Sound* AUD_monoSound(AUD_Sound* sound);
  * \param delay The delay in seconds.
  * \return A handle of the delayed sound.
  */
-extern AUD_Sound* AUD_delaySound(AUD_Sound* sound, float delay);
+extern AUD_Sound *AUD_delaySound(AUD_Sound *sound, float delay);
 
 /**
  * Limits a sound.
@@ -140,21 +140,21 @@ extern AUD_Sound* AUD_delaySound(AUD_Sound* sound, float delay);
  * \param end The stop time in seconds.
  * \return A handle of the limited sound.
  */
-extern AUD_Sound* AUD_limitSound(AUD_Sound* sound, float start, float end);
+extern AUD_Sound *AUD_limitSound(AUD_Sound *sound, float start, float end);
 
 /**
  * Ping pongs a sound.
  * \param sound The sound to ping pong.
  * \return A handle of the ping pong sound.
  */
-extern AUD_Sound* AUD_pingpongSound(AUD_Sound* sound);
+extern AUD_Sound *AUD_pingpongSound(AUD_Sound *sound);
 
 /**
  * Loops a sound.
  * \param sound The sound to loop.
  * \return A handle of the looped sound.
  */
-extern AUD_Sound* AUD_loopSound(AUD_Sound* sound);
+extern AUD_Sound *AUD_loopSound(AUD_Sound *sound);
 
 /**
  * Sets a remaining loop count of a looping sound that currently plays.
@@ -162,20 +162,20 @@ extern AUD_Sound* AUD_loopSound(AUD_Sound* sound);
  * \param loops The count of remaining loops, -1 for infinity.
  * \return Whether the handle is valid.
  */
-extern int AUD_setLoop(AUD_Handlehandle, int loops);
+extern int AUD_setLoop(AUD_Handle *handle, int loops);
 
 /**
  * Rectifies a sound.
  * \param sound The sound to rectify.
  * \return A handle of the rectified sound.
  */
-extern AUD_Sound* AUD_rectifySound(AUD_Sound* sound);
+extern AUD_Sound *AUD_rectifySound(AUD_Sound *sound);
 
 /**
  * Unloads a sound of any type.
  * \param sound The handle of the sound.
  */
-extern void AUD_unload(AUD_Soundsound);
+extern void AUD_unload(AUD_Sound *sound);
 
 /**
  * Plays back a sound file.
@@ -184,28 +184,28 @@ extern void AUD_unload(AUD_Sound* sound);
  *             paused when its end has been reached.
  * \return A handle to the played back sound.
  */
-extern AUD_Handle* AUD_play(AUD_Sound* sound, int keep);
+extern AUD_Handle *AUD_play(AUD_Sound *sound, int keep);
 
 /**
  * Pauses a played back sound.
  * \param handle The handle to the sound.
  * \return Whether the handle has been playing or not.
  */
-extern int AUD_pause(AUD_Handlehandle);
+extern int AUD_pause(AUD_Handle *handle);
 
 /**
  * Resumes a paused sound.
  * \param handle The handle to the sound.
  * \return Whether the handle has been paused or not.
  */
-extern int AUD_resume(AUD_Handlehandle);
+extern int AUD_resume(AUD_Handle *handle);
 
 /**
  * Stops a playing or paused sound.
  * \param handle The handle to the sound.
  * \return Whether the handle has been valid or not.
  */
-extern int AUD_stop(AUD_Handlehandle);
+extern int AUD_stop(AUD_Handle *handle);
 
 /**
  * Sets the end behaviour of a playing or paused sound.
@@ -214,7 +214,7 @@ extern int AUD_stop(AUD_Handle* handle);
  *             paused when its end has been reached.
  * \return Whether the handle has been valid or not.
  */
-extern int AUD_setKeep(AUD_Handlehandle, int keep);
+extern int AUD_setKeep(AUD_Handle *handle, int keep);
 
 /**
  * Seeks a playing or paused sound.
@@ -222,7 +222,7 @@ extern int AUD_setKeep(AUD_Handle* handle, int keep);
  * \param seekTo From where the sound file should be played back in seconds.
  * \return Whether the handle has been valid or not.
  */
-extern int AUD_seek(AUD_Handlehandle, float seekTo);
+extern int AUD_seek(AUD_Handle *handle, float seekTo);
 
 /**
  * Retrieves the playback position of a handle.
@@ -230,32 +230,32 @@ extern int AUD_seek(AUD_Handle* handle, float seekTo);
  * \return The current playback position in seconds or 0.0 if the handle is
  *         invalid.
  */
-extern float AUD_getPosition(AUD_Handlehandle);
+extern float AUD_getPosition(AUD_Handle *handle);
 
 /**
  * Returns the status of a playing, paused or stopped sound.
  * \param handle The handle to the sound.
  * \return The status of the sound behind the handle.
  */
-extern AUD_Status AUD_getStatus(AUD_Handlehandle);
+extern AUD_Status AUD_getStatus(AUD_Handle *handle);
 
 /**
  * Sets the listener location.
  * \param location The new location.
  */
-extern int AUD_setListenerLocation(const float* location);
+extern int AUD_setListenerLocation(const float location[3]);
 
 /**
  * Sets the listener velocity.
  * \param velocity The new velocity.
  */
-extern int AUD_setListenerVelocity(const float* velocity);
+extern int AUD_setListenerVelocity(const float velocity[3]);
 
 /**
  * Sets the listener orientation.
  * \param orientation The new orientation as quaternion.
  */
-extern int AUD_setListenerOrientation(const float* orientation);
+extern int AUD_setListenerOrientation(const float orientation[4]);
 
 /**
  * Sets the speed of sound.
@@ -284,7 +284,7 @@ extern int AUD_setDistanceModel(AUD_DistanceModel model);
  * \param location The new location.
  * \return Whether the action succeeded.
  */
-extern int AUD_setSourceLocation(AUD_Handle* handle, const float* location);
+extern int AUD_setSourceLocation(AUD_Handle *handle, const float location[3]);
 
 /**
  * Sets the velocity of a source.
@@ -292,7 +292,7 @@ extern int AUD_setSourceLocation(AUD_Handle* handle, const float* location);
  * \param velocity The new velocity.
  * \return Whether the action succeeded.
  */
-extern int AUD_setSourceVelocity(AUD_Handle* handle, const float* velocity);
+extern int AUD_setSourceVelocity(AUD_Handle *handle, const float velocity[3]);
 
 /**
  * Sets the orientation of a source.
@@ -300,7 +300,7 @@ extern int AUD_setSourceVelocity(AUD_Handle* handle, const float* velocity);
  * \param orientation The new orientation as quaternion.
  * \return Whether the action succeeded.
  */
-extern int AUD_setSourceOrientation(AUD_Handle* handle, const float* orientation);
+extern int AUD_setSourceOrientation(AUD_Handle *handle, const float orientation[4]);
 
 /**
  * Sets whether the source location, velocity and orientation are relative
@@ -309,7 +309,7 @@ extern int AUD_setSourceOrientation(AUD_Handle* handle, const float* orientation
  * \param relative Whether the source is relative.
  * \return Whether the action succeeded.
  */
-extern int AUD_setRelative(AUD_Handlehandle, int relative);
+extern int AUD_setRelative(AUD_Handle *handle, int relative);
 
 /**
  * Sets the maximum volume of a source.
@@ -317,7 +317,7 @@ extern int AUD_setRelative(AUD_Handle* handle, int relative);
  * \param volume The new maximum volume.
  * \return Whether the action succeeded.
  */
-extern int AUD_setVolumeMaximum(AUD_Handlehandle, float volume);
+extern int AUD_setVolumeMaximum(AUD_Handle *handle, float volume);
 
 /**
  * Sets the minimum volume of a source.
@@ -325,7 +325,7 @@ extern int AUD_setVolumeMaximum(AUD_Handle* handle, float volume);
  * \param volume The new minimum volume.
  * \return Whether the action succeeded.
  */
-extern int AUD_setVolumeMinimum(AUD_Handlehandle, float volume);
+extern int AUD_setVolumeMinimum(AUD_Handle *handle, float volume);
 
 /**
  * Sets the maximum distance of a source.
@@ -335,7 +335,7 @@ extern int AUD_setVolumeMinimum(AUD_Handle* handle, float volume);
  * \param distance The new maximum distance.
  * \return Whether the action succeeded.
  */
-extern int AUD_setDistanceMaximum(AUD_Handlehandle, float distance);
+extern int AUD_setDistanceMaximum(AUD_Handle *handle, float distance);
 
 /**
  * Sets the reference distance of a source.
@@ -343,7 +343,7 @@ extern int AUD_setDistanceMaximum(AUD_Handle* handle, float distance);
  * \param distance The new reference distance.
  * \return Whether the action succeeded.
  */
-extern int AUD_setDistanceReference(AUD_Handlehandle, float distance);
+extern int AUD_setDistanceReference(AUD_Handle *handle, float distance);
 
 /**
  * Sets the attenuation of a source.
@@ -352,7 +352,7 @@ extern int AUD_setDistanceReference(AUD_Handle* handle, float distance);
  * \param factor The new attenuation.
  * \return Whether the action succeeded.
  */
-extern int AUD_setAttenuation(AUD_Handlehandle, float factor);
+extern int AUD_setAttenuation(AUD_Handle *handle, float factor);
 
 /**
  * Sets the outer angle of the cone of a source.
@@ -360,7 +360,7 @@ extern int AUD_setAttenuation(AUD_Handle* handle, float factor);
  * \param angle The new outer angle of the cone.
  * \return Whether the action succeeded.
  */
-extern int AUD_setConeAngleOuter(AUD_Handlehandle, float angle);
+extern int AUD_setConeAngleOuter(AUD_Handle *handle, float angle);
 
 /**
  * Sets the inner angle of the cone of a source.
@@ -368,7 +368,7 @@ extern int AUD_setConeAngleOuter(AUD_Handle* handle, float angle);
  * \param angle The new inner angle of the cone.
  * \return Whether the action succeeded.
  */
-extern int AUD_setConeAngleInner(AUD_Handlehandle, float angle);
+extern int AUD_setConeAngleInner(AUD_Handle *handle, float angle);
 
 /**
  * Sets the outer volume of the cone of a source.
@@ -378,7 +378,7 @@ extern int AUD_setConeAngleInner(AUD_Handle* handle, float angle);
  * \param volume The new outer volume of the cone.
  * \return Whether the action succeeded.
  */
-extern int AUD_setConeVolumeOuter(AUD_Handlehandle, float volume);
+extern int AUD_setConeVolumeOuter(AUD_Handle *handle, float volume);
 
 /**
  * Sets the volume of a played back sound.
@@ -386,7 +386,7 @@ extern int AUD_setConeVolumeOuter(AUD_Handle* handle, float volume);
  * \param volume The new volume, must be between 0.0 and 1.0.
  * \return Whether the action succeeded.
  */
-extern int AUD_setSoundVolume(AUD_Handlehandle, float volume);
+extern int AUD_setSoundVolume(AUD_Handle *handle, float volume);
 
 /**
  * Sets the pitch of a played back sound.
@@ -394,14 +394,14 @@ extern int AUD_setSoundVolume(AUD_Handle* handle, float volume);
  * \param pitch The new pitch.
  * \return Whether the action succeeded.
  */
-extern int AUD_setSoundPitch(AUD_Handlehandle, float pitch);
+extern int AUD_setSoundPitch(AUD_Handle *handle, float pitch);
 
 /**
  * Opens a read device, with which audio data can be read.
  * \param specs The specification of the audio data.
  * \return A device handle.
  */
-extern AUD_DeviceAUD_openReadDevice(AUD_DeviceSpecs specs);
+extern AUD_Device *AUD_openReadDevice(AUD_DeviceSpecs specs);
 
 /**
  * Sets the main volume of a device.
@@ -409,7 +409,7 @@ extern AUD_Device* AUD_openReadDevice(AUD_DeviceSpecs specs);
  * \param volume The new volume, must be between 0.0 and 1.0.
  * \return Whether the action succeeded.
  */
-extern int AUD_setDeviceVolume(AUD_Devicedevice, float volume);
+extern int AUD_setDeviceVolume(AUD_Device *device, float volume);
 
 /**
  * Plays back a sound file through a read device.
@@ -418,7 +418,7 @@ extern int AUD_setDeviceVolume(AUD_Device* device, float volume);
  * \param seek The position where the sound should be seeked to.
  * \return A handle to the played back sound.
  */
-extern AUD_Handle* AUD_playDevice(AUD_Device* device, AUD_Sound* sound, float seek);
+extern AUD_Handle *AUD_playDevice(AUD_Device *device, AUD_Sound *sound, float seek);
 
 /**
  * Reads the next samples into the supplied buffer.
@@ -429,23 +429,23 @@ extern AUD_Handle* AUD_playDevice(AUD_Device* device, AUD_Sound* sound, float se
  *         played back currently, in that case the buffer is filled with
  *         silence.
  */
-extern int AUD_readDevice(AUD_Device* device, data_t* buffer, int length);
+extern int AUD_readDevice(AUD_Device *device, data_t *buffer, int length);
 
 /**
  * Closes a read device.
  * \param device The read device.
  */
-extern void AUD_closeReadDevice(AUD_Devicedevice);
+extern void AUD_closeReadDevice(AUD_Device *device);
 
 /**
  * Reads a sound file into a newly created float buffer.
  * The sound is therefore bandpassed, rectified and resampled.
  */
-extern float* AUD_readSoundBuffer(const char* filename, float low, float high,
+extern float *AUD_readSoundBuffer(const char *filename, float low, float high,
                                   float attack, float release, float threshold,
                                   int accumulate, int additive, int square,
                                   float sthreshold, double samplerate,
-                                  intlength);
+                                  int *length);
 
 /**
  * Pauses a playing sound after a specific amount of time.
@@ -453,7 +453,7 @@ extern float* AUD_readSoundBuffer(const char* filename, float low, float high,
  * \param seconds The time in seconds.
  * \return The silence handle.
  */
-extern AUD_Handle* AUD_pauseAfter(AUD_Handle* handle, float seconds);
+extern AUD_Handle *AUD_pauseAfter(AUD_Handle *handle, float seconds);
 
 /**
  * Creates a new sequenced sound scene.
@@ -461,27 +461,27 @@ extern AUD_Handle* AUD_pauseAfter(AUD_Handle* handle, float seconds);
  * \param muted Whether the scene is muted.
  * \return The new sound scene.
  */
-extern AUD_SoundAUD_createSequencer(float fps, int muted);
+extern AUD_Sound *AUD_createSequencer(float fps, int muted);
 
 /**
  * Deletes a sound scene.
  * \param sequencer The sound scene.
  */
-extern void AUD_destroySequencer(AUD_Soundsequencer);
+extern void AUD_destroySequencer(AUD_Sound *sequencer);
 
 /**
  * Sets the muting state of the scene.
  * \param sequencer The sound scene.
  * \param muted Whether the scene is muted.
  */
-extern void AUD_setSequencerMuted(AUD_Soundsequencer, int muted);
+extern void AUD_setSequencerMuted(AUD_Sound *sequencer, int muted);
 
 /**
  * Sets the scene's FPS.
  * \param sequencer The sound scene.
  * \param fps The new FPS.
  */
-extern void AUD_setSequencerFPS(AUD_Soundsequencer, float fps);
+extern void AUD_setSequencerFPS(AUD_Sound *sequencer, float fps);
 
 /**
  * Adds a new entry to the scene.
@@ -492,7 +492,7 @@ extern void AUD_setSequencerFPS(AUD_Sound* sequencer, float fps);
  * \param skip How much seconds should be skipped at the beginning.
  * \return The entry added.
  */
-extern AUD_SEntry* AUD_addSequence(AUD_Sound* sequencer, AUD_Sound* sound,
+extern AUD_SEntry *AUD_addSequence(AUD_Sound *sequencer, AUD_Sound *sound,
                                    float begin, float end, float skip);
 
 /**
@@ -500,7 +500,7 @@ extern AUD_SEntry* AUD_addSequence(AUD_Sound* sequencer, AUD_Sound* sound,
  * \param sequencer The sound scene.
  * \param entry The entry to remove.
  */
-extern void AUD_removeSequence(AUD_Sound* sequencer, AUD_SEntry* entry);
+extern void AUD_removeSequence(AUD_Sound *sequencer, AUD_SEntry *entry);
 
 /**
  * Moves the entry.
@@ -509,14 +509,14 @@ extern void AUD_removeSequence(AUD_Sound* sequencer, AUD_SEntry* entry);
  * \param end The new end time or a negative value if unknown.
  * \param skip How many seconds to skip at the beginning.
  */
-extern void AUD_moveSequence(AUD_SEntryentry, float begin, float end, float skip);
+extern void AUD_moveSequence(AUD_SEntry *entry, float begin, float end, float skip);
 
 /**
  * Sets the muting state of the entry.
  * \param entry The sequenced entry.
  * \param mute Whether the entry should be muted or not.
  */
-extern void AUD_muteSequence(AUD_SEntryentry, char mute);
+extern void AUD_muteSequence(AUD_SEntry *entry, char mute);
 
 /**
  * Sets whether the entrie's location, velocity and orientation are relative
@@ -525,14 +525,14 @@ extern void AUD_muteSequence(AUD_SEntry* entry, char mute);
  * \param relative Whether the source is relative.
  * \return Whether the action succeeded.
  */
-extern void AUD_setRelativeSequence(AUD_SEntryentry, char relative);
+extern void AUD_setRelativeSequence(AUD_SEntry *entry, char relative);
 
 /**
  * Sets the sound of the entry.
  * \param entry The sequenced entry.
  * \param sound The new sound.
  */
-extern void AUD_updateSequenceSound(AUD_SEntry* entry, AUD_Sound* sound);
+extern void AUD_updateSequenceSound(AUD_SEntry *entry, AUD_Sound *sound);
 
 /**
  * Writes animation data to a sequenced entry.
@@ -542,7 +542,7 @@ extern void AUD_updateSequenceSound(AUD_SEntry* entry, AUD_Sound* sound);
  * \param data The data to write.
  * \param animated Whether the attribute is animated.
  */
-extern void AUD_setSequenceAnimData(AUD_SEntry* entry, AUD_AnimateablePropertyType type, int frame, float* data, char animated);
+extern void AUD_setSequenceAnimData(AUD_SEntry *entry, AUD_AnimateablePropertyType type, int frame, float *data, char animated);
 
 /**
  * Writes animation data to a sequenced entry.
@@ -552,7 +552,7 @@ extern void AUD_setSequenceAnimData(AUD_SEntry* entry, AUD_AnimateablePropertyTy
  * \param data The data to write.
  * \param animated Whether the attribute is animated.
  */
-extern void AUD_setSequencerAnimData(AUD_Sound* sequencer, AUD_AnimateablePropertyType type, int frame, float* data, char animated);
+extern void AUD_setSequencerAnimData(AUD_Sound *sequencer, AUD_AnimateablePropertyType type, int frame, float *data, char animated);
 
 /**
  * Updates all non-animated parameters of the entry.
@@ -566,7 +566,7 @@ extern void AUD_setSequencerAnimData(AUD_Sound* sequencer, AUD_AnimateableProper
  * \param cone_angle_inner The inner cone opening angle.
  * \param cone_volume_outer The volume outside the outer cone.
  */
-extern void AUD_updateSequenceData(AUD_SEntryentry, float volume_max, float volume_min,
+extern void AUD_updateSequenceData(AUD_SEntry *entry, float volume_max, float volume_min,
                                    float distance_max, float distance_reference, float attenuation,
                                    float cone_angle_outer, float cone_angle_inner, float cone_volume_outer);
 
@@ -577,7 +577,7 @@ extern void AUD_updateSequenceData(AUD_SEntry* entry, float volume_max, float vo
  * \param factor The doppler factor to control the effect's strength.
  * \param model The distance model for distance calculation.
  */
-extern void AUD_updateSequencerData(AUD_Soundsequencer, float speed_of_sound,
+extern void AUD_updateSequencerData(AUD_Sound *sequencer, float speed_of_sound,
                                     float factor, AUD_DistanceModel model);
 
 /**
@@ -585,28 +585,28 @@ extern void AUD_updateSequencerData(AUD_Sound* sequencer, float speed_of_sound,
  * current playback device.
  * \param sequencer The sound scene.
  */
-extern void AUD_setSequencerDeviceSpecs(AUD_Soundsequencer);
+extern void AUD_setSequencerDeviceSpecs(AUD_Sound *sequencer);
 
 /**
  * Sets the audio output specification of the sound scene.
  * \param sequencer The sound scene.
  * \param specs The new specification.
  */
-extern void AUD_setSequencerSpecs(AUD_Soundsequencer, AUD_Specs specs);
+extern void AUD_setSequencerSpecs(AUD_Sound *sequencer, AUD_Specs specs);
 
 /**
  * Seeks sequenced sound scene playback.
  * \param handle Playback handle.
  * \param time Time in seconds to seek to.
  */
-extern void AUD_seekSequencer(AUD_Handlehandle, float time);
+extern void AUD_seekSequencer(AUD_Handle *handle, float time);
 
 /**
  * Returns the current sound scene playback time.
  * \param handle Playback handle.
  * \return The playback time in seconds.
  */
-extern float AUD_getSequencerPosition(AUD_Handlehandle);
+extern float AUD_getSequencerPosition(AUD_Handle *handle);
 
 /**
  * Starts the playback of jack transport if possible.
@@ -624,7 +624,7 @@ extern void AUD_stopPlayback(void);
  * \param function The callback function.
  * \param data The data parameter for the callback.
  */
-extern void AUD_setSyncCallback(AUD_syncFunction function, voiddata);
+extern void AUD_setSyncCallback(AUD_syncFunction function, void *data);
 #endif
 
 /**
@@ -641,32 +641,32 @@ extern int AUD_doesPlayback(void);
  * \param samples_per_second How many samples to read per second of the sound.
  * \return How many samples really have been read. Always <= length.
  */
-extern int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length, int samples_per_second);
+extern int AUD_readSound(AUD_Sound *sound, sample_t *buffer, int length, int samples_per_second);
 
 /**
  * Copies a sound.
  * \param sound Sound to copy.
  * \return Copied sound.
  */
-extern AUD_Sound* AUD_copy(AUD_Sound* sound);
+extern AUD_Sound *AUD_copy(AUD_Sound *sound);
 
 /**
  * Frees a handle.
  * \param channel Handle to free.
  */
-extern void AUD_freeHandle(AUD_Handlechannel);
+extern void AUD_freeHandle(AUD_Handle *channel);
 
 /**
  * Creates a new set.
  * \return The new set.
  */
-extern voidAUD_createSet(void);
+extern void *AUD_createSet(void);
 
 /**
  * Deletes a set.
  * \param set The set to delete.
  */
-extern void AUD_destroySet(voidset);
+extern void AUD_destroySet(void *set);
 
 /**
  * Removes an entry from a set.
@@ -674,21 +674,21 @@ extern void AUD_destroySet(void* set);
  * \param entry The entry to remove.
  * \return Whether the entry was in the set or not.
  */
-extern char AUD_removeSet(void* set, void* entry);
+extern char AUD_removeSet(void *set, void *entry);
 
 /**
  * Adds a new entry to a set.
  * \param set The set work on.
  * \param entry The entry to add.
  */
-extern void AUD_addSet(void* set, void* entry);
+extern void AUD_addSet(void *set, void *entry);
 
 /**
  * Removes one entry from a set and returns it.
  * \param set The set work on.
  * \return The entry or NULL if the set is empty.
  */
-extern void* AUD_getSet(void* set);
+extern void *AUD_getSet(void *set);
 
 /**
  * Mixes a sound down into a file.
@@ -703,7 +703,10 @@ extern void* AUD_getSet(void* set);
  * \param bitrate The bitrate for encoding.
  * \return An error message or NULL in case of success.
  */
-extern const char* AUD_mixdown(AUD_Sound* sound, unsigned int start, unsigned int length, unsigned int buffersize, const char* filename, AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate);
+extern const char *AUD_mixdown(AUD_Sound *sound, unsigned int start, unsigned int length,
+                               unsigned int buffersize, const char *filename,
+                               AUD_DeviceSpecs specs, AUD_Container format,
+                               AUD_Codec codec, unsigned int bitrate);
 
 /**
  * Mixes a sound down into multiple files.
@@ -718,7 +721,10 @@ extern const char* AUD_mixdown(AUD_Sound* sound, unsigned int start, unsigned in
  * \param bitrate The bitrate for encoding.
  * \return An error message or NULL in case of success.
  */
-extern const char* AUD_mixdown_per_channel(AUD_Sound* sound, unsigned int start, unsigned int length, unsigned int buffersize, const char* filename, AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate);
+extern const char *AUD_mixdown_per_channel(AUD_Sound *sound, unsigned int start, unsigned int length,
+                                           unsigned int buffersize, const char *filename,
+                                           AUD_DeviceSpecs specs, AUD_Container format,
+                                           AUD_Codec codec, unsigned int bitrate);
 
 /**
  * Opens a read device and prepares it for mixdown of the sound scene.
@@ -728,7 +734,7 @@ extern const char* AUD_mixdown_per_channel(AUD_Sound* sound, unsigned int start,
  * \param start The start time of the mixdown in the sound scene.
  * \return The read device for the mixdown.
  */
-extern AUD_Device* AUD_openMixdownDevice(AUD_DeviceSpecs specs, AUD_Sound* sequencer, float volume, float start);
+extern AUD_Device *AUD_openMixdownDevice(AUD_DeviceSpecs specs, AUD_Sound *sequencer, float volume, float start);
 
 #ifdef WITH_PYTHON
 /**
@@ -736,14 +742,14 @@ extern AUD_Device* AUD_openMixdownDevice(AUD_DeviceSpecs specs, AUD_Sound* seque
  * \param sound The sound factory.
  * \return The python factory.
  */
-extern void* AUD_getPythonFactory(AUD_Sound* sound);
+extern void *AUD_getPythonFactory(AUD_Sound *sound);
 
 /**
  * Retrieves the sound factory of a python factory.
  * \param sound The python factory.
  * \return The sound factory.
  */
-extern AUD_Sound* AUD_getPythonSound(void* sound);
+extern AUD_Sound *AUD_getPythonSound(void *sound);
 #endif
 
 #ifdef __cplusplus
@@ -763,7 +769,7 @@ AUD_Reference<AUD_IDevice> AUD_getDevice();
  * Returns the current playback 3D device.
  * \return The playback 3D device.
  */
-AUD_I3DDeviceAUD_get3DDevice();
+AUD_I3DDevice *AUD_get3DDevice();
 #endif
 
 #endif //__AUD_C_API_H__
index 08e9b9ee726f8131ab5c88f5d99fd26b536f99a8..729d4dae1c96937aa7f02d545e545d13f2e017ca 100644 (file)
@@ -38,9 +38,11 @@ set(SRC_OSL
        node_musgrave_texture.osl
        node_normal.osl
        node_noise_texture.osl
+       node_object_info.osl
        node_output_displacement.osl
        node_output_surface.osl
        node_output_volume.osl
+       node_particle_info.osl
        node_separate_rgb.osl
        node_sky_texture.osl
        node_texture_coordinate.osl
diff --git a/intern/cycles/kernel/osl/nodes/node_object_info.osl b/intern/cycles/kernel/osl/nodes/node_object_info.osl
new file mode 100644 (file)
index 0000000..21e50d8
--- /dev/null
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2011, Blender Foundation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "stdosl.h"
+
+shader node_object_info(
+    output point Location = point(0.0, 0.0, 0.0),
+    output float ObjectIndex = 0.0,
+    output float MaterialIndex = 0.0,
+    output float Random = 0.0
+    )
+{
+    getattribute("std::object_location", Location);
+    getattribute("std::object_index", ObjectIndex);
+    getattribute("std::material_index", MaterialIndex);
+    getattribute("std::object_random", Random);
+}
+
diff --git a/intern/cycles/kernel/osl/nodes/node_particle_info.osl b/intern/cycles/kernel/osl/nodes/node_particle_info.osl
new file mode 100644 (file)
index 0000000..aadc281
--- /dev/null
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2011, Blender Foundation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "stdosl.h"
+
+shader node_particle_info(
+    output float Index = 0.0,
+    output float Age = 0.0,
+    output float Lifetime = 0.0,
+    output point Location = point(0.0, 0.0, 0.0),
+    output float Size = 0.0,
+    output vector Velocity = point(0.0, 0.0, 0.0),
+    output vector AngularVelocity = point(0.0, 0.0, 0.0)
+    )
+{
+    getattribute("std::particle_index", Index);
+    getattribute("std::particle_age", Age);
+    getattribute("std::particle_lifetime", Lifetime);
+    getattribute("std::particle_location", Location);
+    getattribute("std::particle_size", Size);
+    getattribute("std::particle_velocity", Velocity);
+    getattribute("std::particle_angular_velocity", AngularVelocity);
+}
+
index 075c68824e639ce581c650091ac3d2284d33617f..8cbbfc8dbb1547effdaee24a109a7d4a91a06d14 100644 (file)
@@ -36,7 +36,7 @@ struct OSLGlobals {
        /* use */
        bool use;
 
-       /* shading system */ 
+       /* shading system */
        OSL::ShadingSystem *ss;
        OSLRenderServices *services;
 
index a3f2c2ea3697a8f44ac309d960eba06a90bdf159..f1deaa9db9d623a67d6264d26c469831cffd2375 100644 (file)
@@ -179,55 +179,68 @@ bool OSLRenderServices::get_array_attribute(void *renderstate, bool derivatives,
        return false;
 }
 
-static bool get_mesh_attribute(KernelGlobals *kg, const ShaderData *sd,
-                               const OSLGlobals::Attribute& attr, bool derivatives, void *val)
+static void set_attribute_float3(float3 f[3], TypeDesc type, bool derivatives, void *val)
 {
-       if (attr.type == TypeDesc::TypeFloat) {
-               float *fval = (float *)val;
-               fval[0] = triangle_attribute_float(kg, sd, attr.elem, attr.offset,
-                                                  (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL);
+       if (type == TypeDesc::TypePoint || type == TypeDesc::TypeVector ||
+           type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor)
+       {
+               float3 *fval = (float3 *)val;
+               fval[0] = f[0];
+               if (derivatives) {
+                       fval[1] = f[1];
+                       fval[2] = f[2];
+               }
        }
        else {
-               /* todo: this won't work when float3 has w component */
-               float3 *fval = (float3 *)val;
-               fval[0] = triangle_attribute_float3(kg, sd, attr.elem, attr.offset,
-                                                   (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL);
+               float *fval = (float *)val;
+               fval[0] = average(f[0]);
+               if (derivatives) {
+                       fval[1] = average(f[1]);
+                       fval[2] = average(f[2]);
+               }
        }
-
-       return true;
 }
 
-static bool get_mesh_attribute_convert(KernelGlobals *kg, const ShaderData *sd,
-                                       const OSLGlobals::Attribute& attr, const TypeDesc& type, bool derivatives, void *val)
+static void set_attribute_float(float f[3], TypeDesc type, bool derivatives, void *val)
 {
-       if (attr.type == TypeDesc::TypeFloat) {
-               float tmp[3];
+       if (type == TypeDesc::TypePoint || type == TypeDesc::TypeVector ||
+           type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor)
+       {
                float3 *fval = (float3 *)val;
-
-               get_mesh_attribute(kg, sd, attr, derivatives, tmp);
-
-               fval[0] = make_float3(tmp[0], tmp[0], tmp[0]);
+               fval[0] = make_float3(f[0], f[0], f[0]);
+               if (derivatives) {
+                       fval[1] = make_float3(f[1], f[2], f[1]);
+                       fval[2] = make_float3(f[2], f[2], f[2]);
+               }
+       }
+       else {
+               float *fval = (float *)val;
+               fval[0] = f[0];
                if (derivatives) {
-                       fval[1] = make_float3(tmp[1], tmp[1], tmp[1]);
-                       fval[2] = make_float3(tmp[2], tmp[2], tmp[2]);
+                       fval[1] = f[1];
+                       fval[2] = f[2];
                }
+       }
+}
 
+static bool get_mesh_attribute(KernelGlobals *kg, const ShaderData *sd, const OSLGlobals::Attribute& attr,
+                               const TypeDesc& type, bool derivatives, void *val)
+{
+       if (attr.type == TypeDesc::TypeFloat) {
+               float fval[3];
+               fval[0] = triangle_attribute_float(kg, sd, attr.elem, attr.offset,
+                                                  (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL);
+               set_attribute_float(fval, type, derivatives, val);
                return true;
        }
        else if (attr.type == TypeDesc::TypePoint || attr.type == TypeDesc::TypeVector ||
                 attr.type == TypeDesc::TypeNormal || attr.type == TypeDesc::TypeColor)
        {
-               float3 tmp[3];
-               float *fval = (float *)val;
-
-               get_mesh_attribute(kg, sd, attr, derivatives, tmp);
-
-               fval[0] = average(tmp[0]);
-               if (derivatives) {
-                       fval[1] = average(tmp[1]);
-                       fval[2] = average(tmp[2]);
-               }
-
+               /* todo: this won't work when float3 has w component */
+               float3 fval[3];
+               fval[0] = triangle_attribute_float3(kg, sd, attr.elem, attr.offset,
+                                                   (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL);
+               set_attribute_float3(fval, type, derivatives, val);
                return true;
        }
        else
@@ -243,11 +256,116 @@ static void get_object_attribute(const OSLGlobals::Attribute& attr, bool derivat
                memset((char *)val + datasize, 0, datasize * 2);
 }
 
+static bool get_object_standard_attribute(KernelGlobals *kg, ShaderData *sd, ustring name,
+                                          TypeDesc type, bool derivatives, void *val)
+{
+       /* Object Attributes */
+       if (name == "std::object_location") {
+               float3 fval[3];
+               fval[0] = object_location(kg, sd);
+               fval[1] = fval[2] = make_float3(0.0, 0.0, 0.0); /* derivates set to 0 */
+               set_attribute_float3(fval, type, derivatives, val);
+               return true;
+       }
+       else if (name == "std::object_index") {
+               float fval[3];
+               fval[0] = object_pass_id(kg, sd->object);
+               fval[1] = fval[2] = 0.0;        /* derivates set to 0 */
+               set_attribute_float(fval, type, derivatives, val);
+               return true;
+       }
+       else if (name == "std::material_index") {
+               float fval[3];
+               fval[0] = shader_pass_id(kg, sd);
+               fval[1] = fval[2] = 0.0;        /* derivates set to 0 */
+               set_attribute_float(fval, type, derivatives, val);
+               return true;
+       }
+       else if (name == "std::object_random") {
+               float fval[3];
+               fval[0] = object_random_number(kg, sd->object);
+               fval[1] = fval[2] = 0.0;        /* derivates set to 0 */
+               set_attribute_float(fval, type, derivatives, val);
+               return true;
+       }
+
+       /* Particle Attributes */
+       else if (name == "std::particle_index") {
+               float fval[3];
+               uint particle_id = object_particle_id(kg, sd->object);
+               fval[0] = particle_index(kg, particle_id);
+               fval[1] = fval[2] = 0.0;        /* derivates set to 0 */
+               set_attribute_float(fval, type, derivatives, val);
+               return true;
+       }
+       else if (name == "std::particle_age") {
+               float fval[3];
+               uint particle_id = object_particle_id(kg, sd->object);
+               fval[0] = particle_age(kg, particle_id);
+               fval[1] = fval[2] = 0.0;        /* derivates set to 0 */
+               set_attribute_float(fval, type, derivatives, val);
+               return true;
+       }
+       else if (name == "std::particle_lifetime") {
+               float fval[3];
+               uint particle_id = object_particle_id(kg, sd->object);
+               fval[0] = particle_lifetime(kg, particle_id);
+               fval[1] = fval[2] = 0.0;        /* derivates set to 0 */
+               set_attribute_float(fval, type, derivatives, val);
+               return true;
+       }
+       else if (name == "std::particle_location") {
+               float3 fval[3];
+               uint particle_id = object_particle_id(kg, sd->object);
+               fval[0] = particle_location(kg, particle_id);
+               fval[1] = fval[2] = make_float3(0.0, 0.0, 0.0); /* derivates set to 0 */
+               set_attribute_float3(fval, type, derivatives, val);
+               return true;
+       }
+#if 0  /* unsupported */
+       else if (name == "std::particle_rotation") {
+               float4 fval[3];
+               uint particle_id = object_particle_id(kg, sd->object);
+               fval[0] = particle_rotation(kg, particle_id);
+               fval[1] = fval[2] = make_float4(0.0, 0.0, 0.0, 0.0);    /* derivates set to 0 */
+               set_attribute_float4(fval, type, derivatives, val);
+               return true;
+       }
+#endif
+       else if (name == "std::particle_size") {
+               float fval[3];
+               uint particle_id = object_particle_id(kg, sd->object);
+               fval[0] = particle_size(kg, particle_id);
+               fval[1] = fval[2] = 0.0;        /* derivates set to 0 */
+               set_attribute_float(fval, type, derivatives, val);
+               return true;
+       }
+       else if (name == "std::particle_velocity") {
+               float3 fval[3];
+               uint particle_id = object_particle_id(kg, sd->object);
+               fval[0] = particle_velocity(kg, particle_id);
+               fval[1] = fval[2] = make_float3(0.0, 0.0, 0.0); /* derivates set to 0 */
+               set_attribute_float3(fval, type, derivatives, val);
+               return true;
+       }
+       else if (name == "std::particle_angular_velocity") {
+               float3 fval[3];
+               uint particle_id = object_particle_id(kg, sd->object);
+               fval[0] = particle_angular_velocity(kg, particle_id);
+               fval[1] = fval[2] = make_float3(0.0, 0.0, 0.0); /* derivates set to 0 */
+               set_attribute_float3(fval, type, derivatives, val);
+               return true;
+       }
+       
+       else
+               return false;
+}
+
 bool OSLRenderServices::get_attribute(void *renderstate, bool derivatives, ustring object_name,
                                       TypeDesc type, ustring name, void *val)
 {
        KernelGlobals *kg = kernel_globals;
-       const ShaderData *sd = (const ShaderData *)renderstate;
+       ShaderData *sd = (ShaderData *)renderstate;
        int object = sd->object;
        int tri = sd->prim;
 
@@ -270,29 +388,23 @@ bool OSLRenderServices::get_attribute(void *renderstate, bool derivatives, ustri
        OSLGlobals::AttributeMap& attribute_map = kg->osl.attribute_map[object];
        OSLGlobals::AttributeMap::iterator it = attribute_map.find(name);
 
-       if (it == attribute_map.end())
-               return false;
-
-       /* type mistmatch? */
-       const OSLGlobals::Attribute& attr = it->second;
-
-       if (attr.elem != ATTR_ELEMENT_VALUE) {
-               /* triangle and vertex attributes */
-               if (tri != ~0) {
-                       if (attr.type == type || (attr.type == TypeDesc::TypeColor &&
-                                                 (type == TypeDesc::TypePoint || type == TypeDesc::TypeVector || type == TypeDesc::TypeNormal)))
-                       {
-                               return get_mesh_attribute(kg, sd, attr, derivatives, val);
-                       }
-                       else {
-                               return get_mesh_attribute_convert(kg, sd, attr, type, derivatives, val);
-                       }
+       if (it != attribute_map.end()) {
+               const OSLGlobals::Attribute& attr = it->second;
+               
+               if (attr.elem != ATTR_ELEMENT_VALUE) {
+                       /* triangle and vertex attributes */
+                       if (tri != ~0)
+                               return get_mesh_attribute(kg, sd, attr, type, derivatives, val);
+               }
+               else {
+                       /* object attribute */
+                       get_object_attribute(attr, derivatives, val);
+                       return true;
                }
        }
        else {
-               /* object attribute */
-               get_object_attribute(attr, derivatives, val);
-               return true;
+               /* not found in attribute, check standard object info */
+               return get_object_standard_attribute(kg, sd, name, type, derivatives, val);
        }
 
        return false;
@@ -310,15 +422,16 @@ bool OSLRenderServices::has_userdata(ustring name, TypeDesc type, void *renderst
 }
 
 int OSLRenderServices::pointcloud_search(OSL::ShaderGlobals *sg, ustring filename, const OSL::Vec3 &center,
-               float radius, int max_points, bool sort, size_t *out_indices, float *out_distances, int derivs_offset)
+                                         float radius, int max_points, bool sort,
+                                         size_t *out_indices, float *out_distances, int derivs_offset)
 {
-    return 0;
+       return 0;
 }
 
 int OSLRenderServices::pointcloud_get(ustring filename, size_t *indices, int count,
-               ustring attr_name, TypeDesc attr_type, void *out_data)
+                                      ustring attr_name, TypeDesc attr_type, void *out_data)
 {
-    return 0;
+       return 0;
 }
 
 CCL_NAMESPACE_END
index 5ec8a8edf9e07d4d51feb2df0152d8e4c0aeca7f..790b02a8abc4ff0804d98408d989ac7fb3794211 100644 (file)
@@ -56,22 +56,22 @@ public:
        bool get_matrix(OSL::Matrix44 &result, OSL::TransformationPtr xform);
        bool get_matrix(OSL::Matrix44 &result, ustring from);
 
-       bool get_array_attribute(void *renderstate, bool derivatives, 
+       bool get_array_attribute(void *renderstate, bool derivatives,
                                 ustring object, TypeDesc type, ustring name,
                                 int index, void *val);
        bool get_attribute(void *renderstate, bool derivatives, ustring object,
                           TypeDesc type, ustring name, void *val);
 
-       bool get_userdata(bool derivatives, ustring name, TypeDesc type, 
+       bool get_userdata(bool derivatives, ustring name, TypeDesc type,
                          void *renderstate, void *val);
        bool has_userdata(ustring name, TypeDesc type, void *renderstate);
-                                  
+
        int pointcloud_search(OSL::ShaderGlobals *sg, ustring filename, const OSL::Vec3 &center,
-                                               float radius, int max_points, bool sort, size_t *out_indices,
-                                               float *out_distances, int derivs_offset);
+                             float radius, int max_points, bool sort, size_t *out_indices,
+                             float *out_distances, int derivs_offset);
 
        int pointcloud_get(ustring filename, size_t *indices, int count, ustring attr_name,
-                                               TypeDesc attr_type, void *out_data);
+                          TypeDesc attr_type, void *out_data);
 
 private:
        KernelGlobals *kernel_globals;
index c7be02cc7afd4e7159d5680a3aeeee9be0888838..99d8854667ebe637ce1729fc30479efecbb38132 100644 (file)
@@ -676,7 +676,7 @@ GHOST_TSuccess GHOST_WindowCarbon::setWindowCursorShape(GHOST_TStandardCursor sh
        return GHOST_kSuccess;
 }
 
-#if 0
+#if 0  /* UNUSED */
 /** Reverse the bits in a GHOST_TUns8 */
 static GHOST_TUns8 uns8ReverseBits(GHOST_TUns8 ch)
 {
index 0e8ff438998088afc5881dab0b6a283dab84b8f1..c9c902fca8bc265fb1402fb1f95ce82b116ec864 100644 (file)
@@ -20,7 +20,7 @@
  *
  * The Original Code is: all of this file.
  *
- * Contributor(s): none yet.
+ * Contributor(s): Maarten Gribnau.
  *
  * ***** END GPL LICENSE BLOCK *****
  */
  *  \ingroup GHOST
  */
 
-
-/**
- * Copyright (C) 2001 NaN Technologies B.V.
- * \author     Maarten Gribnau
- * \date       May 10, 2001
- */
-
 #include <string.h>
 #include "GHOST_WindowWin32.h"
 #include "GHOST_SystemWin32.h"
@@ -50,7 +43,7 @@
 
 // MSVC6 still doesn't define M_PI
 #ifndef M_PI
-#define M_PI 3.1415926536
+#  define M_PI 3.1415926536
 #endif
 
 // Some more multisample defines
 #define WGL_SAMPLES_ARB         0x2042
 
 // win64 doesn't define GWL_USERDATA
-#ifdef WIN32
-#ifndef GWL_USERDATA
-#define GWL_USERDATA GWLP_USERDATA
-#define GWL_WNDPROC GWLP_WNDPROC
-#endif
+#ifdef WIN32  /* why? - probably should remove */
+#  ifndef GWL_USERDATA
+#    define GWL_USERDATA GWLP_USERDATA
+#    define GWL_WNDPROC GWLP_WNDPROC
+#  endif
 #endif
 
-wchar_t *GHOST_WindowWin32::s_windowClassName = L"GHOST_WindowClass";
+const wchar_t *GHOST_WindowWin32::s_windowClassName = L"GHOST_WindowClass";
 const int GHOST_WindowWin32::s_maxTitleLength = 128;
 HGLRC GHOST_WindowWin32::s_firsthGLRc = NULL;
 HDC GHOST_WindowWin32::s_firstHDC = NULL;
@@ -149,7 +142,6 @@ GHOST_WindowWin32::GHOST_WindowWin32(
        m_tablet(0),
        m_maxPressure(0),
        m_multisample(numOfAASamples),
-       m_parentWindowHwnd(parentwindowhwnd),
        m_multisampleEnabled(msEnabled),
        m_msPixelFormat(msPixelFormat),
        //For recreation
@@ -160,7 +152,8 @@ GHOST_WindowWin32::GHOST_WindowWin32(
        m_height(height),
        m_normal_state(GHOST_kWindowStateNormal),
        m_stereo(stereoVisual),
-       m_nextWindow(NULL)
+       m_nextWindow(NULL),
+       m_parentWindowHwnd(parentwindowhwnd)
 {
        OSVERSIONINFOEX versionInfo;
        bool hasMinVersionForTaskbar = false;
@@ -1208,6 +1201,7 @@ static GHOST_TUns8 uns8ReverseBits(GHOST_TUns8 ch)
        return ch;
 }
 
+#if 0  /* UNUSED */
 /** Reverse the bits in a GHOST_TUns16 */
 static GHOST_TUns16 uns16ReverseBits(GHOST_TUns16 shrt)
 {
@@ -1217,6 +1211,7 @@ static GHOST_TUns16 uns16ReverseBits(GHOST_TUns16 shrt)
        shrt = ((shrt >> 8) & 0x00FF) | ((shrt << 8) & 0xFF00);
        return shrt;
 }
+#endif
 GHOST_TSuccess GHOST_WindowWin32::setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2],
                                                              GHOST_TUns8 mask[16][2],
                                                              int hotX, int hotY)
index 3f52f9e22b0ccedcbb4c64dfa5cf0c2809b687be..9e4377b822582c20151b273d79c5e1e6b2921d03 100644 (file)
@@ -236,7 +236,7 @@ public:
         * Returns the name of the window class.
         * \return The name of the window class.
         */
-       static wchar_t *getWindowClassName() {
+       static const wchar_t *getWindowClassName() {
                return s_windowClassName;
        }
 
@@ -355,7 +355,7 @@ protected:
        /** ITaskbarList3 structure for progress bar*/
        ITaskbarList3 *m_Bar;
 
-       static wchar_t *s_windowClassName;
+       static const wchar_t *s_windowClassName;
        static const int s_maxTitleLength;
 
        /** WinTab dll handle */
index 0a3141d67829468c4ee5f0cd99fd2685693ac1a6..a1ae6bd81c0d6e8b0b622fff3653a2e58cc54e56 100644 (file)
@@ -437,7 +437,7 @@ const int g_iCells = 2048;
 // it is IMPORTANT that this function is called to evaluate the hash since
 // inlining could potentially reorder instructions and generate different
 // results for the same effective input value fVal.
-NOINLINE int FindGridCell(const float fMin, const float fMax, const float fVal)
+static NOINLINE int FindGridCell(const float fMin, const float fMax, const float fVal)
 {
        const float fIndex = g_iCells * ((fVal-fMin)/(fMax-fMin));
        const int iIndex = fIndex<0?0:((int)fIndex);
index 659d01e2d82b38c456acf66ad625eb10d3f10752..875dfc8a63bea722f659ae40c3bde58fc337db4b 100644 (file)
@@ -38,7 +38,7 @@
 
 
 // this is needed for inlining behavior
-#if defined _WIN32
+#if defined _MSC_VER
 #   define DO_INLINE __inline
 #elif defined (__sun) || defined (__sun__)
 #   define DO_INLINE
@@ -819,7 +819,7 @@ int PLX_raskterize_feather(float(*base_verts)[2], int num_base_verts, float(*fea
 
 #ifndef __PLX__FAKE_AA__
 
-int get_range_expanded_pixel_coord(float normalized_value, int max_value) {
+static int get_range_expanded_pixel_coord(float normalized_value, int max_value) {
     return (int)((normalized_value * (float)(max_value)) + 0.5f);
 }
 
@@ -1395,7 +1395,7 @@ int PLX_antialias_buffer(float *buf, int buf_x, int buf_y) {
 
 #define SWAP_POLYVERT(a,b)     point_temp[0]=(a)[0]; point_temp[1]=(a)[1]; (a)[0]=(b)[0]; (a)[1]=(b)[1]; (b)[0]=point_temp[0]; (b)[1]=point_temp[1];
 #define __PLX_SMALL_COUNT__ 13
-void plx_floatsort(float(*f)[2], unsigned int n, int sortby) {
+static void plx_floatsort(float(*f)[2], unsigned int n, int sortby) {
     unsigned int a;
     unsigned int b;
     unsigned int c;
@@ -1474,7 +1474,7 @@ void plx_floatsort(float(*f)[2], unsigned int n, int sortby) {
     }
 }
 
-int plx_find_lower_bound(float v, float(*a)[2], int num_feather_verts) {
+static int plx_find_lower_bound(float v, float(*a)[2], int num_feather_verts) {
     int x;
     int l;
     int r;
@@ -1502,7 +1502,7 @@ int plx_find_lower_bound(float v, float(*a)[2], int num_feather_verts) {
     }
 }
 
-int plx_find_upper_bound(float v, float(*a)[2], int num_feather_verts) {
+static int plx_find_upper_bound(float v, float(*a)[2], int num_feather_verts) {
     int x;
     int l;
     int r;
index a9b2920111dc01128cd7b724e1eb4dcaf2cbbf56..7f7a612528d775ea6da99ba60e403123423eea4c 100644 (file)
@@ -219,7 +219,9 @@ int conv_utf_8_to_16(const char *in8, wchar_t *out16, size_t size16)
        return err;
 }
 
-int is_ascii(const char *in8)
+/* UNUSED FUNCTIONS */
+#if 0
+static int is_ascii(const char *in8)
 {
        for (; *in8; in8++)
                if (0x80 & *in8) return 0;
@@ -227,7 +229,7 @@ int is_ascii(const char *in8)
        return 1;
 }
 
-void utf_8_cut_end(char *inout8, size_t maxcutpoint)
+static void utf_8_cut_end(char *inout8, size_t maxcutpoint)
 {
        char *cur = inout8 + maxcutpoint;
        char cc;
@@ -235,7 +237,7 @@ void utf_8_cut_end(char *inout8, size_t maxcutpoint)
 
        cc = *cur;
 }
-
+#endif
 
 
 char *alloc_utf_8_from_16(const wchar_t *in16, size_t add)
index d19c57b0d5b8a12b0c123627ef3d37149c3668f3..cd67059ea8cf98615e7803747c3e90549ae6e9b7 100644 (file)
@@ -42,7 +42,7 @@ struct Histogram;
 struct ImBuf;
 struct rctf;
 
-#if defined _WIN32
+#if defined _MSC_VER
 #   define DO_INLINE __inline
 #elif defined(__sun) || defined(__sun__)
 #   define DO_INLINE
index 19dd67b88f85da29cf5dfb1d7c09943448ac0da5..33361b9921c012676c4d8b18f9b432fa2539ace7 100644 (file)
@@ -73,6 +73,8 @@ extern const CustomDataMask CD_MASK_FACECORNERS;
 
 #define CD_TYPE_AS_MASK(_type) (CustomDataMask)((CustomDataMask)1 << (CustomDataMask)(_type))
 
+void customData_mask_layers__print(CustomDataMask mask);
+
 /**
  * Checks if the layer at physical offset \a layer_n (in data->layers) support math
  * the below operations.
index 51e301fec80a9c08f012925637111ebb0e738268..cc15ceecbac0ca35881226ff42a4f79a399ebbe9 100644 (file)
@@ -131,6 +131,7 @@ void BKE_mask_get_handle_point_adjacent(struct MaskSpline *spline, struct MaskSp
 void BKE_mask_layer_calc_handles(struct MaskLayer *masklay);
 void BKE_mask_layer_calc_handles_deform(struct MaskLayer *masklay);
 void BKE_mask_calc_handles(struct Mask *mask);
+void BKE_mask_update_deform(struct Mask *mask);
 void BKE_mask_spline_ensure_deform(struct MaskSpline *spline);
 
 /* animation */
@@ -163,10 +164,10 @@ void BKE_mask_layer_shape_changed_remove(struct MaskLayer *masklay, int index, i
 
 int BKE_mask_get_duration(struct Mask *mask);
 
-#define MASKPOINT_ISSEL_ANY(p)          ( ((p)->bezt.f1 | (p)->bezt.f2 | (p)->bezt.f2) & SELECT)
+#define MASKPOINT_ISSEL_ANY(p)          ( ((p)->bezt.f1 | (p)->bezt.f2 | (p)->bezt.f3) & SELECT)
 #define MASKPOINT_ISSEL_KNOT(p)         ( (p)->bezt.f2 & SELECT)
-#define MASKPOINT_ISSEL_HANDLE_ONLY(p)  ( (((p)->bezt.f1 | (p)->bezt.f2) & SELECT) && (((p)->bezt.f2 & SELECT) == 0) )
-#define MASKPOINT_ISSEL_HANDLE(p)       ( (((p)->bezt.f1 | (p)->bezt.f2) & SELECT) )
+#define MASKPOINT_ISSEL_HANDLE_ONLY(p)  ( (((p)->bezt.f1 | (p)->bezt.f3) & SELECT) && (((p)->bezt.f2 & SELECT) == 0) )
+#define MASKPOINT_ISSEL_HANDLE(p)       ( (((p)->bezt.f1 | (p)->bezt.f3) & SELECT) )
 
 #define MASKPOINT_SEL_ALL(p)    { (p)->bezt.f1 |=  SELECT; (p)->bezt.f2 |=  SELECT; (p)->bezt.f3 |=  SELECT; } (void)0
 #define MASKPOINT_DESEL_ALL(p)  { (p)->bezt.f1 &= ~SELECT; (p)->bezt.f2 &= ~SELECT; (p)->bezt.f3 &= ~SELECT; } (void)0
index 576b79f899c0460b9cbb15d2d817daef7edf8632..efdb80433c61486a03a081337b606c0e27f4b744 100644 (file)
@@ -44,6 +44,7 @@ set(INC
        ../../../intern/mikktspace
        ../../../intern/opennl/extern
        ../../../intern/raskter
+       ../../../intern/smoke/extern
 
        # XXX - BAD LEVEL CALL WM_api.h
        ../windowmanager
@@ -342,9 +343,6 @@ if(WITH_MOD_FLUID)
 endif()
 
 if(WITH_MOD_SMOKE)
-       list(APPEND INC
-               ../../../intern/smoke/extern
-       )
        add_definitions(-DWITH_SMOKE)
 endif()
 
index 9145c4af85086dcb574f5bfd075250a8c3b885b3..99b788e80ce5dda6514be2fbca5775f48c7bbba1 100644 (file)
@@ -92,7 +92,7 @@
 #include "IMB_colormanagement.h"
 
 #ifdef WITH_PYTHON
-#include "BPY_extern.h"
+#  include "BPY_extern.h"
 #endif
 
 Global G;
@@ -219,8 +219,6 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath
        /* no load screens? */
        if (mode) {
                /* comes from readfile.c */
-               extern void lib_link_screen_restore(Main *, bScreen *, Scene *);
-               
                SWAP(ListBase, G.main->wm, bfd->main->wm);
                SWAP(ListBase, G.main->screen, bfd->main->screen);
                SWAP(ListBase, G.main->script, bfd->main->script);
@@ -234,7 +232,7 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath
                if (curscreen) curscreen->scene = curscene;  /* can run in bgmode */
 
                /* clear_global will free G.main, here we can still restore pointers */
-               lib_link_screen_restore(bfd->main, curscreen, curscene);
+               blo_lib_link_screen_restore(bfd->main, curscreen, curscene);
        }
        
        /* free G.main Main database */
index b0de7a5ea6c88be004c1214bb0f908f242129ac9..4241756a109d9d9fcf3c7eb8d41cb6191690b56a 100644 (file)
 #include "BKE_modifier.h"
 #include "BKE_pointcache.h"
 
-#ifdef _WIN32
-void tstart( void )
-{}
-void tend( void )
-{
-}
-double tval( void )
-{
-       return 0;
-}
-#else
-#include <sys/time.h>
-static struct timeval _tstart, _tend;
-static struct timezone tz;
-void tstart( void )
-{
-       gettimeofday(&_tstart, &tz);
-}
-void tend(void)
-{
-       gettimeofday(&_tend, &tz);
-}
-double tval(void)
-{
-       double t1, t2;
-       t1 = ( double ) _tstart.tv_sec + ( double ) _tstart.tv_usec/ ( 1000*1000 );
-       t2 = ( double ) _tend.tv_sec + ( double ) _tend.tv_usec/ ( 1000*1000 );
-       return t2-t1;
-}
-#endif
+// #include "PIL_time.h"  /* timing for debug prints */
 
 /* Our available solvers. */
 // 255 is the magic reserved number, so NEVER try to put 255 solvers in here!
@@ -410,13 +381,13 @@ static int do_step_cloth(Object *ob, ClothModifierData *clmd, DerivedMesh *resul
        cloth_apply_vgroup ( clmd, result );
        cloth_update_springs( clmd );
        
-       tstart();
+       // TIMEIT_START(cloth_step)
 
        /* call the solver. */
        if (solvers [clmd->sim_parms->solver_type].solver)
                ret = solvers[clmd->sim_parms->solver_type].solver(ob, framenr, clmd, effectors);
 
-       tend();
+       // TIMEIT_END(cloth_step)
 
        pdEndEffectors(&effectors);
 
index f47ac641cf92f068063699d125bafb640dc4b5d7..1cb29b90133389577544cce59d4726deeed852be 100644 (file)
@@ -669,7 +669,7 @@ static void boundInsert(Bounds3D *b, float point[3])
        }
 }
 
-float getSurfaceDimension(PaintSurfaceData *sData)
+static float getSurfaceDimension(PaintSurfaceData *sData)
 {
        Bounds3D *mb = &sData->bData->mesh_bounds;
        return MAX3((mb->max[0] - mb->min[0]), (mb->max[1] - mb->min[1]), (mb->max[2] - mb->min[2]));
@@ -910,7 +910,7 @@ static void free_bakeData(PaintSurfaceData *data)
 }
 
 /* free surface data if it's not used anymore */
-void surface_freeUnusedData(DynamicPaintSurface *surface)
+static void surface_freeUnusedData(DynamicPaintSurface *surface)
 {
        if (!surface->data) return;
 
@@ -1368,7 +1368,7 @@ static void dynamicPaint_initAdjacencyData(DynamicPaintSurface *surface, int for
        MEM_freeN(temp_data);
 }
 
-void dynamicPaint_setInitialColor(DynamicPaintSurface *surface)
+static void dynamicPaint_setInitialColor(DynamicPaintSurface *surface)
 {
        PaintSurfaceData *sData = surface->data;
        PaintPoint *pPoint = (PaintPoint *)sData->type_data;
@@ -1605,7 +1605,7 @@ static void dynamicPaint_applySurfaceDisplace(DynamicPaintSurface *surface, Deri
 /*
  *     Apply canvas data to the object derived mesh
  */
-struct DerivedMesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd,
+static DerivedMesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd,
                                                 Object *ob,
                                                 DerivedMesh *dm)
 {
@@ -1830,9 +1830,12 @@ void dynamicPaint_cacheUpdateFrames(DynamicPaintSurface *surface)
        }
 }
 
-void canvas_copyDerivedMesh(DynamicPaintCanvasSettings *canvas, DerivedMesh *dm)
+static void canvas_copyDerivedMesh(DynamicPaintCanvasSettings *canvas, DerivedMesh *dm)
 {
-       if (canvas->dm) canvas->dm->release(canvas->dm);
+       if (canvas->dm) {
+               canvas->dm->release(canvas->dm);
+       }
+
        canvas->dm = CDDM_copy(dm);
 }
 
@@ -2748,7 +2751,7 @@ static void dynamicPaint_freeBrushMaterials(BrushMaterials *bMats)
 /*
  *     Get material diffuse color and alpha (including linked textures) in given coordinates
  */
-void dynamicPaint_doMaterialTex(BrushMaterials *bMats, float color[3], float *alpha, Object *brushOb, const float volume_co[3], const float surface_co[3], int faceIndex, short isQuad, DerivedMesh *orcoDm)
+static void dynamicPaint_doMaterialTex(BrushMaterials *bMats, float color[3], float *alpha, Object *brushOb, const float volume_co[3], const float surface_co[3], int faceIndex, short isQuad, DerivedMesh *orcoDm)
 {
        Material *mat = bMats->mat;
        MFace *mface = orcoDm->getTessFaceArray(orcoDm);
@@ -3953,7 +3956,7 @@ static void dynamicPaint_prepareAdjacencyData(DynamicPaintSurface *surface, int
 }
 
 /* find two adjacency points (closest_id) and influence (closest_d) to move paint towards when affected by a force  */
-void surface_determineForceTargetPoints(PaintSurfaceData *sData, int index, float force[3], float closest_d[2], int closest_id[2])
+static void surface_determineForceTargetPoints(PaintSurfaceData *sData, int index, float force[3], float closest_d[2], int closest_id[2])
 {
        BakeAdjPoint *bNeighs = sData->bData->bNeighs;
        int numOfNeighs = sData->adj_data->n_num[index];
@@ -4342,7 +4345,7 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
        }
 }
 
-void dynamicPaint_doWaveStep(DynamicPaintSurface *surface, float timescale)
+static void dynamicPaint_doWaveStep(DynamicPaintSurface *surface, float timescale)
 {
        PaintSurfaceData *sData = surface->data;
        BakeAdjPoint *bNeighs = sData->bData->bNeighs;
index 1c6974b2615337c58e702342b15323f509d8b44d..fcc8b4322a0d08ec24f937188ce0d46163f1ea3a 100644 (file)
@@ -50,6 +50,7 @@
 
 #define CLOTH_OPENMP_LIMIT 512
 
+#if 0  /* debug timing */
 #ifdef _WIN32
 #include <windows.h>
 static LARGE_INTEGER _itstart, _itend;
@@ -81,7 +82,7 @@ double itval(void)
 
 static struct timeval _itstart, _itend;
 static struct timezone itz;
-void itstart(void)
+static void itstart(void)
 {
        gettimeofday(&_itstart, &itz);
 }
@@ -89,7 +90,7 @@ static void itend(void)
 {
        gettimeofday(&_itend, &itz);
 }
-double itval(void)
+static double itval(void)
 {
        double t1, t2;
        t1 =  (double)_itstart.tv_sec + (double)_itstart.tv_usec/(1000*1000);
@@ -97,6 +98,7 @@ double itval(void)
        return t2-t1;
 }
 #endif
+#endif  /* debug timing */
 
 static float I[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
 static float ZERO[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
@@ -1691,13 +1693,13 @@ static void simulate_implicit_euler(lfVector *Vnew, lfVector *UNUSED(lX), lfVect
        mul_bfmatrix_lfvector(dFdXmV, dFdX, lV);
 
        add_lfvectorS_lfvectorS(B, lF, dt, dFdXmV, (dt*dt), numverts);
-       
-       itstart();
-       
+
+       // itstart();
+
        cg_filtered(dV, A, B, z, S); /* conjugate gradient algorithm to solve Ax=b */
        // cg_filtered_pre(dV, A, B, z, S, P, Pinv, bigI);
-       
-       itend();
+
+       // itend();
        // printf("cg_filtered calc time: %f\n", (float)itval());
        
        cp_lfvector(olddV, dV, numverts);
@@ -1713,7 +1715,7 @@ static void simulate_implicit_euler(lfVector *Vnew, lfVector *UNUSED(lX), lfVect
  * (edge distance constraints) in a lagrangian solver.  then add forces to help
  * guide the implicit solver to that state.  this function is called after
  * collisions*/
-int cloth_calc_helper_forces(Object *UNUSED(ob), ClothModifierData * clmd, float (*initial_cos)[3], float UNUSED(step), float dt)
+static int UNUSED_FUNCTION(cloth_calc_helper_forces)(Object *UNUSED(ob), ClothModifierData * clmd, float (*initial_cos)[3], float UNUSED(step), float dt)
 {
        Cloth *cloth= clmd->clothObject;
        float (*cos)[3] = MEM_callocN(sizeof(float)*3*cloth->numverts, "cos cloth_calc_helper_forces");
index 97b46d4829d9d68f415bbdb0ce5ca8f2a348a3cf..3564071334c7a32400a0bd9e01f89a51ea16cd09 100644 (file)
@@ -1112,7 +1112,8 @@ static int BKE_mask_evaluate_parent(MaskParent *parent, float ctime, float r_co[
        return FALSE;
 }
 
-int BKE_mask_evaluate_parent_delta(MaskParent *parent, float ctime, float r_delta[2])
+/* could make external but for now its only used internally */
+static int mask_evaluate_parent_delta(MaskParent *parent, float ctime, float r_delta[2])
 {
        float parent_co[2];
 
@@ -1452,7 +1453,7 @@ void BKE_mask_layer_evaluate(MaskLayer *masklay, const float ctime, const int do
                                *point_deform = *point;
                                point_deform->uw = point->uw ? MEM_dupallocN(point->uw) : NULL;
 
-                               if (BKE_mask_evaluate_parent_delta(&point->parent, ctime, delta)) {
+                               if (mask_evaluate_parent_delta(&point->parent, ctime, delta)) {
                                        add_v2_v2(point_deform->bezt.vec[0], delta);
                                        add_v2_v2(point_deform->bezt.vec[1], delta);
                                        add_v2_v2(point_deform->bezt.vec[2], delta);
index 18617f0ef2ea9af7893a492ff1318fa4762e5827..00898b0fe10733b975944e5c763a77fc9fed7d47 100644 (file)
@@ -253,9 +253,9 @@ void BKE_maskrasterize_handle_free(MaskRasterHandle *mr_handle)
 }
 
 
-void maskrasterize_spline_differentiate_point_outset(float (*diff_feather_points)[2], float (*diff_points)[2],
-                                                     const unsigned int tot_diff_point, const float ofs,
-                                                     const short do_test)
+static void maskrasterize_spline_differentiate_point_outset(float (*diff_feather_points)[2], float (*diff_points)[2],
+                                                            const unsigned int tot_diff_point, const float ofs,
+                                                            const short do_test)
 {
        unsigned int k_prev = tot_diff_point - 2;
        unsigned int k_curr = tot_diff_point - 1;
index cd8b0e4e52c6604e48275ee309fca3420c698da6..97d4c150b845565a2955851cda23250cf6a2d697 100644 (file)
@@ -391,7 +391,7 @@ static int moviecache_hashcmp(const void *av, const void *bv)
        return 0;
 }
 
-void *moviecache_getprioritydata(void *key_v)
+static void *moviecache_getprioritydata(void *key_v)
 {
        MovieClipImBufCacheKey *key = (MovieClipImBufCacheKey *) key_v;
        MovieClipCachePriorityData *priority_data;
@@ -402,7 +402,7 @@ void *moviecache_getprioritydata(void *key_v)
        return priority_data;
 }
 
-int moviecache_getitempriority(void *last_userkey_v, void *priority_data_v)
+static int moviecache_getitempriority(void *last_userkey_v, void *priority_data_v)
 {
        MovieClipImBufCacheKey *last_userkey = (MovieClipImBufCacheKey *) last_userkey_v;
        MovieClipCachePriorityData *priority_data = (MovieClipCachePriorityData *) priority_data_v;
@@ -410,7 +410,7 @@ int moviecache_getitempriority(void *last_userkey_v, void *priority_data_v)
        return -abs(last_userkey->framenr - priority_data->framenr);
 }
 
-void moviecache_prioritydeleter(void *priority_data_v)
+static void moviecache_prioritydeleter(void *priority_data_v)
 {
        MovieClipCachePriorityData *priority_data = (MovieClipCachePriorityData *) priority_data_v;
 
index 5dfecfcb7171a866e57d555d19de40a6de7b7cb1..4fb235ac9f7e4bee890565ad0ae1aaca5a7f3067 100644 (file)
@@ -305,17 +305,27 @@ void BKE_object_free(Object *ob)
                ID *id = ob->data;
                id->us--;
                if (id->us == 0) {
-                       if (ob->type == OB_MESH) BKE_mesh_unlink(ob->data);
-                       else if (ob->type == OB_CURVE) BKE_curve_unlink(ob->data);
-                       else if (ob->type == OB_MBALL) BKE_mball_unlink(ob->data);
+                       switch (ob->type) {
+                               case OB_MESH:
+                                       BKE_mesh_unlink((Mesh *)id);
+                                       break;
+                               case OB_CURVE:
+                                       BKE_curve_unlink((Curve *)id);
+                                       break;
+                               case OB_MBALL:
+                                       BKE_mball_unlink((MetaBall *)id);
+                                       break;
+                       }
                }
                ob->data = NULL;
        }
-       
-       for (a = 0; a < ob->totcol; a++) {
-               if (ob->mat[a]) ob->mat[a]->id.us--;
+
+       if (ob->mat) {
+               for (a = 0; a < ob->totcol; a++) {
+                       if (ob->mat[a]) ob->mat[a]->id.us--;
+               }
+               MEM_freeN(ob->mat);
        }
-       if (ob->mat) MEM_freeN(ob->mat);
        if (ob->matbits) MEM_freeN(ob->matbits);
        ob->mat = NULL;
        ob->matbits = NULL;
@@ -1757,8 +1767,8 @@ static void give_parvert(Object *par, int nr, float vec[3])
 {
        BMEditMesh *em;
        int a, count;
-       
-       vec[0] = vec[1] = vec[2] = 0.0f;
+
+       zero_v3(vec);
        
        if (par->type == OB_MESH) {
                Mesh *me = par->data;
@@ -1850,7 +1860,7 @@ static void give_parvert(Object *par, int nr, float vec[3])
                                while (a--) {
                                        if (count == nr) {
                                                found = 1;
-                                               memcpy(vec, bp->vec, sizeof(float) * 3);
+                                               copy_v3_v3(vec, bp->vec);
                                                break;
                                        }
                                        count++;
@@ -1875,9 +1885,9 @@ static void give_parvert(Object *par, int nr, float vec[3])
                while (a--) {
                        if (count == nr) {
                                if (co)
-                                       memcpy(vec, co, 3 * sizeof(float));
+                                       copy_v3_v3(vec, co);
                                else
-                                       memcpy(vec, bp->vec, 3 * sizeof(float));
+                                       copy_v3_v3(vec, bp->vec);
                                break;
                        }
                        count++;
index bae8efa758ea37c90bcfac9d85020f983fb0f536..2c0452bc2d137e603ed273eb0043b8beb2214b78 100644 (file)
@@ -3776,7 +3776,7 @@ static void save_hair(ParticleSimulationData *sim, float UNUSED(cfra))
  * simulation. This should be called once per particle during a simulation
  * step, after the velocity has been updated. element_size defines the scale of
  * the simulation, and is typically the distance to neighbourning particles. */
-void update_courant_num(ParticleSimulationData *sim, ParticleData *pa,
+static void update_courant_num(ParticleSimulationData *sim, ParticleData *pa,
        float dtime, SPHData *sphdata)
 {
        float relative_vel[3];
@@ -3788,8 +3788,7 @@ void update_courant_num(ParticleSimulationData *sim, ParticleData *pa,
                sim->courant_num = speed * dtime / sphdata->element_size;
 }
 /* Update time step size to suit current conditions. */
-float update_timestep(ParticleSystem *psys, ParticleSimulationData *sim,
-       float t_frac)
+static float update_timestep(ParticleSystem *psys, ParticleSimulationData *sim, float t_frac)
 {
        if (sim->courant_num == 0.0f)
                psys->dt_frac = 1.0f;
index 1fa009d22a036314fb4ce1ba30b3e7f1aff8acf6..b0dcad64722f86fa97eda033437f11de541084ff 100644 (file)
@@ -140,7 +140,7 @@ static void modifier_apply_threaded(ImBuf *ibuf, ImBuf *mask, modifier_apply_thr
 
 /* **** Color Balance Modifier **** */
 
-void colorBalance_init_data(SequenceModifierData *smd)
+static void colorBalance_init_data(SequenceModifierData *smd)
 {
        ColorBalanceModifierData *cbmd = (ColorBalanceModifierData *) smd;
        int c;
@@ -154,7 +154,7 @@ void colorBalance_init_data(SequenceModifierData *smd)
        }
 }
 
-void colorBalance_apply(SequenceModifierData *smd, ImBuf *ibuf, ImBuf *mask)
+static void colorBalance_apply(SequenceModifierData *smd, ImBuf *ibuf, ImBuf *mask)
 {
        ColorBalanceModifierData *cbmd = (ColorBalanceModifierData *) smd;
 
@@ -173,21 +173,21 @@ static SequenceModifierTypeInfo seqModifier_ColorBalance = {
 
 /* **** Curves Modifier **** */
 
-void curves_init_data(SequenceModifierData *smd)
+static void curves_init_data(SequenceModifierData *smd)
 {
        CurvesModifierData *cmd = (CurvesModifierData *) smd;
 
        curvemapping_set_defaults(&cmd->curve_mapping, 4, 0.0f, 0.0f, 1.0f, 1.0f);
 }
 
-void curves_free_data(SequenceModifierData *smd)
+static void curves_free_data(SequenceModifierData *smd)
 {
        CurvesModifierData *cmd = (CurvesModifierData *) smd;
 
        curvemapping_free_data(&cmd->curve_mapping);
 }
 
-void curves_copy_data(SequenceModifierData *target, SequenceModifierData *smd)
+static void curves_copy_data(SequenceModifierData *target, SequenceModifierData *smd)
 {
        CurvesModifierData *cmd = (CurvesModifierData *) smd;
        CurvesModifierData *cmd_target = (CurvesModifierData *) target;
@@ -195,8 +195,8 @@ void curves_copy_data(SequenceModifierData *target, SequenceModifierData *smd)
        curvemapping_copy_data(&cmd_target->curve_mapping, &cmd->curve_mapping);
 }
 
-void curves_apply_threaded(int width, int height, unsigned char *rect, float *rect_float,
-                           unsigned char *mask_rect, float *mask_rect_float, void *data_v)
+static void curves_apply_threaded(int width, int height, unsigned char *rect, float *rect_float,
+                                  unsigned char *mask_rect, float *mask_rect_float, void *data_v)
 {
        CurveMapping *curve_mapping = (CurveMapping *) data_v;
        int x, y;
@@ -249,7 +249,7 @@ void curves_apply_threaded(int width, int height, unsigned char *rect, float *re
        }
 }
 
-void curves_apply(struct SequenceModifierData *smd, ImBuf *ibuf, ImBuf *mask)
+static void curves_apply(struct SequenceModifierData *smd, ImBuf *ibuf, ImBuf *mask)
 {
        CurvesModifierData *cmd = (CurvesModifierData *) smd;
 
@@ -278,7 +278,7 @@ static SequenceModifierTypeInfo seqModifier_Curves = {
 
 /* **** Hue Correct Modifier **** */
 
-void hue_correct_init_data(SequenceModifierData *smd)
+static void hue_correct_init_data(SequenceModifierData *smd)
 {
        HueCorrectModifierData *hcmd = (HueCorrectModifierData *) smd;
        int c;
@@ -296,14 +296,14 @@ void hue_correct_init_data(SequenceModifierData *smd)
        hcmd->curve_mapping.cur = 1;
 }
 
-void hue_correct_free_data(SequenceModifierData *smd)
+static void hue_correct_free_data(SequenceModifierData *smd)
 {
        HueCorrectModifierData *hcmd = (HueCorrectModifierData *) smd;
 
        curvemapping_free_data(&hcmd->curve_mapping);
 }
 
-void hue_correct_copy_data(SequenceModifierData *target, SequenceModifierData *smd)
+static void hue_correct_copy_data(SequenceModifierData *target, SequenceModifierData *smd)
 {
        HueCorrectModifierData *hcmd = (HueCorrectModifierData *) smd;
        HueCorrectModifierData *hcmd_target = (HueCorrectModifierData *) target;
@@ -311,7 +311,7 @@ void hue_correct_copy_data(SequenceModifierData *target, SequenceModifierData *s
        curvemapping_copy_data(&hcmd_target->curve_mapping, &hcmd->curve_mapping);
 }
 
-void hue_correct_apply_threaded(int width, int height, unsigned char *rect, float *rect_float,
+static void hue_correct_apply_threaded(int width, int height, unsigned char *rect, float *rect_float,
                                 unsigned char *mask_rect, float *mask_rect_float, void *data_v)
 {
        CurveMapping *curve_mapping = (CurveMapping *) data_v;
@@ -365,7 +365,7 @@ void hue_correct_apply_threaded(int width, int height, unsigned char *rect, floa
        }
 }
 
-void hue_correct_apply(struct SequenceModifierData *smd, ImBuf *ibuf, ImBuf *mask)
+static void hue_correct_apply(struct SequenceModifierData *smd, ImBuf *ibuf, ImBuf *mask)
 {
        HueCorrectModifierData *hcmd = (HueCorrectModifierData *) smd;
 
@@ -391,8 +391,8 @@ typedef struct BrightContrastThreadData {
        float contrast;
 } BrightContrastThreadData;
 
-void brightcontrast_apply_threaded(int width, int height, unsigned char *rect, float *rect_float,
-                                   unsigned char *mask_rect, float *mask_rect_float, void *data_v)
+static void brightcontrast_apply_threaded(int width, int height, unsigned char *rect, float *rect_float,
+                                          unsigned char *mask_rect, float *mask_rect_float, void *data_v)
 {
        BrightContrastThreadData *data = (BrightContrastThreadData *) data_v;
        int x, y;
@@ -460,7 +460,7 @@ void brightcontrast_apply_threaded(int width, int height, unsigned char *rect, f
        }
 }
 
-void brightcontrast_apply(struct SequenceModifierData *smd, ImBuf *ibuf, ImBuf *mask)
+static void brightcontrast_apply(struct SequenceModifierData *smd, ImBuf *ibuf, ImBuf *mask)
 {
        BrightContrastModifierData *bcmd = (BrightContrastModifierData *) smd;
        BrightContrastThreadData data;
index ddcba50930122c071498a23f0b2987122ab612d4..5e67e094e4366d8be673a536531ae0179be60bfd 100644 (file)
 /* UNUSED so far, may be enabled later */
 /* #define USE_SMOKE_COLLISION_DM */
 
-#ifdef WITH_SMOKE
-
 #include "smoke_API.h"
 
+#ifdef WITH_SMOKE
+
 #ifdef _WIN32
 #include <time.h>
 #include <stdio.h>
@@ -148,7 +148,7 @@ static void fill_scs_points(Object *ob, DerivedMesh *dm, SmokeCollSettings *scs)
 
 /* Stubs to use when smoke is disabled */
 struct WTURBULENCE *smoke_turbulence_init(int *UNUSED(res), int UNUSED(amplify), int UNUSED(noisetype)) { return NULL; }
-struct FLUID_3D *smoke_init(int *UNUSED(res), float *UNUSED(p0)) { return NULL; }
+// struct FLUID_3D *smoke_init(int *UNUSED(res), float *UNUSED(p0)) { return NULL; }
 void smoke_free(struct FLUID_3D *UNUSED(fluid)) {}
 float *smoke_get_density(struct FLUID_3D *UNUSED(fluid)) { return NULL; }
 void smoke_turbulence_free(struct WTURBULENCE *UNUSED(wt)) {}
index 787def5c20b173493620bcd1dc71bf67c286f740..af5a8f5d59db9379b38f7a68236f5754e62c378c 100644 (file)
@@ -3031,30 +3031,6 @@ void txt_uncomment(Text *text)
        }
 }
 
-
-void txt_move_lines_up(struct Text *text)
-{
-       TextLine *prev_line;
-       
-       if (!text || !text->curl || !text->sell) return;
-       
-       txt_order_cursors(text);
-       
-       prev_line = text->curl->prev;
-       
-       if (!prev_line) return;
-       
-       BLI_remlink(&text->lines, prev_line);
-       BLI_insertlinkafter(&text->lines, text->sell, prev_line);
-       
-       txt_make_dirty(text);
-       txt_clean_text(text);
-       
-       if (!undoing) {
-               txt_undo_add_op(text, UNDO_MOVE_LINES_UP);
-       }
-}
-
 void txt_move_lines(struct Text *text, const int direction)
 {
        TextLine *line_other;
index ee904de4af6ca698b8359f16bd9bb75eafbca4bc..bdd9b424f3b89e9b82d49fa5350af0222064a984 100644 (file)
@@ -338,7 +338,7 @@ void colorband_table_RGBA(ColorBand *coba, float **array, int *size)
                do_colorband(coba, (float)a / (float)CM_TABLE, &(*array)[a * 4]);
 }
 
-int vergcband(const void *a1, const void *a2)
+static int vergcband(const void *a1, const void *a2)
 {
        const CBData *x1 = a1, *x2 = a2;
 
index c0c5c5791337323a3192d303a9659e6772db9e4d..97ebc3a90ba6f4f381fd7dfc4ad81a2e5c9733f2 100644 (file)
@@ -2223,8 +2223,8 @@ static ImBuf *tracking_context_get_frame_ibuf(MovieTrackingContext *context, int
        return ibuf;
 }
 
-MovieTrackingMarker *tracking_context_get_keyframed_marker(MovieTrackingContext *context, MovieTrackingTrack *track,
-                                                           MovieTrackingMarker *marker)
+static MovieTrackingMarker *tracking_context_get_keyframed_marker(MovieTrackingContext *context, MovieTrackingTrack *track,
+                                                                  MovieTrackingMarker *marker)
 {
        int a = marker - track->markers;
        MovieTrackingMarker *marker_keyed = marker;
index bd25ff8c6e65e4292bcfff4125439739aecf66a4..4019eba517786bdb6b6bc1ddc68aba4a9d0eb03c 100644 (file)
@@ -847,7 +847,7 @@ static int start_ffmpeg_impl(struct RenderData *rd, int rectx, int recty, Report
  * parameter.
  * </p>
  */
-void flush_ffmpeg(void)
+static void flush_ffmpeg(void)
 {
        int outsize = 0;
        int ret = 0;
index 7520f09fe954e9b68493e092a8d9d1d0eea8adba..6fe5d48d06eda1174253dfc2d7fc5ff9b9753a37 100644 (file)
@@ -67,6 +67,8 @@ void rgb_to_yuv(float r, float g, float b, float *ly, float *lu, float *lv);
 void rgb_to_ycc(float r, float g, float b, float *ly, float *lcb, float *lcr, int colorspace);
 void rgb_to_hsv(float r, float g, float b, float *lh, float *ls, float *lv);
 void rgb_to_hsv_v(const float rgb[3], float r_hsv[3]);
+void rgb_to_hsl(float r, float g, float b, float *lh, float *ls, float *ll);
+void rgb_to_hsl_v(const float rgb[3], float r_hsl[3]);
 void rgb_to_hsv_compat(float r, float g, float b, float *lh, float *ls, float *lv);
 void rgb_to_hsv_compat_v(const float rgb[3], float r_hsv[3]);
 void rgb_to_lab(float r, float g, float b, float *ll, float *la, float *lb);
index b93597bf107c929f31d2d3114057852a99e303cc..64851dbf12cd6836b632b05a6abb6e688c1233ea 100644 (file)
@@ -293,6 +293,12 @@ void rgb_to_hsl(float r, float g, float b, float *lh, float *ls, float *ll)
        *ll = l;
 }
 
+/* convenience function for now */
+void rgb_to_hsl_v(const float rgb[3], float r_hsl[3])
+{
+       rgb_to_hsl(rgb[0], rgb[1], rgb[2], &r_hsl[0], &r_hsl[1], &r_hsl[2]);
+}
+
 void rgb_to_hsv_compat(float r, float g, float b, float *lh, float *ls, float *lv)
 {
        float orig_h = *lh;
index a521d0e523b88ec76875cedaddf2147374cc2e24..4a09afe2e3d1f6fbc63ff104181ce1f57f685cd4 100644 (file)
@@ -2,6 +2,8 @@
  *  \ingroup imbuf
  */
 
+#include "BLI_md5.h"  /* own include */
+
 /* md5.c - Functions to compute MD5 message digest of files or memory blocks
    according to the definition of MD5 in RFC 1321 from April 1992.
    Copyright (C) 1995 Software Foundation, Inc.
index 22597c9f8e648c78ccc00c9400e2356280f4f177..d3d8d371f60b9deb489fd3f448842394ef287822 100644 (file)
@@ -487,7 +487,7 @@ static void build_leaf(PBVH *bvh, int node_index, BBC *prim_bbc,
 
 /* Return zero if all primitives in the node can be drawn with the
  * same material (including flat/smooth shading), non-zerootherwise */
-int leaf_needs_material_split(PBVH *bvh, int offset, int count)
+static int leaf_needs_material_split(PBVH *bvh, int offset, int count)
 {
        int i, prim;
 
index 80a4da5cacef614826764ea013335d155ff4431f..3030e54eb7873104e8baf3c2c50e81fab81c674f 100644 (file)
@@ -480,7 +480,7 @@ static void voronoi_removeParabola(VoronoiProcess *process, VoronoiEvent *event)
        voronoi_checkCircle(process, p2);
 }
 
-void voronoi_finishEdge(VoronoiProcess *process, VoronoiParabola *parabola)
+static void voronoi_finishEdge(VoronoiProcess *process, VoronoiParabola *parabola)
 {
        float mx;
 
@@ -503,12 +503,12 @@ void voronoi_finishEdge(VoronoiProcess *process, VoronoiParabola *parabola)
        MEM_freeN(parabola);
 }
 
-void voronoi_clampEdgeVertex(int width, int height, float *coord, float *other_coord)
+static void voronoi_clampEdgeVertex(int width, int height, float *coord, float *other_coord)
 {
        const float corners[4][2] = {{0.0f, 0.0f},
-                                                                {width - 1, 0.0f},
-                                                                {width - 1, height - 1},
-                                                                {0.0f, height - 1}};
+                                    {width - 1, 0.0f},
+                                    {width - 1, height - 1},
+                                    {0.0f, height - 1}};
        int i;
 
        if (IN_RANGE_INCL(coord[0], 0, width - 1) && IN_RANGE_INCL(coord[1], 0, height - 1)) {
@@ -541,7 +541,7 @@ void voronoi_clampEdgeVertex(int width, int height, float *coord, float *other_c
        }
 }
 
-void voronoi_clampEdges(ListBase *edges, int width, int height, ListBase *clamped_edges)
+static void voronoi_clampEdges(ListBase *edges, int width, int height, ListBase *clamped_edges)
 {
        VoronoiEdge *edge;
 
index 5b5f4cf8b80b6eda2d8694c879cb080b56f5565c..a0b31f8d5b8b73e16d4d0f8e02decdb0a69dce74 100644 (file)
@@ -68,7 +68,7 @@ int BLI_getInstallationDir(char *str)
        return 1;
 }
 
-void RegisterBlendExtension_Fail(HKEY root)
+static void RegisterBlendExtension_Fail(HKEY root)
 {
        printf("failed\n");
        if (root)
index f0bf7e9975820dc252ff82f8c5e53d80d733ecea..16a4d8d46ec8e9d5fd57fe28622c219c343b41bc 100644 (file)
@@ -244,6 +244,9 @@ void *BLO_library_read_struct(struct FileData *fd, struct BHead *bh, const char
 
 BlendFileData *blo_read_blendafterruntime(int file, const char *name, int actualsize, struct ReportList *reports);
 
+/* internal function but we need to expose it */
+void blo_lib_link_screen_restore(struct Main *newmain, struct bScreen *curscreen, struct Scene *curscene);
+
 #ifdef __cplusplus
 } 
 #endif
index dd945dd4cc0d35a37ffc80a633f440e834d2d70a..2932fb63f43dcb7fee0094d638a8e3a955780242 100644 (file)
@@ -589,11 +589,7 @@ static void switch_endian_bh8(BHead8 *bhead)
 static void bh4_from_bh8(BHead *bhead, BHead8 *bhead8, int do_endian_swap)
 {
        BHead4 *bhead4 = (BHead4 *) bhead;
-#if defined(WIN32) && !defined(FREE_WINDOWS)
-       __int64 old;
-#else
-       long long old;
-#endif
+       int64_t old;
 
        bhead4->code = bhead8->code;
        bhead4->len = bhead8->len;
@@ -5455,7 +5451,7 @@ static void lib_link_clipboard_restore(Main *newmain)
 /* called from kernel/blender.c */
 /* used to link a file (without UI) to the current UI */
 /* note that it assumes the old pointers in UI are still valid, so old Main is not freed */
-void lib_link_screen_restore(Main *newmain, bScreen *curscreen, Scene *curscene)
+void blo_lib_link_screen_restore(Main *newmain, bScreen *curscreen, Scene *curscene)
 {
        wmWindow *win;
        wmWindowManager *wm;
@@ -6700,7 +6696,7 @@ static void do_versions_nodetree_convert_angle(bNodeTree *ntree)
        }
 }
 
-void do_versions_image_settings_2_60(Scene *sce)
+static void do_versions_image_settings_2_60(Scene *sce)
 {
        /* note: rd->subimtype is moved into individual settings now and no longer
         * exists */
index b10556af04e1ae6c024c2d7801cd1528a9ed25c9..84f6cb27b3b776bc23352c8b0a7ccdbc21101e88 100644 (file)
@@ -484,7 +484,7 @@ void dummy_exec(BMesh *bm, BMOperator *op)
 /* multiply vertex edge angle by face angle
  * this means we are not left with sharp corners between _almost_ planer faces
  * convert angles [0-PI/2] -> [0-1], multiply together, then convert back to radians. */
-float bm_vert_edge_face_angle(BMVert *v)
+static float bm_vert_edge_face_angle(BMVert *v)
 {
        const float angle = BM_vert_calc_edge_angle(v);
        /* note: could be either edge, it doesn't matter */
index 87ba216d5cfb0e62e4f887c6dadf0b259addb309..d97d901777caa6d4934d18d1819c88e4f0d9b936 100644 (file)
@@ -44,6 +44,8 @@
 
 #include "bmesh.h"
 
+#include "intern/bmesh_operators_private.h"  /* own include */
+
 #define HULL_EPSILON_FLT 0.0001f
 /* values above 0.0001 cause errors, see below for details, don't increase
  * without checking against bug [#32027] */
@@ -628,7 +630,7 @@ static void hull_tag_unused(BMesh *bm, BMOperator *op)
        }
 }
 
-void hull_tag_holes(BMesh *bm, BMOperator *op)
+static void hull_tag_holes(BMesh *bm, BMOperator *op)
 {
        BMIter iter;
        BMOIter oiter;
index e1a5ef9f905cce2acbb31e5bc941fe1c4b97ebd3..0caa766c0f0da6e183210c72ac3e9ac787000ffa 100644 (file)
@@ -487,7 +487,7 @@ void bmo_collapse_uvs_exec(BMesh *bm, BMOperator *op)
        }
 }
 
-void bmesh_find_doubles_common(BMesh *bm, BMOperator *op, BMOperator *optarget, const char *targetmapname)
+static void bmesh_find_doubles_common(BMesh *bm, BMOperator *op, BMOperator *optarget, const char *targetmapname)
 {
        BMOIter oiter;
        BMVert *v, *v2;
index e0dc5cf48c71ce89cfc8e8bb72a4287c57521611..d572a1c58639c220cf0572d666dfa97be0755620 100644 (file)
@@ -34,7 +34,7 @@
 
 #include "intern/bmesh_operators_private.h" /* own include */
 
-BMLoop *bm_edge_tag_faceloop(BMEdge *e)
+static BMLoop *bm_edge_tag_faceloop(BMEdge *e)
 {
        BMLoop *l, *l_first;
 
index 91527313972ea9154308a5f8b8a430fa38701816..98f270abd163f7fe615c718455ce973582eb5c07 100644 (file)
@@ -66,7 +66,7 @@
 
 /* ------- Bevel code starts here -------- */
 
-BME_TransData_Head *BME_init_transdata(int bufsize)
+static BME_TransData_Head *BME_init_transdata(int bufsize)
 {
        BME_TransData_Head *td;
 
@@ -85,9 +85,9 @@ void BME_free_transdata(BME_TransData_Head *td)
        MEM_freeN(td);
 }
 
-BME_TransData *BME_assign_transdata(BME_TransData_Head *td, BMesh *bm, BMVert *v,
-                                    float *co, float *org, float *vec, float *loc,
-                                    float factor, float weight, float maxfactor, float *max)
+static BME_TransData *BME_assign_transdata(BME_TransData_Head *td, BMesh *bm, BMVert *v,
+                                           float *co, float *org, float *vec, float *loc,
+                                           float factor, float weight, float maxfactor, float *max)
 {
        BME_TransData *vtd;
        int is_new = 0;
@@ -140,7 +140,7 @@ BME_TransData *BME_get_transdata(BME_TransData_Head *td, BMVert *v)
 }
 
 /* a hack (?) to use the transdata memarena to allocate floats for use with the max limits */
-float *BME_new_transdata_float(BME_TransData_Head *td)
+static float *BME_new_transdata_float(BME_TransData_Head *td)
 {
        return BLI_memarena_alloc(td->ma, sizeof(float));
 }
index 41d3c790dd0d740948fbeffb0fb06f125c8f5675..f1f1efdbd33e22390242ea24a7bc2e420c7e49cd 100644 (file)
@@ -74,6 +74,7 @@ void ImagesExporter::export_UV_Image(Image *image, bool use_copies)
 
                short image_source = image->source;
                bool  is_generated = image_source == IMA_SRC_GENERATED;
+               bool  is_packed    = image->packedfile != NULL;
 
                char export_path[FILE_MAX];
                char source_path[FILE_MAX];
@@ -83,7 +84,7 @@ void ImagesExporter::export_UV_Image(Image *image, bool use_copies)
                // Destination folder for exported assets
                BLI_split_dir_part(this->export_settings->filepath, export_dir, sizeof(export_dir));
 
-               if (is_generated || is_dirty || use_copies) {
+               if (is_generated || is_dirty || use_copies || is_packed) {
 
                        // make absolute destination path
 
@@ -96,7 +97,7 @@ void ImagesExporter::export_UV_Image(Image *image, bool use_copies)
                        BLI_make_existing_file(export_path);
                }
 
-               if (is_generated || is_dirty) {
+               if (is_generated || is_dirty || is_packed) {
 
                        // This image in its current state only exists in Blender memory.
                        // So we have to export it. The export will keep the image state intact,
index 8cd8cfaea51db7ae8807b40bd30026a3a13fe5ab..5e0459bea903339a2d0ceb361f89a865ffeadee3 100644 (file)
@@ -1086,7 +1086,7 @@ short delete_keyframe(ReportList *reports, ID *id, bAction *act, const char grou
  *     The flag argument is used for special settings that alter the behavior of
  *     the keyframe deletion. These include the quick refresh options.
  */
-short clear_keyframe(ReportList *reports, ID *id, bAction *act, const char group[], const char rna_path[], int array_index, short UNUSED(flag))
+static short clear_keyframe(ReportList *reports, ID *id, bAction *act, const char group[], const char rna_path[], int array_index, short UNUSED(flag))
 {
        AnimData *adt = BKE_animdata_from_id(id);
        PointerRNA id_ptr, ptr;
index e9424a08b0cb6382e141fa9c2ba00431ed33595c..b1a613bef5d82b4ef8a76b27ca467e3e02c0330b 100644 (file)
@@ -74,6 +74,7 @@
 #include "ED_mesh.h"
 #include "ED_screen.h"
 #include "ED_object.h"
+#include "ED_util.h"  /* clipboard */
 
 #include "UI_interface.h"
 #include "UI_resources.h"
@@ -1049,7 +1050,7 @@ static void pose_copy_menu(Scene *scene)
 /* Global copy/paste buffer for pose - cleared on start/end session + before every copy operation */
 static bPose *g_posebuf = NULL;
 
-void free_posebuf(void) 
+void ED_clipboard_posebuf_free(void)
 {
        if (g_posebuf) {
                bPoseChannel *pchan;
@@ -1225,7 +1226,7 @@ static int pose_copy_exec(bContext *C, wmOperator *op)
        }
 
        /* free existing pose buffer */
-       free_posebuf();
+       ED_clipboard_posebuf_free();
        
        /* sets chan->flag to POSE_KEY if bone selected, then copy those bones to the buffer */
        set_pose_keys(ob);  
index 8ebf932fd966ed0c9d5741d57129ba2babe5b374..dc40b687dfda13ee817cba519033a94a461f94a7 100644 (file)
@@ -53,14 +53,14 @@ void ED_keymap_mask(struct wmKeyConfig *keyconf);
 void ED_operatormacros_mask(void);
 
 /* mask_draw.c */
-void ED_mask_draw(const bContext *C, const char draw_flag, const char draw_type);
+void ED_mask_draw(const struct bContext *C, const char draw_flag, const char draw_type);
 void ED_mask_draw_region(struct Mask *mask, struct ARegion *ar,
                          const char draw_flag, const char draw_type,
                          const int width_i, const int height_i,
                          const float aspx, const float aspy,
                          const short do_scale_applied, const short do_post_draw,
                          float stabmat[4][4],
-                         const bContext *C);
+                         const struct bContext *C);
 
 void ED_mask_draw_frames(struct Mask *mask, struct ARegion *ar, const int cfra, const int sfra, const int efra);
 
index 7807f06594e20aa786f5fac4b20fc27079853723..84fd5332316fc517fcc904a461f7caefdefc5ef1 100644 (file)
@@ -36,7 +36,7 @@ void ED_sequencer_deselect_all(struct Scene *scene);
 
 int ED_space_sequencer_maskedit_mask_poll(struct bContext *C);
 int ED_space_sequencer_check_show_maskedit(struct SpaceSeq *sseq, struct Scene *scene);
-int ED_space_sequencer_maskedit_poll(bContext *C);
+int ED_space_sequencer_maskedit_poll(struct bContext *C);
 
 void ED_operatormacros_sequencer(void);
 
index e10f049d0bc098c45a80a5c46c56449c8f5360f8..d0ca079b8c9200daec0810cd7aa18d3d4cf98c05 100644 (file)
@@ -84,6 +84,8 @@ void crazyspace_set_quats_mesh(struct Mesh *me, float *origcos, float *mappedcos
 int sculpt_get_first_deform_matrices(struct Scene *scene, struct Object *ob, float (**deformmats)[3][3], float (**deformcos)[3]);
 void crazyspace_build_sculpt(struct Scene *scene, struct Object *ob, float (**deformmats)[3][3], float (**deformcos)[3]);
 
+/* cut-paste buffer free */
+void ED_clipboard_posebuf_free(void);
 
 /* ************** XXX OLD CRUFT WARNING ************* */
 
index 72779234bae466f88cdb8656a23276837aba84c6..ded5887f7f2ad19d832c512a21a33a1c0b3ba3e5 100644 (file)
@@ -912,7 +912,7 @@ static void UI_OT_editsource(wmOperatorType *ot)
  * Note: this includes utility functions and button matching checks.
  *       this only works in conjunction with a py operator! */
 
-void edittranslation_find_po_file(const char *root, const char *uilng, char *path, const size_t maxlen)
+static void edittranslation_find_po_file(const char *root, const char *uilng, char *path, const size_t maxlen)
 {
        char tstr[32]; /* Should be more than enough! */
        /* First, full lang code. */
index d2b0ddd4e7e94f326c8db1e5c3017f521e8da8f1..f2a0532932daa7cd6ee198739d64774ff6f53279 100644 (file)
@@ -34,6 +34,8 @@
 #include "WM_types.h"
 #include "WM_api.h"
 
+#include "io_ops.h"  /* own include */
+
 void ED_operatortypes_io(void) 
 {
 #ifdef WITH_COLLADA
index 6124947e3b9055908718796654a528323599c3b9..561ad004a1d04b8fc59183370759204c6c41729b 100644 (file)
@@ -48,6 +48,7 @@
 
 #include "ED_anim_api.h"
 #include "ED_keyframes_edit.h"
+#include "ED_mask.h"  /* own include */
 
 /* ***************************************** */
 /* NOTE ABOUT THIS FILE:
index d90735ca5ac1922f313080042ffd5d49a71f6885..d73bbbabf84a925c8e5e8b7e6218ad3dc0d5f935 100644 (file)
@@ -198,7 +198,7 @@ float ED_object_new_primitive_matrix(bContext *C, Object *obedit,
 
 /********************* Add Object Operator ********************/
 
-void view_align_update(struct Main *UNUSED(main), struct Scene *UNUSED(scene), struct PointerRNA *ptr)
+static void view_align_update(struct Main *UNUSED(main), struct Scene *UNUSED(scene), struct PointerRNA *ptr)
 {
        RNA_struct_idprops_unset(ptr, "rotation");
 }
index f95b07bd71e0d62d002d319aac25c34180322cc3..099d868a0ad55a0f6967b4f73a9865001a1ba60b 100644 (file)
@@ -782,7 +782,7 @@ static void fluidbake_endjob(void *customdata)
        }
 }
 
-int runSimulationCallback(void *data, int status, int frame)
+static int runSimulationCallback(void *data, int status, int frame)
 {
        FluidBakeJob *fb = (FluidBakeJob *)data;
        elbeemSimulationSettings *settings = fb->settings;
@@ -1095,7 +1095,7 @@ static int fluidsimBake(bContext *C, ReportList *reports, Object *fsDomain, shor
        return 1;
 }
 
-void fluidsimFreeBake(Object *UNUSED(ob))
+static void UNUSED_FUNCTION(fluidsimFreeBake)(Object *UNUSED(ob))
 {
        /* not implemented yet */
 }
index 6f51c5a98e688bf971d84ce6235b0048a28bd42d..64430a263f08d24e04944a55ee50e19db105116b 100644 (file)
@@ -5258,7 +5258,7 @@ void PAINT_OT_image_paint(wmOperatorType *ot)
        RNA_def_collection_runtime(ot->srna, "stroke", &RNA_OperatorStrokeElement, "Stroke", "");
 }
 
-int get_imapaint_zoom(bContext *C, float *zoomx, float *zoomy)
+static int get_imapaint_zoom(bContext *C, float *zoomx, float *zoomy)
 {
        RegionView3D *rv3d = CTX_wm_region_view3d(C);
 
index cc71be4938ecc8f3c95ea2e3bddc4d5fe9ae72f0..39a95300d5de56af1eaf84af405f38c0167609d6 100644 (file)
@@ -602,7 +602,7 @@ static void ed_keymap_paint_brush_radial_control(wmKeyMap *keymap, const char *p
        }
 }
 
-void paint_partial_visibility_keys(wmKeyMap *keymap)
+static void paint_partial_visibility_keys(wmKeyMap *keymap)
 {
        wmKeyMapItem *kmi;
        
index b53edeadb5123d7740de8fab5f21a32a67f21fa5..7657f78596a6b5d60ae27a02789405f0c3d74ab3 100644 (file)
@@ -254,7 +254,10 @@ static int paint_space_stroke(bContext *C, wmOperator *op, wmEvent *event, const
                                pressure = event_tablet_data(event, NULL);
                        
                        if (pressure > FLT_EPSILON) {
-                               scale = (BKE_brush_size_get(scene, stroke->brush) * pressure * stroke->brush->spacing / 50.0f) / length;
+                               /* brushes can have a minimum size of 1.0 but with pressure it can be smaller then a pixel
+                                * causing very high step sizes, hanging blender [#32381] */
+                               const float size_clamp = maxf(1.0f, BKE_brush_size_get(scene, stroke->brush) * pressure);
+                               scale = (size_clamp * stroke->brush->spacing / 50.0f) / length;
                                if (scale > FLT_EPSILON) {
                                        mul_v2_fl(vec, scale);
 
index ba440e982905a7651d30b37954662e3880f9aded..fd5044afc4483c57fcd1f2b685d31733fae5e681 100644 (file)
@@ -257,7 +257,7 @@ static void do_shared_vertex_tesscol(Mesh *me)
        MEM_freeN(scolmain);
 }
 
-void do_shared_vertexcol(Mesh *me, int do_tessface)
+static void do_shared_vertexcol(Mesh *me, int do_tessface)
 {
        const int use_face_sel = (me->editflag & ME_EDIT_PAINT_MASK);
        MPoly *mp;
index fdce8ec04a4361dbf6fce6961ad84a5f97bb5c12..0bcccd9479c13bcf54a917130a6c6abccbed137b 100644 (file)
@@ -156,8 +156,8 @@ typedef struct Temp_UvData {
 
 
 
-void HC_relaxation_iteration_uv(BMEditMesh *em, UvSculptData *sculptdata, float mouse_coord[2],
-                                float alpha, float radius, float aspectRatio)
+static void HC_relaxation_iteration_uv(BMEditMesh *em, UvSculptData *sculptdata, float mouse_coord[2],
+                                       float alpha, float radius, float aspectRatio)
 {
        Temp_UVData *tmp_uvdata;
        float diff[2];
index 91501971d9d50a014f5499f60266e35e9c90e73e..7b070fde6bad24e83a7bab9c969d199f4fc50469 100644 (file)
@@ -94,7 +94,7 @@ static void tracking_segment_point_cb(void *UNUSED(userdata), MovieTrackingTrack
        glVertex2f(scene_framenr, val);
 }
 
-void tracking_segment_start_cb(void *userdata, MovieTrackingTrack *track, int coord)
+static void tracking_segment_start_cb(void *userdata, MovieTrackingTrack *track, int coord)
 {
        static float colors[2][3] = {{1.0f, 0.0f, 0.0f},
                                     {0.0f, 1.0f, 0.0f}};
@@ -116,7 +116,7 @@ void tracking_segment_start_cb(void *userdata, MovieTrackingTrack *track, int co
        glBegin(GL_LINE_STRIP);
 }
 
-void tracking_segment_end_cb(void *UNUSED(userdata))
+static void tracking_segment_end_cb(void *UNUSED(userdata))
 {
        glEnd();
 
index 71dcd32688754e8745e5884647d1f80598aaad81..f48d4e8d94678babee26733e47b907eb2adb34cd 100644 (file)
@@ -130,7 +130,7 @@ static void find_nearest_tracking_segment_cb(void *userdata, MovieTrackingTrack
        copy_v2_v2(data->prev_co, co);
 }
 
-void find_nearest_tracking_segment_end_cb(void *userdata)
+static void find_nearest_tracking_segment_end_cb(void *userdata)
 {
        MouseSelectUserData *data = userdata;
 
index 616587b0b19aaffeaa4f2360a17abf539654800d..16804c5a1c66b1c5ed2bfc85136f1afe8f1377ba 100644 (file)
@@ -192,7 +192,7 @@ int space_image_main_area_poll(bContext *C)
 }
 
 /* For IMAGE_OT_curves_point_set to avoid sampling when in uv smooth mode or editmode */
-int space_image_main_area_not_uv_brush_poll(bContext *C)
+static int space_image_main_area_not_uv_brush_poll(bContext *C)
 {
        SpaceImage *sima = CTX_wm_space_image(C);
        Scene *scene = CTX_data_scene(C);
index 775dd5445c3c2c8110cacfce6d63379057040770..2861d17b350f385d6fca461086025274562c3d78 100644 (file)
@@ -1170,7 +1170,7 @@ static int nlaedit_bake_exec(bContext *C, wmOperator *UNUSED(op))
        return OPERATOR_FINISHED;
 }
 
-void NLA_OT_bake(wmOperatorType *ot)
+static void NLA_OT_bake(wmOperatorType *ot)
 {
        /* identifiers */
        ot->name = "Bake Strips";
index 4fae060deb90b3f6de6ad01d82c5431a4f664d47..1f266c98020b761c3a618968ce19fd813fb0a900 100644 (file)
@@ -893,7 +893,7 @@ static void node_draw_group(const bContext *C, ARegion *ar, SpaceNode *snode, bN
        }
 }
 
-void node_uifunc_group(uiLayout *layout, bContext *C, PointerRNA *ptr)
+static void node_uifunc_group(uiLayout *layout, bContext *C, PointerRNA *ptr)
 {
        uiTemplateIDBrowse(layout, C, ptr, "node_tree", NULL, NULL, NULL);
 }
@@ -2388,7 +2388,7 @@ static void node_composit_buts_bokehblur(uiLayout *layout, bContext *UNUSED(C),
        uiItemR(layout, ptr, "blur_max", 0, NULL, ICON_NONE);
 }
 
-void node_composit_backdrop_viewer(SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
+static void node_composit_backdrop_viewer(SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
 {
 //     node_composit_backdrop_canvas(snode, backdrop, node, x, y);
        if (node->custom1 == 0) {
@@ -2408,7 +2408,7 @@ void node_composit_backdrop_viewer(SpaceNode *snode, ImBuf *backdrop, bNode *nod
        }
 }
 
-void node_composit_backdrop_boxmask(SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
+static void node_composit_backdrop_boxmask(SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
 {
        NodeBoxMask *boxmask = node->storage;
        const float backdropWidth = backdrop->x;
@@ -2449,7 +2449,7 @@ void node_composit_backdrop_boxmask(SpaceNode *snode, ImBuf *backdrop, bNode *no
        glEnd();
 }
 
-void node_composit_backdrop_ellipsemask(SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
+static void node_composit_backdrop_ellipsemask(SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
 {
        NodeEllipseMask *ellipsemask = node->storage;
        const float backdropWidth = backdrop->x;
index 1522528a8ac1783bf131fb6adf066049b0195a45..0601d7c105f6d63f6923eb9d17df27ab423e7191 100644 (file)
@@ -44,6 +44,7 @@
 #include "BKE_screen.h"
 #include "BKE_node.h"
 
+#include "ED_space_api.h"
 #include "ED_render.h"
 #include "ED_screen.h"
 #include "ED_node.h"
index aa6bacf88363de8ee18663a7f7d2ce950b07be65..dc5cf98f5151bf9ce632c7e74c9369fb001cbb01 100644 (file)
@@ -43,6 +43,7 @@
 #include "WM_api.h"
 #include "WM_types.h"
 
+#include "ED_sequencer.h"
 #include "ED_markers.h"
 #include "ED_transform.h" /* transform keymap */
 
index c357a05936af3bcdf331517e7a5e2291e9b609dc..3c3489115a458b1da63476b85ae55df0158bdc75 100644 (file)
@@ -211,7 +211,7 @@ static int sample_cancel(bContext *C, wmOperator *op)
        return OPERATOR_CANCELLED;
 }
 
-int sample_poll(bContext *C)
+static int sample_poll(bContext *C)
 {
        return BKE_sequencer_editing_get(CTX_data_scene(C), FALSE) != NULL;
 }
index 2e542737494828a5f8076cddf5a0827bfa08e2f4..e7014bf41d55fb4ff098d64e242f59a0f6562632 100644 (file)
@@ -179,7 +179,7 @@ static DMDrawOption draw_mesh_face_select__drawFaceOptsInv(void *userData, int i
                return DM_DRAW_OPTION_SKIP;
 }
 
-void draw_mesh_face_select(RegionView3D *rv3d, Mesh *me, DerivedMesh *dm)
+static void draw_mesh_face_select(RegionView3D *rv3d, Mesh *me, DerivedMesh *dm)
 {
        drawMeshFaceSelect_userData data;
 
@@ -780,8 +780,8 @@ static int compareDrawOptionsEm(void *userData, int cur_index, int next_index)
        return 1;
 }
 
-void draw_mesh_textured_old(Scene *scene, View3D *v3d, RegionView3D *rv3d,
-                            Object *ob, DerivedMesh *dm, const int draw_flags)
+static void draw_mesh_textured_old(Scene *scene, View3D *v3d, RegionView3D *rv3d,
+                                   Object *ob, DerivedMesh *dm, const int draw_flags)
 {
        Mesh *me = ob->data;
        
index 5712144caf1d7b28334bea31370c22940ae42b98..166a62562fde12122d6e666ad7fdcc68cd533e80 100644 (file)
@@ -646,7 +646,7 @@ static void do_lasso_select_meta(ViewContext *vc, int mcords[][2], short moves,
        }
 }
 
-int do_paintvert_box_select(ViewContext *vc, rcti *rect, int select, int extend)
+static int do_paintvert_box_select(ViewContext *vc, rcti *rect, int select, int extend)
 {
        Mesh *me;
        MVert *mvert;
index 5008c35e46a523a61f2b5d9832797a3832b3df78..06da1c8bfea3071e401b71239c3cfdb03dac6558 100644 (file)
@@ -2836,7 +2836,7 @@ static int uv_lasso_select_exec(bContext *C, wmOperator *op)
        return OPERATOR_PASS_THROUGH;
 }
 
-void UV_OT_select_lasso(wmOperatorType *ot)
+static void UV_OT_select_lasso(wmOperatorType *ot)
 {
        ot->name = "Lasso Select UV";
        ot->description = "Select UVs using lasso selection";
index 5e38c31f4c7ca21f6bff0f4d614b6439e36905ef..9ce5d0e30dad93c8de377d5b4f096ba714396be5 100644 (file)
@@ -109,7 +109,7 @@ typedef struct DitherContext {
        float f;
 } DitherContext;
 
-DitherContext *create_dither_context(int w, float factor)
+static DitherContext *create_dither_context(int w, float factor)
 {
        DitherContext *di;
        int i;
index 6b960a18277a7ee51a55485900cedcea603c3ec8..7a8f8fcc7529b2e50075167b211ceac983644500 100644 (file)
@@ -385,7 +385,7 @@ static void indexer_dv_delete(anim_index_builder *idx)
        MEM_freeN(This);
 }
 
-void IMB_indexer_dv_new(anim_index_builder *idx)
+static void UNUSED_FUNCTION(IMB_indexer_dv_new)(anim_index_builder *idx)
 {
        indexer_dv_context *rv = MEM_callocN(
                sizeof(indexer_dv_context), "index_dv builder context");
index 6d1e3c16631a17417128be6ab962a625c7fe123b..833671e3f2f3240bcd6a1d133f39434e45db8a6e 100644 (file)
@@ -225,7 +225,7 @@ static int isqtime(const char *name)
 
 static char ffmpeg_last_error[1024];
 
-void ffmpeg_log_callback(void *ptr, int level, const char *format, va_list arg)
+static void ffmpeg_log_callback(void *ptr, int level, const char *format, va_list arg)
 {
        if (ELEM(level, AV_LOG_FATAL, AV_LOG_ERROR)) {
                size_t n = BLI_vsnprintf(ffmpeg_last_error, sizeof(ffmpeg_last_error), format, arg);
index 22b1e33e2a6e0f569f5521757c833271b3f26674..25a2a61d8e3444c321665f90a3404512c97a220e 100644 (file)
@@ -185,7 +185,7 @@ static float get_ob2ob_distance(const Object *ob, const Object *obr)
 /**
  * Maps distances to weights, with an optional "smoothing" mapping.
  */
-void do_map(float *weights, const int nidx, const float min_d, const float max_d, short mode)
+static void do_map(float *weights, const int nidx, const float min_d, const float max_d, short mode)
 {
        const float range_inv = 1.0f / (max_d - min_d); /* invert since multiplication is faster */
        unsigned int i = nidx;
index fdbe82efeda295eafab475d04f8e9f41e24fcd6a..59a4d6818c83925cb3d9436bd7e57a55257645b9 100644 (file)
@@ -349,7 +349,7 @@ void node_group_edit_clear(bNode *node)
                        nodeGroupEditClear(inode);
 }
 
-void node_group_link(bNodeTree *ntree, bNodeSocket *sock, int in_out)
+static void UNUSED_FUNCTION(node_group_link)(bNodeTree *ntree, bNodeSocket *sock, int in_out)
 {
        node_group_expose_socket(ntree, sock, in_out);
 }
index 9f9caef14e2b084ae5b641e7968e01743dcfc3f6..95104df5fedc5b53cb05d2c7f0e7d8d82441308a 100644 (file)
@@ -67,7 +67,7 @@ ListBase node_internal_connect_default(struct bNodeTree *ntree, struct bNode *no
 #endif
 
 // this is needed for inlining behavior
-#if defined _WIN32
+#if defined _MSC_VER
 #   define DO_INLINE __inline
 #elif defined (__sun) || defined (__sun__)
 #   define DO_INLINE
index 7d8c4ce232c140ac85628a8cd0f87b21f4e209e4..e938e6fc419c408ee092918113b110a94df20b62 100644 (file)
@@ -61,6 +61,8 @@
 
 #include "node_util.h"
 
+#include "NOD_texture.h"
+
 #include "BLI_math.h"
 #include "BLI_blenlib.h"
 #include "BLI_rand.h"
index c16b1fb901fc614b54d2f0437e2dbb9d5e79d961..fb5b94249e6b131aafb189172cb02a7a2727219a 100644 (file)
@@ -42,6 +42,8 @@
 
 #include "bmesh.h"
 
+#include "bmesh_py_ops.h"  /* own include */
+
 #include "bmesh_py_types.h"
 
 #include "bmesh_py_utils.h" /* own include */
@@ -69,7 +71,7 @@ typedef struct {
        const char *opname;
 } BPy_BMeshOpFunc;
 
-PyObject *bpy_bmesh_op_CreatePyObject(const char *opname)
+static PyObject *bpy_bmesh_op_CreatePyObject(const char *opname)
 {
        BPy_BMeshOpFunc *self = PyObject_New(BPy_BMeshOpFunc, &bmesh_op_Type);
 
index 05583e133dc0840eab6672b97eba85fd4f64ab76..604166eed3c4bc1514888c100ae6fd6ec827b097 100644 (file)
@@ -71,6 +71,7 @@ set(SRC
        bpy_app_handlers.h
        bpy_driver.h
        bpy_intern_string.h
+       bpy_library.h
        bpy_operator.h
        bpy_operator_wrap.h
        bpy_props.h
index 0f0250fb8d57ff71deff17ef9352809166e7da2c..f2222825c42acc0524fff4605a72dae1a5224611 100644 (file)
@@ -37,6 +37,7 @@
 #include "bpy_rna.h"
 #include "bpy_app.h"
 #include "bpy_props.h"
+#include "bpy_library.h"
 #include "bpy_operator.h"
 
 #include "BLI_path_util.h"
@@ -238,7 +239,6 @@ static PyObject *bpy_import_test(const char *modname)
 void BPy_init_modules(void)
 {
        extern BPy_StructRNA *bpy_context_module;
-       extern int bpy_lib_init(PyObject *);
        PointerRNA ctx_ptr;
        PyObject *mod;
 
@@ -273,7 +273,7 @@ void BPy_init_modules(void)
        PyModule_AddObject(mod, "StructMetaPropGroup", (PyObject *)&pyrna_struct_meta_idprop_Type);
 
        /* needs to be first so bpy_types can run */
-       bpy_lib_init(mod);
+       BPY_library_module(mod);
 
        bpy_import_test("bpy_types");
        PyModule_AddObject(mod, "data", BPY_rna_module()); /* imports bpy_types by running this */
index 2412d65aa2104f37fa7c584cf90d9a4d33c09a30..fe877d161ff3e727261ed8cb7aeff8b848dd27e0 100644 (file)
  *  \ingroup pythonintern
  */
 
+#ifndef __BPY_H__
+
 void BPy_init_modules(void);
 extern PyObject *bpy_package_py;
 
 /* bpy_interface_atexit.c */
 void BPY_atexit_register(void);
 void BPY_atexit_unregister(void);
+
+#endif  /* __BPY_H__ */
index 44bba4c098f70b82eb138a36e0991b657218c80c..68fd9a997123ed01166db502f08fd2ab6a5db1cc 100644 (file)
 
 #include <Python.h>
 #include "BLI_utildefines.h"
-#include "BLI_callbacks.h"
 
-#include "RNA_types.h"
-#include "RNA_access.h"
-#include "bpy_rna.h"
+#include "bpy_app_ffmpeg.h"
 
 #ifdef WITH_FFMPEG
 #include <libavcodec/avcodec.h>
index bab5a83a6ed51cca26f13acd8ffe13cd28b317d0..4d7f2080bbc477346b0900c48db18b0baa0b2f98 100644 (file)
@@ -37,6 +37,8 @@
 #include "bpy_rna.h"
 #include "bpy_app_handlers.h"
 
+#include "BPY_extern.h"
+
 void bpy_app_generic_callback(struct Main *main, struct ID *id, void *arg);
 
 static PyTypeObject BlenderAppCbType;
index db97d361c7324248f13cb83c964a96db71d0601b..13d8cedf9076564eb9507dc089c368d0ca106a14 100644 (file)
@@ -32,6 +32,7 @@
 #include <Python.h>
 
 #include "bpy_util.h"
+#include "bpy.h"  /* own include */
 
 #include "WM_api.h"
 
index 40ec8136eb7f4a95a69e4a5a1ee6868fefcbb916..7571fe0f75e7ba8783bd186fafccd02561b9be0b 100644 (file)
@@ -55,6 +55,7 @@
 #include "DNA_space_types.h" /* FILE_LINK, FILE_RELPATH */
 
 #include "bpy_util.h"
+#include "bpy_library.h"
 
 #ifdef USE_RNA_DATABLOCKS
 #  include "bpy_rna.h"
@@ -426,7 +427,7 @@ static PyObject *bpy_lib_dir(BPy_Library *self)
 }
 
 
-int bpy_lib_init(PyObject *mod_par)
+int BPY_library_module(PyObject *mod_par)
 {
        static PyMethodDef load_meth = {"load", (PyCFunction)bpy_lib_load,
                                        METH_STATIC | METH_VARARGS | METH_KEYWORDS,
diff --git a/source/blender/python/intern/bpy_library.h b/source/blender/python/intern/bpy_library.h
new file mode 100644 (file)
index 0000000..1b68007
--- /dev/null
@@ -0,0 +1,32 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/python/intern/bpy_library.h
+ *  \ingroup pythonintern
+ */
+
+#ifndef __BPY_LIBRARY_H__
+#define __BPY_LIBRARY_H__
+
+int BPY_library_module(PyObject *);
+
+#endif  /* __BPY_LIBRARY_H__ */
index 4ae8e821298678d35799288aba6341a178f105c8..8ec8c4c41bacdbbfe7a50b0755ace6ccad29467a 100644 (file)
@@ -37,6 +37,8 @@
 
 #include "RNA_types.h"
 
+#include "BPY_extern.h"
+
 #include "bpy_rna.h"
 #include "bpy_rna_anim.h"
 #include "bpy_props.h"
@@ -45,7 +47,7 @@
 #include "bpy_intern_string.h"
 
 #ifdef USE_PYRNA_INVALIDATE_WEAKREF
-#include "MEM_guardedalloc.h"
+#  include "MEM_guardedalloc.h"
 #endif
 
 #include "BLI_dynstr.h"
@@ -55,7 +57,7 @@
 #include "BLI_utildefines.h"
 
 #ifdef USE_PYRNA_INVALIDATE_WEAKREF
-#include "BLI_ghash.h"
+#  include "BLI_ghash.h"
 #endif
 
 #include "RNA_enum_types.h"
@@ -78,7 +80,7 @@
 #include "../generic/py_capi_utils.h"
 
 #ifdef WITH_INTERNATIONAL
-#include "BLF_translation.h"
+#  include "BLF_translation.h"
 #endif
 
 #define USE_PEDANTIC_WRITE
@@ -2150,10 +2152,10 @@ static PyObject *pyrna_prop_collection_subscript_str(BPy_PropertyRNA *self, cons
  * -1: exception set
  *  0: not found
  *  1: found */
-int pyrna_prop_collection_subscript_str_lib_pair_ptr(BPy_PropertyRNA *self, PyObject *key,
-                                                     const char *err_prefix, const short err_not_found,
-                                                     PointerRNA *r_ptr
-                                                     )
+static int pyrna_prop_collection_subscript_str_lib_pair_ptr(BPy_PropertyRNA *self, PyObject *key,
+                                                            const char *err_prefix, const short err_not_found,
+                                                            PointerRNA *r_ptr
+                                                            )
 {
        char *keyname;
 
@@ -5908,7 +5910,7 @@ PyTypeObject pyrna_prop_collection_iter_Type = {
        NULL
 };
 
-PyObject *pyrna_prop_collection_iter_CreatePyObject(PointerRNA *ptr, PropertyRNA *prop)
+static PyObject *pyrna_prop_collection_iter_CreatePyObject(PointerRNA *ptr, PropertyRNA *prop)
 {
        BPy_PropertyCollectionIterRNA *self = PyObject_New(BPy_PropertyCollectionIterRNA, &pyrna_prop_collection_iter_Type);
 
index 113367788b66c89b91da5272460ba4d9ddf6fd6a..1fb4b116872eecbf6a1863dcb7a8bf4de980fc06 100644 (file)
@@ -175,6 +175,10 @@ PyObject *BPY_rna_types(void);
 PyObject *pyrna_struct_CreatePyObject(PointerRNA *ptr);
 PyObject *pyrna_prop_CreatePyObject(PointerRNA *ptr, PropertyRNA *prop);
 
+/* extern'd by other modules which don't deal closely with RNA */
+PyObject *pyrna_id_CreatePyObject(struct ID *id);
+int       pyrna_id_FromPyObject(PyObject *obj, struct ID **id);
+
 /* operators also need this to set args */
 int pyrna_pydict_to_props(PointerRNA *ptr, PyObject *kw, int all_args, const char *error_prefix);
 PyObject *pyrna_prop_to_py(PointerRNA *ptr, PropertyRNA *prop);
index 7e2da5b1818a62dc52453cd39debb28033016cc9..69fe0c48a41707bd3778cfdd39c2b52092d5c341 100644 (file)
@@ -74,8 +74,7 @@ static struct PyModuleDef gpumodule = {
        NULL, NULL, NULL, NULL, NULL
 };
 
-PyMODINIT_FUNC
-PyInit_gpu(void)
+static PyObject *PyInit_gpu(void)
 {
        PyObject *m;
 
index 50d2e88f210cf672731170171448d4a89ae9d8b9..e0508359e136052e28d7a76e1eeabda988a05dad 100644 (file)
  *  \ingroup pythonintern
  */
 
+#include "BLI_utildefines.h"
+
+#include "BPY_extern.h"
 
 /* python, will come back */
 //void BPY_script_exec(void) {}
 //void BPY_python_start(void) {}
 //void BPY_text_free_code(void) {}
-void BPY_pyconstraint_exec(void) {}
-void BPY_pyconstraint_target(void) {}
-int BPY_is_pyconstraint(void) { return 0;}
-void BPY_pyconstraint_update(void) {}
+void BPY_pyconstraint_exec(struct bPythonConstraint *UNUSED(con), struct bConstraintOb *UNUSED(cob), struct ListBase *UNUSED(targets)) {}
+void BPY_pyconstraint_target(struct bPythonConstraint *UNUSED(con), struct bConstraintTarget *UNUSED(ct)) {}
+int BPY_is_pyconstraint(struct Text *UNUSED(text)) { return 0;}
+void BPY_pyconstraint_update(struct Object *UNUSED(owner), struct bConstraint *UNUSED(con)) {}
index e4ee19d8ed26b0822b9b06ace03bdf7eabd787bc..e873111e6bf8d6e348c7f038da7de5e9e03e3c4b 100644 (file)
@@ -139,5 +139,10 @@ void zbufclipwire(struct ZSpan *zspan, int obi, int zvlnr, int ec,
 void zbuf_make_winmat(Render *re, float winmat[][4]);
 void zbuf_render_project(float winmat[][4], const float co[3], float ho[4]);
 
+/* sould not really be exposed, bad! */
+void hoco_to_zco(ZSpan *zspan, float zco[3], const float hoco[4]);
+void zspan_scanconvert_strand(ZSpan *zspan, void *handle, float *v1, float *v2, float *v3, void (*func)(void *, int, int, float, float, float) );
+void zbufsinglewire(ZSpan *zspan, int obi, int zvlnr, const float ho1[4], const float ho2[4]);
+
 #endif
 
index 2d694a3e274f238847597af262bad4a8a9ea7de6..51e5b30a31cd54446cb63403f778291aae4a1bcd 100644 (file)
 #include "zbuf.h"
 #include "sunsky.h"
 
+#include "RE_render_ext.h"
 
 /* 10 times larger than normal epsilon, test it on default nurbs sphere with ray_transp (for quad detection) */
 /* or for checking vertex normal flips */
index f7e3a9ddc39c352639f26814c75eb4d510b64fd2..6d22d8991b404764dcf44d82cbaffd82ead47748 100644 (file)
@@ -83,6 +83,8 @@
 
 #include "renderdatabase.h" /* needed for UV */
 
+#include "RE_render_ext.h"
+
 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
 /* defined in pipeline.c, is hardcopy of active dynamic allocated Render */
 /* only to be used here in this file, it's for speed */
@@ -1260,18 +1262,19 @@ int multitex_nodes(Tex *tex, float *texvec, float *dxt, float *dyt, int osatex,
 }
 
 /* this is called for surface shading */
-int multitex_mtex(ShadeInput *shi, MTex *mtex, float *texvec, float *dxt, float *dyt, TexResult *texres)
+static int multitex_mtex(ShadeInput *shi, MTex *mtex, float *texvec, float *dxt, float *dyt, TexResult *texres)
 {
-       Tex *tex= mtex->tex;
+       Tex *tex = mtex->tex;
 
        if (tex->use_nodes && tex->nodetree) {
                /* stupid exception here .. but we have to pass shi and mtex to
                 * textures nodes for 2d mapping and color management for images */
                return ntreeTexExecTree(tex->nodetree, texres, texvec, dxt, dyt, shi->osatex, shi->thread,
-                       tex, mtex->which_output, R.r.cfra, (R.r.scemode & R_TEXNODE_PREVIEW) != 0, shi, mtex);
+                                       tex, mtex->which_output, R.r.cfra, (R.r.scemode & R_TEXNODE_PREVIEW) != 0, shi, mtex);
        }
-       else
+       else {
                return multitex(mtex->tex, texvec, dxt, dyt, shi->osatex, texres, shi->thread, mtex->which_output);
+       }
 }
 
 /* Warning, if the texres's values are not declared zero, check the return value to be sure
index 51be519d5b80bd8d8edc4a2d8831c901f890ced4..dc3225b7f09891f6a3f536e773633cc896891f60 100644 (file)
 #include "strand.h"
 #include "zbuf.h"
 
-/* to be removed */
-void hoco_to_zco(ZSpan *zspan, float *zco, float *hoco);
-void zspan_scanconvert_strand(ZSpan *zspan, void *handle, float *v1, float *v2, float *v3, void (*func)(void *, int, int, float, float, float) );
-void zbufsinglewire(ZSpan *zspan, int obi, int zvlnr, float *ho1, float *ho2);
-
 /* *************** */
 
 static float strand_eval_width(Material *ma, float strandco)
index 8c9df496dd67a44a3526a6a3027576b04b420028..b2bc635cba75ca5058c4b5f3090ebc7f3fc87ea6 100644 (file)
@@ -42,6 +42,8 @@
 
 #include "texture.h"
 
+#include "texture_ocean.h"  /* own include */
+
 
 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
 /* defined in pipeline.c, is hardcopy of active dynamic allocated Render */
index de9572bf57bd6ccde424ef5828882085cd74b7fe..bf6962d00878e7799b271142983dbc6ed250bffd 100644 (file)
@@ -3476,7 +3476,7 @@ void zbuffer_abuf_shadow(Render *re, LampRen *lar, float winmat[][4], APixstr *A
 /* speed pointer NULL = sky, we clear */
 /* else if either alpha is full or no solid was filled in: copy speed */
 /* else fill in minimum speed */
-void add_transp_speed(RenderLayer *rl, int offset, float *speed, float alpha, intptr_t *rdrect)
+static void add_transp_speed(RenderLayer *rl, int offset, float speed[4], float alpha, intptr_t *rdrect)
 {
        RenderPass *rpass;
        
@@ -3525,7 +3525,7 @@ static void add_transp_obindex(RenderLayer *rl, int offset, Object *ob)
 
 /* ONLY OSA! merge all shaderesult samples to one */
 /* target should have been cleared */
-void merge_transp_passes(RenderLayer *rl, ShadeResult *shr)
+static void merge_transp_passes(RenderLayer *rl, ShadeResult *shr)
 {
        RenderPass *rpass;
        float weight= 1.0f/((float)R.osa);
@@ -3627,7 +3627,7 @@ void merge_transp_passes(RenderLayer *rl, ShadeResult *shr)
                                
 }
 
-void add_transp_passes(RenderLayer *rl, int offset, ShadeResult *shr, float alpha)
+static void add_transp_passes(RenderLayer *rl, int offset, ShadeResult *shr, float alpha)
 {
        RenderPass *rpass;
        
index ff7c8cd2ea7890f64b25de231ef4693bc53aa803..1d509a87ffe608b2783248564072190f12afc57e 100644 (file)
@@ -361,6 +361,8 @@ void                WM_progress_clear(struct wmWindow *win);
                        /* Draw (for screenshot) */
 void           WM_redraw_windows(struct bContext *C);
 
+void        WM_main_playanim(int argc, const char **argv);
+
 /* debugging only, convenience function to write on crash */
 int write_crash_blend(void);
 
index a1c46e4e6a277b5db85f8d0a49101c712eae5067..908f7e27f0b0e56c687b9946ecb4882d40fc64e2 100644 (file)
@@ -339,7 +339,6 @@ static void free_openrecent(void)
 extern void free_anim_copybuf(void);
 extern void free_anim_drivers_copybuf(void);
 extern void free_fmodifiers_copybuf(void);
-extern void free_posebuf(void);
 
 #if WIN32
 /* Read console events until there is a key event.  Also returns on any error. */
@@ -424,7 +423,7 @@ void WM_exit_ext(bContext *C, const short do_python)
        free_anim_copybuf();
        free_anim_drivers_copybuf();
        free_fmodifiers_copybuf();
-       free_posebuf();
+       ED_clipboard_posebuf_free();
        BKE_node_clipboard_clear();
 
        BLF_exit();
index 1b76e71503c45a6e2f3352c82e4aa129be842011..313fc0a819e66412593f480c463997cab84f34b7 100644 (file)
@@ -1693,7 +1693,7 @@ static void WM_OT_open_mainfile(wmOperatorType *ot)
 
 /* **************** link/append *************** */
 
-int wm_link_append_poll(bContext *C)
+static int wm_link_append_poll(bContext *C)
 {
        if (WM_operator_winactive(C)) {
                /* linking changes active object which is pretty useful in general,
index bbe5ddc72f2d42ce012b312669fbd638cfbb8122..bff40faf1d1cbc87de73f98858a37107712cc801 100644 (file)
@@ -72,6 +72,8 @@
 
 #include "wm_event_types.h"
 
+#include "WM_api.h"  /* only for WM_main_playanim */
+
 typedef struct PlayState {
 
        /* playback state */
@@ -142,7 +144,7 @@ static struct WindowStateGlobal {
        eWS_Qual qual;
 } g_WS = {NULL};
 
-void playanim_window_get_size(int *width_r, int *height_r)
+static void playanim_window_get_size(int *width_r, int *height_r)
 {
        GHOST_RectangleHandle bounds = GHOST_GetClientBounds(g_WS.ghost_window);
        *width_r = GHOST_GetWidthRectangle(bounds);
@@ -691,7 +693,7 @@ static int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr ps_void)
        return 1;
 }
 
-void playanim_window_open(const char *title, int posx, int posy, int sizex, int sizey, int start_maximized)
+static void playanim_window_open(const char *title, int posx, int posy, int sizex, int sizey, int start_maximized)
 {
        GHOST_TWindowState inital_state;
        GHOST_TUns32 scr_w, scr_h;
@@ -722,7 +724,7 @@ void playanim_window_open(const char *title, int posx, int posy, int sizex, int
 }
 
 
-void playanim(int argc, const char **argv)
+void WM_main_playanim(int argc, const char **argv)
 {
        struct ImBuf *ibuf = NULL;
        char filepath[FILE_MAX];
index b3c111984037bed6276de1e64f189611d17f9270..ab9541cf29966da459cabde63a83b0ecffcdd6d7 100644 (file)
@@ -91,7 +91,6 @@
 #include "RE_engine.h"
 #include "RE_pipeline.h"
 
-//XXX #include "playanim_ext.h"
 #include "ED_datafiles.h"
 
 #include "WM_api.h"
@@ -454,11 +453,9 @@ static int set_env(int argc, const char **argv, void *UNUSED(data))
 
 static int playback_mode(int argc, const char **argv, void *UNUSED(data))
 {
-       extern void playanim(int argc, const char **argv);
-
        /* not if -b was given first */
        if (G.background == 0) {
-               playanim(argc, argv); /* not the same argc and argv as before */
+               WM_main_playanim(argc, argv); /* not the same argc and argv as before */
                exit(0); /* 2.4x didn't do this */
        }