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 39c1474..83e094b 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 ad5e315..43cfb31 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 a7d37da..46bba23 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 6af0c64..75e3456 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 08e9b9e..729d4da 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 075c688..8cbbfc8 100644 (file)
@@ -36,7 +36,7 @@ struct OSLGlobals {
        /* use */
        bool use;
 
-       /* shading system */ 
+       /* shading system */
        OSL::ShadingSystem *ss;
        OSLRenderServices *services;
 
index a3f2c2e..f1deaa9 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 5ec8a8e..790b02a 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 c7be02c..99d8854 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 0e8ff43..c9c902f 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 3f52f9e..9e4377b 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 0a3141d..a1ae6bd 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 659d01e..875dfc8 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 a9b2920..7f7a612 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 d19c57b..cd67059 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 19dd67b..33361b9 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 51e301f..cc15cee 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 576b79f..efdb804 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 9145c4a..99b788e 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 b0de7a5..4241756 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 f47ac64..1cb29b9 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 1c6974b..fcc8b43 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 97b46d4..3564071 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 18617f0..00898b0 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 cd8b0e4..97d4c15 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 5dfecfc..4fb235a 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 bae8efa..2c0452b 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 1fa009d..b0dcad6 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 ddcba50..5e67e09 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 787def5..af5a8f5 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 ee904de..bdd9b42 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 c0c5c57..97ebc3a 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 bd25ff8..4019eba 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 7520f09..6fe5d48 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 b93597b..64851db 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 a521d0e..4a09afe 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 22597c9..d3d8d37 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 80a4da5..3030e54 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 5b5f4cf..a0b31f8 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 f0bf7e9..16a4d8d 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 dd945dd..2932fb6 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 b10556a..84f6cb2 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 87ba216..d97d901 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 e1a5ef9..0caa766 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 e0dc5cf..d572a1c 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 9152731..98f270a 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 41d3c79..f1f1efd 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 8cd8cfa..5e0459b 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 e9424a0..b1a613b 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 8ebf932..dc40b68 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 7807f06..84fd533 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 e10f049..d0ca079 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 7277923..ded5887 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 d2b0ddd..f2a0532 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 6124947..561ad00 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 d90735c..d73bbba 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 f95b07b..099d868 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 6f51c5a..64430a2 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 cc71be4..39a9530 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 b53edea..7657f78 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 ba440e9..fd5044a 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 fdce8ec..0bcccd9 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 9150197..7b070fd 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 71dcd32..f48d4e8 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 616587b..16804c5 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 775dd54..2861d17 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 4fae060..1f266c9 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 1522528..0601d7c 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 aa6bacf..dc5cf98 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 c357a05..3c34891 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 2e54273..e7014bf 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 5712144..166a625 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 5008c35..06da1c8 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 5e38c31..9ce5d0e 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 6b960a1..7a8f8fc 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 6d1e3c1..833671e 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 22b1e33..25a2a61 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 fdbe82e..59a4d68 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 9f9caef..95104df 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 7d8c4ce..e938e6f 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 c16b1fb..fb5b942 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 05583e1..604166e 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 0f0250f..f222282 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 2412d65..fe877d1 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 44bba4c..68fd9a9 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 bab5a83..4d7f208 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 db97d36..13d8ced 100644 (file)
@@ -32,6 +32,7 @@
 #include <Python.h>
 
 #include "bpy_util.h"
+#include "bpy.h"  /* own include */
 
 #include "WM_api.h"
 
index 40ec813..7571fe0 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 4ae8e82..8ec8c4c 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 1133677..1fb4b11 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 7e2da5b..69fe0c4 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 50d2e88..e050835 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 e4ee19d..e873111 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 2d694a3..51e5b30 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 f7e3a9d..6d22d89 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 51be519..dc3225b 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 8c9df49..b2bc635 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 de9572b..bf6962d 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 ff7c8cd..1d509a8 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 a1c46e4..908f7e2 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 1b76e71..313fc0a 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 bbe5ddc..bff40fa 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 b3c1119..ab9541c 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 */
        }