There was a problem with the last merge :S
authorAndre Susano Pinto <andresusanopinto@gmail.com>
Tue, 15 Jul 2008 12:54:57 +0000 (12:54 +0000)
committerAndre Susano Pinto <andresusanopinto@gmail.com>
Tue, 15 Jul 2008 12:54:57 +0000 (12:54 +0000)
Somehow it didnt finished and didnt added some files under the svn control
(found thanks to lguillaume that reported some files were missing)

Last merge fixed and also merged modifications up to revision 15584.

I checked the diff
svn diff --new . --old https://svn.blender.org/svnroot/bf-blender/trunk/blender
And everything seems to be right now

28 files changed:
CMakeLists.txt
intern/bsp/intern/BSP_CSGMesh.cpp
intern/container/CTR_TaggedIndex.h
intern/decimation/intern/LOD_ManMesh2.cpp
intern/elbeem/intern/solver_init.cpp
intern/ghost/intern/GHOST_SystemWin32.cpp
intern/ghost/intern/GHOST_WindowWin32.cpp
release/scripts/scripttemplate_ipo_gen.py [new file with mode: 0644]
source/blender/blenlib/BLI_mempool.h [new file with mode: 0644]
source/blender/blenlib/intern/BLI_mempool.c [new file with mode: 0644]
source/blender/imbuf/intern/openexr/openexr_api.cpp
source/blender/render/intern/include/sunsky.h [new file with mode: 0644]
source/blender/render/intern/source/sunsky.c [new file with mode: 0644]
source/blender/render/intern/source/zbuf.c
source/blender/src/buttons_editing.c
source/blender/src/buttons_scene.c
source/blender/src/transform_conversions.c
source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
source/gameengine/GameLogic/SCA_ActuatorEventManager.cpp [new file with mode: 0644]
source/gameengine/GameLogic/SCA_ActuatorEventManager.h [new file with mode: 0644]
source/gameengine/GameLogic/SCA_ActuatorSensor.cpp [new file with mode: 0644]
source/gameengine/GameLogic/SCA_ActuatorSensor.h [new file with mode: 0644]
source/gameengine/GameLogic/SCA_PythonController.cpp
source/gameengine/GamePlayer/ghost/GPG_Application.cpp
source/gameengine/Ketsji/KX_KetsjiEngine.cpp
source/gameengine/Ketsji/KX_PythonInit.cpp
source/gameengine/Ketsji/KX_PythonInit.h
source/gameengine/Ketsji/KX_SoundActuator.cpp

index b58fe9456639abdd060aa9f9f6812e3083a54bbb..5a23e77d9f81fa04100e840f1bab164e442a317f 100644 (file)
@@ -197,10 +197,17 @@ IF(UNIX)
 ENDIF(UNIX)
 
 IF(WIN32)
-  INCLUDE(${CMAKE_ROOT}/Modules/Platform/Windows-cl.cmake)
 
+  INCLUDE(${CMAKE_ROOT}/Modules/Platform/Windows-cl.cmake)
+  
   SET(LIBDIR ${CMAKE_SOURCE_DIR}/../lib/windows)
 
+  # Setup 64bit and 64bit windows systems
+  IF(CMAKE_CL_64)
+    message("64 bit compiler detected.")
+    SET(LIBDIR ${CMAKE_SOURCE_DIR}/../lib/win64)
+  ENDIF(CMAKE_CL_64)
+
   SET(PYTHON ${LIBDIR}/python)
   SET(PYTHON_VERSION 2.5)
   SET(PYTHON_INC "${PYTHON}/include/python${PYTHON_VERSION}")
@@ -214,12 +221,20 @@ IF(WIN32)
   SET(OPENAL_LIB openal_static)
   SET(OPENAL_LIBPATH ${OPENAL}/lib)
 
-  SET(PNG_LIB libpng_st)
+  IF(CMAKE_CL_64)
+       SET(PNG_LIB libpng)
+  ELSE(CMAKE_CL_64)
+       SET(PNG_LIB libpng_st)
+  ENDIF(CMAKE_CL_64)
   SET(JPEG_LIB libjpeg)
 
   SET(ZLIB ${LIBDIR}/zlib)
   SET(ZLIB_INC ${ZLIB}/include)
-  SET(ZLIB_LIB libz)
+  IF(CMAKE_CL_64)
+       SET(ZLIB_LIB zlib)
+  ELSE(CMAKE_CL_64)
+       SET(ZLIB_LIB libz)
+  ENDIF(CMAKE_CL_64)
   SET(ZLIB_LIBPATH ${ZLIB}/lib)
   
   SET(PTHREADS ${LIBDIR}/pthreads)
@@ -302,7 +317,11 @@ IF(WIN32)
   
   SET(WINTAB_INC ${LIBDIR}/wintab/include) 
 
-  SET(PLATFORM_LINKFLAGS "/NODEFAULTLIB:libc.lib")
+  IF(CMAKE_CL_64)
+  SET(PLATFORM_LINKFLAGS "/NODEFAULTLIB:libc.lib;MSVCRT.lib ")
+  ELSE(CMAKE_CL_64)
+  SET(PLATFORM_LINKFLAGS "/NODEFAULTLIB:libc.lib ")
+  ENDIF(CMAKE_CL_64)
   SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /NODEFAULTLIB:libcmt.lib;libc.lib ")
 ENDIF(WIN32)
 
index 553f39a4642e1a8ae73c3f1f5baeecf51d3fbc10..ca7795b3cf5edea6b29dfa9caab4fd1e6accf674 100644 (file)
@@ -197,7 +197,7 @@ BuildEdges(
 
                for (int vert = 0; vert < vertex_num; ++vert) {
 
-                       BSP_FaceInd fi(f_it - f_it_begin);
+                       BSP_FaceInd fi(size_t (f_it - f_it_begin));
                        InsertEdge(prev_vi,face.m_verts[vert],fi,dummy);
                        prev_vi = face.m_verts[vert];
                }
index 7a7bd85e8902d02347f067f1080babe2548ebef5..68d2536c8793fb37d526295a0ac6d7aa0562cc36 100644 (file)
@@ -93,6 +93,16 @@ public:
        }
 
 
+#if defined(_WIN64)
+       CTR_TaggedIndex(
+               const unsigned __int64 val
+       ) :
+               m_val ( ((unsigned __int64)val & index_mask)
+                               | ( (empty_tag << tag_shift)
+                                       & (~index_mask) ) ) {
+       }
+#endif
+
        CTR_TaggedIndex(
                const CTR_TaggedIndex &my_index
        ):
@@ -124,6 +134,12 @@ public:
                return (long int)(m_val & index_mask);
        }
 
+#if defined(_WIN64)
+       operator unsigned __int64 () const {
+                       return (unsigned __int64)(m_val & index_mask);
+               }
+#endif
+
                bool
        IsEmpty(
        ) const {
index eeb497bb09eb1024a003b0ac6fb135d3046de0ce..2fe49b36583c47c756fa1dd498d08908fd7ccb3e 100644 (file)
@@ -477,7 +477,7 @@ DeleteVertex(
                return;
        }
 
-       LOD_VertexInd last = LOD_VertexInd(verts.end() - verts.begin() - 1);
+       LOD_VertexInd last = LOD_VertexInd(size_t(verts.end() - verts.begin() - 1));
 
        if (!(last == v)) {
 
@@ -533,7 +533,7 @@ DeleteEdge(
                return;
        }
 
-       LOD_EdgeInd last = LOD_EdgeInd(edges.end() - edges.begin() - 1);
+       LOD_EdgeInd last = LOD_EdgeInd(size_t(edges.end() - edges.begin() - 1));
 
        if (!(last == e)) {
                vector<LOD_EdgeInd> e_verts;
@@ -573,7 +573,7 @@ DeleteFace(
                return;
        }
 
-       LOD_FaceInd last = LOD_FaceInd(faces.end() - faces.begin() - 1);
+       LOD_FaceInd last = LOD_FaceInd(size_t (faces.end() - faces.begin() - 1));
 
        if (!(last == f)) {
                
index c953d2f47da66979878b645e62bfc1f28aec0679..a873f3c69874587ad84d61382ee1d2dee4f3b26a 100644 (file)
@@ -694,7 +694,7 @@ bool LbmFsgrSolver::initializeSolverMemory()
                double maxDefaultMemChunk = 2.*1024.*1024.*1024.;
                //std::cerr<<" memEstFine "<< memEstFine <<" maxWin:" <<maxWinMemChunk <<" maxMac:" <<maxMacMemChunk ; // DEBUG
 #ifdef WIN32
-               if(memEstFine> maxWinMemChunk) {
+               if(sizeof(void *)==4 && memEstFine>maxWinMemChunk) {
                        memBlockAllocProblem = true;
                }
 #endif // WIN32
index 293f8fc1661d2230ec2f1ff109c5564da92d0ef6..f5c7c08ebfe1d71ec5e68647413009b7485b65a5 100644 (file)
 
 #include "GHOST_SystemWin32.h"
 
+// win64 doesn't define GWL_USERDATA
+#ifdef WIN32
+#ifndef GWL_USERDATA
+#define GWL_USERDATA GWLP_USERDATA
+#define GWL_WNDPROC GWLP_WNDPROC
+#endif
+#endif
+
 /*
  * According to the docs the mouse wheel message is supported from windows 98 
  * upwards. Leaving WINVER at default value, the WM_MOUSEWHEEL message and the 
index 905b2f7ac6349487d6c1b6371690f3db4927ba27..fef58d071a457a3412c72bfbe1344e8875c4d097 100644 (file)
 #define M_PI 3.1415926536
 #endif
 
+// win64 doesn't define GWL_USERDATA
+#ifdef WIN32
+#ifndef GWL_USERDATA
+#define GWL_USERDATA GWLP_USERDATA
+#define GWL_WNDPROC GWLP_WNDPROC
+#endif
+#endif
+
 LPCSTR GHOST_WindowWin32::s_windowClassName = "GHOST_WindowClass";
 const int GHOST_WindowWin32::s_maxTitleLength = 128;
 HGLRC GHOST_WindowWin32::s_firsthGLRc = NULL;
diff --git a/release/scripts/scripttemplate_ipo_gen.py b/release/scripts/scripttemplate_ipo_gen.py
new file mode 100644 (file)
index 0000000..791eaed
--- /dev/null
@@ -0,0 +1,92 @@
+#!BPY
+"""
+Name: 'Camera/Object Example'
+Blender: 245
+Group: 'ScriptTemplate'
+Tooltip: 'Script template for setting the camera direction'
+"""
+
+from Blender import Window
+import bpy
+
+script_data = \
+'''#!BPY
+"""
+Name: 'My Ipo Script'
+Blender: 245
+Group: 'Animation'
+Tooltip: 'Put some useful info here'
+"""
+
+# Add a licence here if you wish to re-distribute, we recommend the GPL
+
+from Blender import Ipo, Mathutils, Window
+import bpy, BPyMessages
+
+def makeRandomIpo(object, firstFrame, numberOfFrames, frameStep):
+       # Create an new Ipo Curve of name myIpo and type Object
+       myIpo = bpy.data.ipos.new('myIpo', 'Object')
+       
+       # Create LocX, LocY, and LocZ Ipo curves in our new Curve Object
+       # and store them so we can access them later
+       myIpo_x = myIpo.addCurve('LocX')
+       myIpo_y = myIpo.addCurve('LocY')
+       myIpo_z = myIpo.addCurve('LocZ')
+       
+       # What value we want to scale our random value by
+       ipoScale = 4
+       
+       # This Calculates the End Frame for use in an xrange() expression
+       endFrame = firstFrame + (numberOfFrames * frameStep) + frameStep
+       
+       for frame in xrange(firstFrame, endFrame, frameStep):
+               
+               # Use the Mathutils Rand() function to get random numbers
+               ipoValue_x = Mathutils.Rand(-1, 1) * ipoScale
+               ipoValue_y = Mathutils.Rand(-1, 1) * ipoScale
+               ipoValue_z = Mathutils.Rand(-1, 1) * ipoScale
+               
+               # Append to the Ipo curve at location frame, with the value ipoValue_x
+               # Note that we should pass the append function a tuple or a BezTriple
+               myIpo_x.append((frame, ipoValue_x))
+       
+               # Similar to above
+               myIpo_y.append((frame, ipoValue_y))
+               myIpo_z.append((frame, ipoValue_z))
+       
+       # Link our new Ipo Curve to the passed object
+       object.setIpo(myIpo)
+       print object
+       
+       
+def main():
+       
+       # Get the active scene, since there can be multiple ones
+       sce = bpy.data.scenes.active
+       
+       # Get the active object
+       object = sce.objects.active
+       
+       # If there is no active object, pop up an error message
+       if not object:
+               BPyMessages.Error_NoActive()
+               
+       Window.WaitCursor(1)
+       
+       # Call our makeRandomIpo function
+       # Pass it our object, Tell it to keys from the start frame until the end frame, at a step of 10 frames
+       # between them
+       
+       makeRandomIpo(object, sce.render.sFrame, sce.render.eFrame, 10)
+       
+       Window.WaitCursor(0)
+
+if __name__ == '__main__':
+       main()
+
+'''
+
+new_text = bpy.data.texts.new('ipo_template.py')
+new_text.write(script_data)
+bpy.data.texts.active = new_text
+Window.RedrawAll()
diff --git a/source/blender/blenlib/BLI_mempool.h b/source/blender/blenlib/BLI_mempool.h
new file mode 100644 (file)
index 0000000..8b31459
--- /dev/null
@@ -0,0 +1,44 @@
+/**
+ * Simple fast memory allocator
+ * 
+ *
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Geoffrey Bantle.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef BLI_MEMPOOL_H
+#define BLI_MEMPOOL_H
+
+struct BLI_mempool;
+typedef struct BLI_mempool BLI_mempool;
+
+BLI_mempool *BLI_mempool_create(int esize, int tote, int pchunk);
+void *BLI_mempool_alloc(BLI_mempool *pool);
+void *BLI_mempool_calloc(BLI_mempool *pool);
+void BLI_mempool_free(BLI_mempool *pool, void *addr);
+void BLI_mempool_destroy(BLI_mempool *pool);
+
+
+#endif
diff --git a/source/blender/blenlib/intern/BLI_mempool.c b/source/blender/blenlib/intern/BLI_mempool.c
new file mode 100644 (file)
index 0000000..7ac7b8b
--- /dev/null
@@ -0,0 +1,140 @@
+/**
+ *
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008 by Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/*
+       Simple, fast memory allocator for allocating many elements of the same size.
+*/
+
+#include "MEM_guardedalloc.h"
+#include "BLI_blenlib.h"
+#include "DNA_listBase.h"
+#include "BLI_linklist.h"
+#include <string.h> 
+
+typedef struct BLI_freenode{
+       struct BLI_freenode *next;
+}BLI_freenode;
+
+typedef struct BLI_mempool_chunk{
+       struct BLI_mempool_chunk *next, *prev;
+       void *data;
+}BLI_mempool_chunk;
+
+typedef struct BLI_mempool{
+       struct ListBase chunks;
+       int esize, csize, pchunk;               /*size of elements and chunks in bytes and number of elements per chunk*/
+       struct BLI_freenode     *free;          /*free element list. Interleaved into chunk datas.*/
+}BLI_mempool;
+
+BLI_mempool *BLI_mempool_create(int esize, int tote, int pchunk)
+{      BLI_mempool  *pool = NULL;
+       BLI_freenode *lasttail = NULL, *curnode = NULL;
+       int i,j, maxchunks;
+       char *addr;
+
+       /*allocate the pool structure*/
+       pool = MEM_mallocN(sizeof(BLI_mempool),"memory pool");
+       pool->esize = esize;
+       pool->pchunk = pchunk;  
+       pool->csize = esize * pchunk;
+       pool->chunks.first = pool->chunks.last = NULL;
+       
+       maxchunks = tote / pchunk;
+       
+       /*allocate the actual chunks*/
+       for(i=0; i < maxchunks; i++){
+               BLI_mempool_chunk *mpchunk = MEM_mallocN(sizeof(BLI_mempool_chunk), "BLI_Mempool Chunk");
+               mpchunk->next = mpchunk->prev = NULL;
+               mpchunk->data = MEM_mallocN(pool->csize, "BLI Mempool Chunk Data");
+               BLI_addtail(&(pool->chunks), mpchunk);
+               
+               if(i==0) pool->free = mpchunk->data; /*start of the list*/
+               /*loop through the allocated data, building the pointer structures*/
+               for(addr = mpchunk->data, j=0; j < pool->pchunk; j++){
+                       curnode = ((BLI_freenode*)addr);
+                       addr += pool->esize;
+                       curnode->next = (BLI_freenode*)addr;
+               }
+               /*final pointer in the previously allocated chunk is wrong.*/
+               if(lasttail) lasttail->next = mpchunk->data;
+               /*set the end of this chunks memoryy to the new tail for next iteration*/
+               lasttail = curnode;
+       }
+       /*terminate the list*/
+       curnode->next = NULL;
+       return pool;
+}
+void *BLI_mempool_alloc(BLI_mempool *pool){
+       void *retval=NULL;
+       BLI_freenode *curnode=NULL;
+       char *addr=NULL;
+       int j;
+
+       if(!(pool->free)){
+               /*need to allocate a new chunk*/
+               BLI_mempool_chunk *mpchunk = MEM_mallocN(sizeof(BLI_mempool_chunk), "BLI_Mempool Chunk");
+               mpchunk->next = mpchunk->prev = NULL;
+               mpchunk->data = MEM_mallocN(pool->csize, "BLI_Mempool Chunk Data");
+               BLI_addtail(&(pool->chunks), mpchunk);
+
+               pool->free = mpchunk->data; /*start of the list*/
+               for(addr = mpchunk->data, j=0; j < pool->pchunk; j++){
+                       curnode = ((BLI_freenode*)addr);
+                       addr += pool->esize;
+                       curnode->next = (BLI_freenode*)addr;
+               }
+               curnode->next = NULL; /*terminate the list*/
+       }
+
+       retval = pool->free;
+       pool->free = pool->free->next;
+       //memset(retval, 0, pool->esize);
+       return retval;
+}
+
+void *BLI_mempool_calloc(BLI_mempool *pool){
+       void *retval=NULL;
+       retval = BLI_mempool_alloc(pool);
+       memset(retval, 0, pool->esize);
+       return retval;
+}
+
+
+
+void BLI_mempool_free(BLI_mempool *pool, void *addr){ //doesnt protect against double frees, dont be stupid!
+       BLI_freenode *newhead = addr;
+       newhead->next = pool->free;
+       pool->free = newhead;
+}
+void BLI_mempool_destroy(BLI_mempool *pool)
+{
+       BLI_mempool_chunk *mpchunk=NULL;
+       for(mpchunk = pool->chunks.first; mpchunk; mpchunk = mpchunk->next) MEM_freeN(mpchunk->data);
+       BLI_freelistN(&(pool->chunks));
+       MEM_freeN(pool);
+}
index fe352610a40cb36fcdd2c4c4103bb3452826a5c2..3e618a483e352ca8b8ebf981b5de9cd84035d941 100644 (file)
@@ -451,7 +451,7 @@ void IMB_exr_begin_write(void *handle, char *filename, int width, int height, in
        openexr_header_compression(&header, compress);
        /* header.lineOrder() = DECREASING_Y; this crashes in windows for file read! */
        
-       header.insert ("BlenderMultiChannel", StringAttribute ("Blender V2.43"));
+       header.insert ("BlenderMultiChannel", StringAttribute ("Blender V2.43 and newer"));
        
        data->ofile = new OutputFile(filename, header);
 }
diff --git a/source/blender/render/intern/include/sunsky.h b/source/blender/render/intern/include/sunsky.h
new file mode 100644 (file)
index 0000000..c61a637
--- /dev/null
@@ -0,0 +1,141 @@
+ /**
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): zaghaghi
+ * 
+ * ***** END GPL LICENSE BLOCK *****
+ */
+/**
+ * This feature comes from Preetham paper on "A Practical Analytic Model for Daylight" 
+ * and example code from Brian Smits, another author of that paper in 
+ * http://www.cs.utah.edu/vissim/papers/sunsky/code/
+ * */
+#ifndef SUNSKY_H_
+#define SUNSKY_H_
+
+#define SPECTRUM_MAX_COMPONENTS     100
+#define SPECTRUM_START              350.0
+#define SPECTRUM_END                800.0
+
+typedef struct SunSky
+{
+    short effect_type;
+    float turbidity;
+    float theta, phi;
+    
+    float toSun[3];
+
+    /*float sunSpectralRaddata[SPECTRUM_MAX_COMPONENTS];*/
+    float sunSolidAngle;
+
+    float zenith_Y, zenith_x, zenith_y;
+    
+    float perez_Y[5], perez_x[5], perez_y[5];
+
+    /* suggested by glome in 
+     * http://projects.blender.org/tracker/?func=detail&atid=127&aid=8063&group_id=9*/
+    float horizon_brightness;
+    float spread;
+    float sun_brightness;
+    float sun_size;
+    float backscattered_light;
+    
+    float atm_HGg;
+
+    float atm_SunIntensity;
+    float atm_InscatteringMultiplier;
+    float atm_ExtinctionMultiplier;
+    float atm_BetaRayMultiplier;
+    float atm_BetaMieMultiplier;
+    float atm_DistanceMultiplier;
+
+    float atm_BetaRay[3];
+    float atm_BetaDashRay[3];
+    float atm_BetaMie[3];
+    float atm_BetaDashMie[3];
+    float atm_BetaRM[3];
+}SunSky;
+
+/**
+ * InitSunSky:
+ * this function compute some sun,sky parameters according to input parameters and also initiate some other sun, sky parameters
+ * parameters:
+ * sunSky, is a structure that contains informtion about sun, sky and atmosphere, in this function, most of its values initiated
+ * turb, is atmosphere turbidity
+ * toSun, contains sun direction
+ * horizon_brighness, controls the brightness of the horizon colors
+ * spread, controls colors spreed at horizon
+ * sun_brightness, controls sun's brightness
+ * sun_size, controls sun's size
+ * back_scatter, controls back scatter light
+ * */
+void InitSunSky(struct SunSky *sunsky, float turb, float *toSun, float horizon_brightness, 
+                               float spread,float sun_brightness, float sun_size, float back_scatter);
+
+/**
+ * GetSkyXYZRadiance:
+ * this function compute sky radiance according to a view parameters `theta' and `phi'and sunSky values
+ * parameters:
+ * sunSky, sontains sun and sky parameters
+ * theta, is sun's theta
+ * phi, is sun's phi
+ * color_out, is computed color that shows sky radiance in XYZ color format
+ * */
+void GetSkyXYZRadiance(struct SunSky* sunsky, float theta, float phi, float color_out[3]);
+
+/**
+ * GetSkyXYZRadiancef:
+ * this function compute sky radiance according to a view direction `varg' and sunSky values
+ * parameters:
+ * sunSky, sontains sun and sky parameters
+ * varg, shows direction
+ * color_out, is computed color that shows sky radiance in XYZ color format
+ * */
+void GetSkyXYZRadiancef(struct SunSky* sunsky, const float varg[3], float color_out[3]);
+
+/**
+ * InitAtmosphere:
+ * this function intiate sunSky structure with user input parameters.
+ * parameters:
+ * sunSky, contains information about sun, and in this function some atmosphere parameters will initiated
+ * sun_intens, shows sun intensity value
+ * mief, Mie scattering factor this factor currently call with 1.0 
+ * rayf, Rayleigh scattering factor, this factor currently call with 1.0
+ * inscattf, inscatter light factor that range from 0.0 to 1.0, 0.0 means no inscatter light and 1.0 means full inscatter light
+ * extincf, extinction light factor that range from 0.0 to 1.0, 0.0 means no extinction and 1.0 means full extinction
+ * disf, is distance factor, multiplyed to pixle's z value to compute each pixle's distance to camera, 
+ * */
+void InitAtmosphere(struct SunSky *sunSky, float sun_intens, float mief, float rayf, float inscattf, float extincf, float disf);
+
+/**
+ * AtmospherePixleShader:
+ * this function apply atmosphere effect on a pixle color `rgb' at distance `s'
+ * parameters:
+ * sunSky, contains information about sun parameters and user values
+ * view, is camera view vector
+ * s, is distance 
+ * rgb, contains rendered color value for a pixle
+ * */
+void AtmospherePixleShader( struct SunSky* sunSky, float view[3], float s, float rgb[3]);
+
+/**
+ * ClipColor:
+ * clip a color to range [0,1];
+ * */
+void ClipColor(float c[3]);
+
+#endif /*SUNSKY_H_*/
diff --git a/source/blender/render/intern/source/sunsky.c b/source/blender/render/intern/source/sunsky.c
new file mode 100644 (file)
index 0000000..1918677
--- /dev/null
@@ -0,0 +1,492 @@
+ /**
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+
+#include "sunsky.h"
+#include "math.h"
+#include "BLI_arithb.h"
+
+
+/**
+ * These macros are defined for vector operations
+ * */
+
+/**
+ * compute v1 = v2 op v3
+ * v1, v2 and v3 are vectors contains 3 float
+ * */
+#define vec3opv(v1, v2, op, v3) \
+       v1[0] = (v2[0] op v3[0]); \
+       v1[1] = (v2[1] op v3[1]);\
+       v1[2] = (v2[2] op v3[2]);
+
+/**
+ * compute v1 = v2 op f1
+ * v1, v2 are vectors contains 3 float
+ * and f1 is a float
+ * */
+#define vec3opf(v1, v2, op, f1)\
+       v1[0] = (v2[0] op (f1));\
+       v1[1] = (v2[1] op (f1));\
+       v1[2] = (v2[2] op (f1));
+
+/**
+ * compute v1 = f1 op v2
+ * v1, v2 are vectors contains 3 float
+ * and f1 is a float
+ * */
+#define fopvec3(v1, f1, op, v2)\
+       v1[0] = ((f1) op v2[0]);\
+       v1[1] = ((f1) op v2[1]);\
+       v1[2] = ((f1) op v2[2]);
+
+/**
+ * ClipColor:
+ * clip a color to range [0,1];
+ * */
+void ClipColor(float c[3])
+{
+    if (c[0] > 1.0) c[0] = 1.0;
+    if (c[0] < 0.0) c[0] = 0.0;
+    if (c[1] > 1.0) c[1] = 1.0;
+    if (c[1] < 0.0) c[1] = 0.0;
+    if (c[2] > 1.0) c[2] = 1.0;
+    if (c[2] < 0.0) c[2] = 0.0;
+}
+
+/**
+ * AngleBetween:
+ * compute angle between to direction 
+ * all angles are in radians
+ * */
+static float AngleBetween(float thetav, float phiv, float theta, float phi)
+{
+       float cospsi = sin(thetav) * sin(theta) * cos(phi - phiv) + cos(thetav) * cos(theta);
+
+       if (cospsi > 1.0)
+               return 0;
+       if (cospsi < -1.0)
+               return M_PI;
+
+       return acos(cospsi);
+}
+
+/**
+ * DirectionToThetaPhi:
+ * this function convert a direction to it's theta and phi value
+ * parameters:
+ * toSun: contains direction information
+ * theta, phi, are return values from this conversion
+ * */
+static void DirectionToThetaPhi(float *toSun, float *theta, float *phi)
+{
+    *theta = acos(toSun[2]);
+    if (fabs(*theta) < 1e-5)
+       *phi = 0;
+    else
+       *phi = atan2(toSun[1], toSun[0]);
+}
+
+/**
+ * PerezFunction:
+ * compute perez function value based on input paramters
+ * */
+float PerezFunction(struct SunSky *sunsky, const float *lam, float theta, float gamma, float lvz)
+{
+    float den, num;
+
+    den = ((1 + lam[0] * exp(lam[1])) *
+                   (1 + lam[2] * exp(lam[3] * sunsky->theta) + lam[4] * cos(sunsky->theta) * cos(sunsky->theta)));
+
+    num = ((1 + lam[0] * exp(lam[1] / cos(theta))) *
+                   (1 + lam[2] * exp(lam[3] * gamma) + lam[4] * cos(gamma) * cos(gamma)));
+
+    return(lvz * num / den);
+}
+
+/**
+ * InitSunSky:
+ * this function compute some sun,sky parameters according to input parameters and also initiate some other sun, sky parameters
+ * parameters:
+ * sunSky, is a structure that contains informtion about sun, sky and atmosphere, in this function, most of its values initiated
+ * turb, is atmosphere turbidity
+ * toSun, contains sun direction
+ * horizon_brighness, controls the brightness of the horizon colors
+ * spread, controls colors spreed at horizon
+ * sun_brightness, controls sun's brightness
+ * sun_size, controls sun's size
+ * back_scatter, controls back scatter light
+ * */
+void InitSunSky(struct SunSky *sunsky, float turb, float *toSun, float horizon_brightness, 
+                               float spread,float sun_brightness, float sun_size, float back_scatter)
+{
+    
+       float theta2;
+       float theta3;
+       float T;
+       float T2;
+       float chi;
+        
+       sunsky->turbidity = turb;
+
+       sunsky->horizon_brightness = horizon_brightness;
+       sunsky->spread = spread;
+       sunsky->sun_brightness = sun_brightness;
+       sunsky->sun_size = sun_size;
+       sunsky->backscattered_light = back_scatter;
+       
+       sunsky->toSun[0] = toSun[0];
+    sunsky->toSun[1] = toSun[1];
+    sunsky->toSun[2] = toSun[2];
+
+    DirectionToThetaPhi(sunsky->toSun, &sunsky->theta, &sunsky->phi);
+
+       sunsky->sunSolidAngle = 0.25 * M_PI * 1.39 * 1.39 / (150 * 150);   // = 6.7443e-05
+
+       theta2 = sunsky->theta*sunsky->theta;
+       theta3 = theta2 * sunsky->theta;
+       T = turb;
+       T2 = turb*turb;
+
+       chi = (4.0 / 9.0 - T / 120.0) * (M_PI - 2 * sunsky->theta);
+       sunsky->zenith_Y = (4.0453 * T - 4.9710) * tan(chi) - .2155 * T + 2.4192;
+       sunsky->zenith_Y *= 1000;   // conversion from kcd/m^2 to cd/m^2
+
+       if (sunsky->zenith_Y<=0)
+               sunsky->zenith_Y = 1e-6;
+       
+       sunsky->zenith_x =
+           ( + 0.00165 * theta3 - 0.00374 * theta2 + 0.00208 * sunsky->theta + 0) * T2 +
+           ( -0.02902 * theta3 + 0.06377 * theta2 - 0.03202 * sunsky->theta + 0.00394) * T +
+           ( + 0.11693 * theta3 - 0.21196 * theta2 + 0.06052 * sunsky->theta + 0.25885);
+
+       sunsky->zenith_y =
+           ( + 0.00275 * theta3 - 0.00610 * theta2 + 0.00316 * sunsky->theta + 0) * T2 +
+           ( -0.04214 * theta3 + 0.08970 * theta2 - 0.04153 * sunsky->theta + 0.00515) * T +
+           ( + 0.15346 * theta3 - 0.26756 * theta2 + 0.06669 * sunsky->theta + 0.26688);
+
+       
+       sunsky->perez_Y[0] = 0.17872 * T - 1.46303;
+       sunsky->perez_Y[1] = -0.35540 * T + 0.42749;
+       sunsky->perez_Y[2] = -0.02266 * T + 5.32505;
+       sunsky->perez_Y[3] = 0.12064 * T - 2.57705;
+       sunsky->perez_Y[4] = -0.06696 * T + 0.37027;
+
+       sunsky->perez_x[0] = -0.01925 * T - 0.25922;
+       sunsky->perez_x[1] = -0.06651 * T + 0.00081;
+       sunsky->perez_x[2] = -0.00041 * T + 0.21247;
+       sunsky->perez_x[3] = -0.06409 * T - 0.89887;
+       sunsky->perez_x[4] = -0.00325 * T + 0.04517;
+
+       sunsky->perez_y[0] = -0.01669 * T - 0.26078;
+       sunsky->perez_y[1] = -0.09495 * T + 0.00921;
+       sunsky->perez_y[2] = -0.00792 * T + 0.21023;
+       sunsky->perez_y[3] = -0.04405 * T - 1.65369;
+       sunsky->perez_y[4] = -0.01092 * T + 0.05291;
+       
+    /* suggested by glome in 
+     * http://projects.blender.org/tracker/?func=detail&atid=127&aid=8063&group_id=9*/
+       sunsky->perez_Y[0] *= sunsky->horizon_brightness;
+       sunsky->perez_x[0] *= sunsky->horizon_brightness;
+       sunsky->perez_y[0] *= sunsky->horizon_brightness;
+       
+       sunsky->perez_Y[1] *= sunsky->spread;
+       sunsky->perez_x[1] *= sunsky->spread;
+       sunsky->perez_y[1] *= sunsky->spread;
+
+       sunsky->perez_Y[2] *= sunsky->sun_brightness;
+       sunsky->perez_x[2] *= sunsky->sun_brightness;
+       sunsky->perez_y[2] *= sunsky->sun_brightness;
+       
+       sunsky->perez_Y[3] *= sunsky->sun_size;
+       sunsky->perez_x[3] *= sunsky->sun_size;
+       sunsky->perez_y[3] *= sunsky->sun_size;
+       
+       sunsky->perez_Y[4] *= sunsky->backscattered_light;
+       sunsky->perez_x[4] *= sunsky->backscattered_light;
+       sunsky->perez_y[4] *= sunsky->backscattered_light;
+}
+
+/**
+ * GetSkyXYZRadiance:
+ * this function compute sky radiance according to a view parameters `theta' and `phi'and sunSky values
+ * parameters:
+ * sunSky, sontains sun and sky parameters
+ * theta, is sun's theta
+ * phi, is sun's phi
+ * color_out, is computed color that shows sky radiance in XYZ color format
+ * */
+void GetSkyXYZRadiance(struct SunSky* sunsky, float theta, float phi, float color_out[3])
+{
+    float gamma;
+    float x,y,Y,X,Z;
+    float hfade=1, nfade=1;
+    
+    
+    if (theta>(0.5*M_PI)) {
+               hfade = 1.0-(theta*M_1_PI-0.5)*2.0;
+               hfade = hfade*hfade*(3.0-2.0*hfade);
+               theta = 0.5*M_PI;
+       }
+
+       if (sunsky->theta>(0.5*M_PI)) {
+               if (theta<=0.5*M_PI) {
+                       nfade = 1.0-(0.5-theta*M_1_PI)*2.0;
+                       nfade *= 1.0-(sunsky->theta*M_1_PI-0.5)*2.0;
+                       nfade = nfade*nfade*(3.0-2.0*nfade);
+               }
+       }
+
+       gamma = AngleBetween(theta, phi, sunsky->theta, sunsky->phi);
+       
+    // Compute xyY values
+    x = PerezFunction(sunsky, sunsky->perez_x, theta, gamma, sunsky->zenith_x);
+    y = PerezFunction(sunsky, sunsky->perez_y, theta, gamma, sunsky->zenith_y);
+    Y = nfade * hfade * PerezFunction(sunsky, sunsky->perez_Y, theta, gamma, sunsky->zenith_Y);
+
+    X = (x / y) * Y;
+    Z = ((1 - x - y) / y) * Y;
+
+    color_out[0] = X;
+    color_out[1] = Y;
+    color_out[2] = Z;
+}
+
+/**
+ * GetSkyXYZRadiancef:
+ * this function compute sky radiance according to a view direction `varg' and sunSky values
+ * parameters:
+ * sunSky, sontains sun and sky parameters
+ * varg, shows direction
+ * color_out, is computed color that shows sky radiance in XYZ color format
+ * */
+void GetSkyXYZRadiancef(struct SunSky* sunsky, const float varg[3], float color_out[3])
+{
+    float      theta, phi;
+    float      v[3];
+
+       VecCopyf(v, (float*)varg);
+       Normalize(v);
+
+    if (v[2] < 0.001){
+        v[2] = 0.001;
+        Normalize(v);
+    }
+
+    DirectionToThetaPhi(v, &theta, &phi);
+    GetSkyXYZRadiance(sunsky, theta, phi, color_out);
+}
+
+/**
+ * ComputeAttenuatedSunlight:
+ * this function compute attenuated sun light based on sun's theta and atmosphere turbidity
+ * parameters:
+ * theta, is sun's theta
+ * turbidity: is atmosphere turbidity
+ * fTau: contains computed attenuated sun light
+ * */
+void ComputeAttenuatedSunlight(float theta, int turbidity, float fTau[3])
+{
+    float fBeta ;
+    float fTauR, fTauA;
+    float m ;
+    float fAlpha;
+    
+    int i;
+    float fLambda[3]; 
+       fLambda[0] = 0.65f;     
+       fLambda[1] = 0.57f;     
+       fLambda[2] = 0.475f;
+
+       fAlpha = 1.3f;
+       fBeta = 0.04608365822050f * turbidity - 0.04586025928522f;
+       
+       m =  1.0/(cos(theta) + 0.15f*pow(93.885f-theta/M_PI*180.0f,-1.253f));  
+
+    for(i = 0; i < 3; i++)
+       {
+               // Rayleigh Scattering
+               fTauR = exp( -m * 0.008735f * pow(fLambda[i], (float)(-4.08f)));
+
+               // Aerosal (water + dust) attenuation
+               fTauA = exp(-m * fBeta * pow(fLambda[i], -fAlpha));  
+
+               fTau[i] = fTauR * fTauA; 
+    }
+}
+
+/**
+ * InitAtmosphere:
+ * this function intiate sunSky structure with user input parameters.
+ * parameters:
+ * sunSky, contains information about sun, and in this function some atmosphere parameters will initiated
+ * sun_intens, shows sun intensity value
+ * mief, Mie scattering factor this factor currently call with 1.0 
+ * rayf, Rayleigh scattering factor, this factor currently call with 1.0
+ * inscattf, inscatter light factor that range from 0.0 to 1.0, 0.0 means no inscatter light and 1.0 means full inscatter light
+ * extincf, extinction light factor that range from 0.0 to 1.0, 0.0 means no extinction and 1.0 means full extinction
+ * disf, is distance factor, multiplyed to pixle's z value to compute each pixle's distance to camera, 
+ * */
+void InitAtmosphere(struct SunSky *sunSky, float sun_intens, float mief, float rayf,
+                                                       float inscattf, float extincf, float disf)
+{
+       const float pi = 3.14159265358f;
+       const float n = 1.003f; // refractive index
+       const float N = 2.545e25;
+       const float pn = 0.035f;
+       const float T = 2.0f;
+       float fTemp, fTemp2, fTemp3, fBeta, fBetaDash;
+       float c = (6.544*T - 6.51)*1e-17; 
+       float K[3] = {0.685f, 0.679f, 0.670f}; 
+       float vBetaMieTemp[3];
+       
+       float fLambda[3],fLambda2[3], fLambda4[3];
+       float vLambda2[3];
+       float vLambda4[3];
+       
+       int i;
+
+       sunSky->atm_SunIntensity = sun_intens;
+       sunSky->atm_BetaMieMultiplier  = mief;
+       sunSky->atm_BetaRayMultiplier = rayf;
+       sunSky->atm_InscatteringMultiplier = inscattf;
+       sunSky->atm_ExtinctionMultiplier = extincf;
+       sunSky->atm_DistanceMultiplier = disf;
+               
+       sunSky->atm_HGg=0.8;
+
+       fLambda[0]  = 1/650e-9f; 
+       fLambda[1]  = 1/570e-9f;
+       fLambda[2]  = 1/475e-9f;
+       for (i=0; i < 3; i++)
+       {
+               fLambda2[i] = fLambda[i]*fLambda[i];
+               fLambda4[i] = fLambda2[i]*fLambda2[i];
+       }
+
+       vLambda2[0] = fLambda2[0];
+       vLambda2[1] = fLambda2[1];
+       vLambda2[2] = fLambda2[2];
+       vLambda4[0] = fLambda4[0];
+       vLambda4[1] = fLambda4[1];
+       vLambda4[2] = fLambda4[2];
+
+       // Rayleigh scattering constants.
+       fTemp = pi*pi*(n*n-1)*(n*n-1)*(6+3*pn)/(6-7*pn)/N;
+       fBeta = 8*fTemp*pi/3;
+               
+       vec3opf(sunSky->atm_BetaRay, vLambda4, *, fBeta);
+       fBetaDash = fTemp/2;
+       vec3opf(sunSky->atm_BetaDashRay, vLambda4,*, fBetaDash);
+       
+
+       // Mie scattering constants.
+       fTemp2 = 0.434*c*(2*pi)*(2*pi)*0.5f;
+       vec3opf(sunSky->atm_BetaDashMie, vLambda2, *, fTemp2);
+       
+       fTemp3 = 0.434f*c*pi*(2*pi)*(2*pi);
+       
+       vec3opv(vBetaMieTemp, K, *, fLambda);
+       vec3opf(sunSky->atm_BetaMie, vBetaMieTemp,*, fTemp3);
+       
+}
+
+/**
+ * AtmospherePixleShader:
+ * this function apply atmosphere effect on a pixle color `rgb' at distance `s'
+ * parameters:
+ * sunSky, contains information about sun parameters and user values
+ * view, is camera view vector
+ * s, is distance 
+ * rgb, contains rendered color value for a pixle
+ * */
+void AtmospherePixleShader( struct SunSky* sunSky, float view[3], float s, float rgb[3])
+{
+       float costheta;
+       float Phase_1;
+       float Phase_2;
+       float sunColor[3];
+       
+       float E[3];
+       float E1[3];
+       
+       
+       float I[3];
+       float fTemp;
+       float vTemp1[3], vTemp2[3];
+
+       float sunDirection[3];
+       
+       s *= sunSky->atm_DistanceMultiplier;
+       
+       sunDirection[0] = sunSky->toSun[0];
+       sunDirection[1] = sunSky->toSun[1];
+       sunDirection[2] = sunSky->toSun[2];
+       
+       costheta = Inpf(view, sunDirection); // cos(theta)
+       Phase_1 = 1 + (costheta * costheta); // Phase_1
+       
+       vec3opf(sunSky->atm_BetaRay, sunSky->atm_BetaRay, *, sunSky->atm_BetaRayMultiplier);
+       vec3opf(sunSky->atm_BetaMie, sunSky->atm_BetaMie, *, sunSky->atm_BetaMieMultiplier);
+       vec3opv(sunSky->atm_BetaRM, sunSky->atm_BetaRay, +, sunSky->atm_BetaMie);
+       
+       //e^(-(beta_1 + beta_2) * s) = E1
+       vec3opf(E1, sunSky->atm_BetaRM, *, -s/log(2));
+       E1[0] = exp(E1[0]);
+       E1[1] = exp(E1[1]);
+       E1[2] = exp(E1[2]);
+
+       VecCopyf(E, E1);
+               
+       //Phase2(theta) = (1-g^2)/(1+g-2g*cos(theta))^(3/2)
+       fTemp = 1 + sunSky->atm_HGg - 2 * sunSky->atm_HGg * costheta;
+       fTemp = fTemp * sqrt(fTemp);
+       Phase_2 = (1 - sunSky->atm_HGg * sunSky->atm_HGg)/fTemp;
+       
+       vec3opf(vTemp1, sunSky->atm_BetaDashRay, *, Phase_1);
+       vec3opf(vTemp2, sunSky->atm_BetaDashMie, *, Phase_2);   
+
+       vec3opv(vTemp1, vTemp1, +, vTemp2);
+       fopvec3(vTemp2, 1.0, -, E1);
+       vec3opv(vTemp1, vTemp1, *, vTemp2);
+
+       fopvec3(vTemp2, 1.0, / , sunSky->atm_BetaRM);
+
+       vec3opv(I, vTemp1, *, vTemp2);
+               
+       vec3opf(I, I, *, sunSky->atm_InscatteringMultiplier);
+       vec3opf(E, E, *, sunSky->atm_ExtinctionMultiplier);
+               
+       //scale to color sun
+       ComputeAttenuatedSunlight(sunSky->theta, sunSky->turbidity, sunColor);
+       vec3opv(E, E, *, sunColor);
+
+       vec3opf(I, I, *, sunSky->atm_SunIntensity);
+
+       vec3opv(rgb, rgb, *, E);
+       vec3opv(rgb, rgb, +, I);
+}
+
+#undef vec3opv
+#undef vec3opf
+#undef fopvec3
+
+/* EOF */
index 579905315bb4c46d06e15b3b2f337cd33cf502cf..c91c9e2f799fb42121e2b58c4cf16b72374b3069 100644 (file)
@@ -3545,7 +3545,7 @@ void merge_transp_passes(RenderLayer *rl, ShadeResult *shr)
        
        for(rpass= rl->passes.first; rpass; rpass= rpass->next) {
                float *col= NULL;
-               int pixsize= 0;
+               int pixsize= 3;
                
                switch(rpass->passtype) {
                        case SCE_PASS_RGBA:
@@ -3580,6 +3580,10 @@ void merge_transp_passes(RenderLayer *rl, ShadeResult *shr)
                                col= &shr->mist;
                                pixsize= 1;
                                break;
+                       case SCE_PASS_Z:
+                               col= &shr->z;
+                               pixsize= 1;
+                               break;
                        case SCE_PASS_VECTOR:
                                
                                {
@@ -3612,14 +3616,18 @@ void merge_transp_passes(RenderLayer *rl, ShadeResult *shr)
                        
                        for(samp= 1; samp<R.osa; samp++, fp+=delta) {
                                col[0]+= fp[0];
-                               col[1]+= fp[1];
-                               col[2]+= fp[2];
-                               if(pixsize) col[3]+= fp[3];
+                               if(pixsize>1) {
+                                       col[1]+= fp[1];
+                                       col[2]+= fp[2];
+                                       if(pixsize==4) col[3]+= fp[3];
+                               }
                        }
                        col[0]*= weight;
-                       col[1]*= weight;
-                       col[2]*= weight;
-                       if(pixsize) col[3]*= weight;
+                       if(pixsize>1) {
+                               col[1]*= weight;
+                               col[2]*= weight;
+                               if(pixsize==4) col[3]*= weight;
+                       }
                }
        }
                                
@@ -3973,7 +3981,7 @@ unsigned short *zbuffer_transp_shade(RenderPart *pa, RenderLayer *rl, float *pas
 
        /* general shader info, passes */
        shade_sample_initialize(&ssamp, pa, rl);
-       addpassflag= rl->passflag & ~(SCE_PASS_Z|SCE_PASS_COMBINED);
+       addpassflag= rl->passflag & ~(SCE_PASS_COMBINED);
        addzbuf= rl->passflag & SCE_PASS_Z;
        
        if(R.osa)
index a21dc8b0f5dc8904f716f89716971bffa46ff484..c30f39b5f4c7dfb473bccaac48c513f5d94777a1 100644 (file)
@@ -513,7 +513,6 @@ void do_common_editbuts(unsigned short event) // old name, is a mix of object an
                                } else {
                                        editmesh_deselect_by_material(G.obedit->actcol-1);
                                }
-                               allqueue(REDRAWVIEW3D, 0);
                        }
                        else if ELEM(G.obedit->type, OB_CURVE, OB_SURF) {
                                nu= editNurb.first;
@@ -553,8 +552,9 @@ void do_common_editbuts(unsigned short event) // old name, is a mix of object an
                                        nu= nu->next;
                                }
                                BIF_undo_push("Select material index");
-                               allqueue(REDRAWVIEW3D, 0);
                        }
+                       allqueue(REDRAWIMAGE, 0);
+                       allqueue(REDRAWVIEW3D, 0);
                }
                countall();
                break;
index af90d01fb59b14e318a8539ec5b492f4ac080ed4..3b0167d673c6ae258d8ccf36a4ebba37cce238d0 100644 (file)
@@ -137,36 +137,42 @@ static void load_new_sample(char *str)    /* called from fileselect */
        bSample *sample, *newsample;
 
        sound = G.buts->lockpoin;
+       
+       /* No Sound or Selected the same sample as we alredy have, just ignore */
+       if (sound==NULL || str==sound->name)
+               return;
+               
+       if (sizeof(sound->sample->name) < strlen(str)) {
+               error("Path too long: %s", str);
+               return;
+       }
+               
+       // save values
+       sample = sound->sample;
+       strcpy(name, sound->sample->name);      
+       strcpy(sound->name, str);
+       sound_set_sample(sound, NULL);
+       sound_initialize_sample(sound);
 
-       if (sound) {
-               // save values
-               sample = sound->sample;
-               strcpy(name, sound->sample->name);
-
-               strcpy(sound->name, str);
-               sound_set_sample(sound, NULL);
-               sound_initialize_sample(sound);
-
-               if (sound->sample->type == SAMPLE_INVALID) {
-                       error("Not a valid sample: %s", str);
+       if (sound->sample->type == SAMPLE_INVALID) {
+               error("Not a valid sample: %s", str);
 
-                       newsample = sound->sample;
+               newsample = sound->sample;
 
-                       // restore values
-                       strcpy(sound->name, name);
-                       sound_set_sample(sound, sample);
+               // restore values
+               strcpy(sound->name, name);
+               sound_set_sample(sound, sample);
 
-                       // remove invalid sample
+               // remove invalid sample
 
-                       sound_free_sample(newsample);
-                       BLI_remlink(samples, newsample);
-                       MEM_freeN(newsample);
-               }
+               sound_free_sample(newsample);
+               BLI_remlink(samples, newsample);
+               MEM_freeN(newsample);
+               return;
        }
-
+       
        BIF_undo_push("Load new audio file");
        allqueue(REDRAWBUTSSCENE, 0);
-
 }
 
 
@@ -403,7 +409,7 @@ static void sound_panel_sound(bSound *sound)
                sample = sound->sample;
 
                /* info string */
-               if (sound->sample && sound->sample->len) {
+               if (sound->sample && sound->sample->len && sound->sample->channels && sound->sample->bits) {
                        char *tmp;
                        if (sound->sample->channels == 1) tmp= "Mono";
                        else if (sound->sample->channels == 2) tmp= "Stereo";
@@ -1174,18 +1180,18 @@ static void seq_panel_proxy()
                             130,140,120,19, &last_seq->flag, 
                             0.0, 21.0, 100, 0, 
                             "Use a custom directory to store data");
-       }
 
-       if (last_seq->flag & SEQ_USE_PROXY_CUSTOM_DIR) {
-               uiDefIconBut(block, BUT, B_SEQ_SEL_PROXY_DIR, 
-                            ICON_FILESEL, 10, 120, 20, 20, 0, 0, 0, 0, 0, 
-                            "Select the directory/name for "
-                            "the proxy storage");
+               if (last_seq->flag & SEQ_USE_PROXY_CUSTOM_DIR) {
+                       uiDefIconBut(block, BUT, B_SEQ_SEL_PROXY_DIR, 
+                                    ICON_FILESEL, 10, 120, 20, 20, 0, 0, 0, 0, 0, 
+                                    "Select the directory/name for "
+                                    "the proxy storage");
 
-               uiDefBut(block, TEX, 
-                        B_SEQ_BUT_RELOAD, "Dir: ", 
-                        30,120,220,20, last_seq->strip->proxy->dir, 
-                        0.0, 160.0, 100, 0, "");
+                       uiDefBut(block, TEX, 
+                                B_SEQ_BUT_RELOAD, "Dir: ", 
+                                30,120,220,20, last_seq->strip->proxy->dir, 
+                                0.0, 160.0, 100, 0, "");
+               }
        }
 
        if (last_seq->flag & SEQ_USE_PROXY) {
index 10e49cdd2183eb6ad80565a9ee7de8d09cc28b82..562d9a4934d9c6e0530fbec4cf5d77c525d433a6 100644 (file)
@@ -3623,7 +3623,7 @@ void special_aftertrans_update(TransInfo *t)
                        }
                }
        }
-       else if (t->spacetype == SPACE_ACTION) {
+       if (t->spacetype == SPACE_ACTION) {
                void *data;
                short datatype;
                
index 4af5ac4d5d2f3a47502b6ac0f7b678a8ad8ebf11..b3a3a47152ad03a54a710f023020308a9efb4e57 100644 (file)
@@ -332,6 +332,7 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
                        ketsjiengine->SetPythonDictionary(dictionaryobject);
                        initRasterizer(rasterizer, canvas);
                        PyObject *gameLogic = initGameLogic(startscene);
+                       PyDict_SetItemString(dictionaryobject, "GameLogic", gameLogic); // Same as importing the module.
                        initGameKeys();
                        initPythonConstraintBinding();
 
@@ -399,7 +400,14 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
                                exitstring = ketsjiengine->GetExitString();
                                
                                // when exiting the mainloop
-                               dictionaryClearByHand(gameLogic);
+                               
+                               // Clears the dictionary by hand:
+                               // This prevents, extra references to global variables
+                               // inside the GameLogic dictionary when the python interpreter is finalized.
+                               // which allows the scene to safely delete them :)
+                               // see: (space.c)->start_game
+                               PyDict_Clear(PyModule_GetDict(gameLogic));
+                               
                                ketsjiengine->StopEngine();
                                exitGamePythonScripting();
                                networkdevice->Disconnect();
@@ -591,6 +599,7 @@ extern "C" void StartKetsjiShellSimulation(struct ScrArea *area,
                        ketsjiengine->SetPythonDictionary(dictionaryobject);
                        initRasterizer(rasterizer, canvas);
                        PyObject *gameLogic = initGameLogic(startscene);
+                       PyDict_SetItemString(dictionaryobject, "GameLogic", gameLogic); // Same as importing the module
                        initGameKeys();
                        initPythonConstraintBinding();
 
diff --git a/source/gameengine/GameLogic/SCA_ActuatorEventManager.cpp b/source/gameengine/GameLogic/SCA_ActuatorEventManager.cpp
new file mode 100644 (file)
index 0000000..c635227
--- /dev/null
@@ -0,0 +1,76 @@
+/**
+ * $Id: SCA_ActuatorEventManager.cpp 15444 2008-07-05 17:05:05Z lukep $
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "SCA_ISensor.h"
+#include "SCA_ActuatorEventManager.h"
+#include "SCA_ActuatorSensor.h"
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+
+SCA_ActuatorEventManager::SCA_ActuatorEventManager(class SCA_LogicManager* logicmgr)
+       : SCA_EventManager(ACTUATOR_EVENTMGR),
+       m_logicmgr(logicmgr)
+{
+}
+
+
+
+SCA_ActuatorEventManager::~SCA_ActuatorEventManager()
+{
+
+}
+
+
+
+void SCA_ActuatorEventManager::RegisterSensor(SCA_ISensor* sensor)
+{
+       m_sensors.push_back(sensor);
+}
+
+
+
+void SCA_ActuatorEventManager::NextFrame()
+{
+       // check for changed actuator
+       for (vector<SCA_ISensor*>::const_iterator it = m_sensors.begin();!(it==m_sensors.end());it++)
+       {
+               (*it)->Activate(m_logicmgr,NULL);
+       }
+}
+
+void SCA_ActuatorEventManager::UpdateFrame()
+{
+       // update the state of actuator before executing them
+       for (vector<SCA_ISensor*>::const_iterator it = m_sensors.begin();!(it==m_sensors.end());it++)
+       {
+               ((SCA_ActuatorSensor*)(*it))->Update();
+       }
+}
\ No newline at end of file
diff --git a/source/gameengine/GameLogic/SCA_ActuatorEventManager.h b/source/gameengine/GameLogic/SCA_ActuatorEventManager.h
new file mode 100644 (file)
index 0000000..98e217c
--- /dev/null
@@ -0,0 +1,52 @@
+/**
+ * $Id: SCA_ActuatorEventManager.h 15444 2008-07-05 17:05:05Z lukep $
+ *
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef __KX_ACTUATOREVENTMANAGER
+#define __KX_ACTUATOREVENTMANAGER
+
+#include "SCA_EventManager.h"
+
+#include <vector>
+
+using namespace std;
+
+class SCA_ActuatorEventManager : public SCA_EventManager
+{
+       class SCA_LogicManager* m_logicmgr;
+
+public:
+       SCA_ActuatorEventManager(class SCA_LogicManager* logicmgr);
+       virtual ~SCA_ActuatorEventManager();
+       virtual void NextFrame();
+       virtual void UpdateFrame();
+       virtual void    RegisterSensor(SCA_ISensor* sensor);
+       //SCA_LogicManager* GetLogicManager() { return m_logicmgr;}
+};
+
+#endif //__KX_ACTUATOREVENTMANAGER
+
diff --git a/source/gameengine/GameLogic/SCA_ActuatorSensor.cpp b/source/gameengine/GameLogic/SCA_ActuatorSensor.cpp
new file mode 100644 (file)
index 0000000..a16f719
--- /dev/null
@@ -0,0 +1,196 @@
+/**
+ * Actuator sensor
+ *
+ * $Id: SCA_ActuatorSensor.cpp 15486 2008-07-08 12:18:43Z ben2610 $
+ *
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <iostream>
+#include "SCA_ActuatorSensor.h"
+#include "SCA_EventManager.h"
+#include "SCA_LogicManager.h"
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+SCA_ActuatorSensor::SCA_ActuatorSensor(SCA_EventManager* eventmgr,
+                                                                        SCA_IObject* gameobj,
+                                                                        const STR_String& actname,
+                                                                        PyTypeObject* T )
+       : SCA_ISensor(gameobj,eventmgr,T),
+         m_checkactname(actname)
+{
+       m_actuator = GetParent()->FindActuator(m_checkactname);
+       Init();
+}
+
+void SCA_ActuatorSensor::Init()
+{
+       m_lastresult = m_invert?true:false;
+       m_midresult = m_lastresult;
+       m_reset = true;
+}
+
+CValue* SCA_ActuatorSensor::GetReplica()
+{
+       SCA_ActuatorSensor* replica = new SCA_ActuatorSensor(*this);
+       // m_range_expr must be recalculated on replica!
+       CValue::AddDataToReplica(replica);
+       replica->Init();
+
+       return replica;
+}
+
+void SCA_ActuatorSensor::ReParent(SCA_IObject* parent)
+{
+       m_actuator = parent->FindActuator(m_checkactname);
+       SCA_ISensor::ReParent(parent);
+}
+
+bool SCA_ActuatorSensor::IsPositiveTrigger()
+{
+       bool result = m_lastresult;
+       if (m_invert)
+               result = !result;
+
+       return result;
+}
+
+
+
+SCA_ActuatorSensor::~SCA_ActuatorSensor()
+{
+}
+
+
+
+bool SCA_ActuatorSensor::Evaluate(CValue* event)
+{
+       if (m_actuator)
+       {
+               bool result = m_actuator->IsActive();
+               bool reset = m_reset && m_level;
+               
+               m_reset = false;
+               if (m_lastresult != result || m_midresult != result)
+               {
+                       m_lastresult = m_midresult = result;
+                       return true;
+               }
+               return (reset) ? true : false;
+       }
+       return false;
+}
+
+void SCA_ActuatorSensor::Update()
+{
+       if (m_actuator)
+       {
+               m_midresult = m_actuator->IsActive() && !m_actuator->IsNegativeEvent();
+       }
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* Python functions                                                          */
+/* ------------------------------------------------------------------------- */
+
+/* Integration hooks ------------------------------------------------------- */
+PyTypeObject SCA_ActuatorSensor::Type = {
+       PyObject_HEAD_INIT(&PyType_Type)
+       0,
+       "SCA_ActuatorSensor",
+       sizeof(SCA_ActuatorSensor),
+       0,
+       PyDestructor,
+       0,
+       __getattr,
+       __setattr,
+       0, //&MyPyCompare,
+       __repr,
+       0, //&cvalue_as_number,
+       0,
+       0,
+       0,
+       0
+};
+
+PyParentObject SCA_ActuatorSensor::Parents[] = {
+       &SCA_ActuatorSensor::Type,
+       &SCA_ISensor::Type,
+       &SCA_ILogicBrick::Type,
+       &CValue::Type,
+       NULL
+};
+
+PyMethodDef SCA_ActuatorSensor::Methods[] = {
+       {"getActuator", (PyCFunction) SCA_ActuatorSensor::sPyGetActuator, METH_VARARGS, GetActuator_doc},
+       {"setActuator", (PyCFunction) SCA_ActuatorSensor::sPySetActuator, METH_VARARGS, SetActuator_doc},
+       {NULL,NULL} //Sentinel
+};
+
+PyObject* SCA_ActuatorSensor::_getattr(const STR_String& attr) {
+       _getattr_up(SCA_ISensor); /* implicit return! */
+}
+
+/* 3. getActuator */
+char SCA_ActuatorSensor::GetActuator_doc[] = 
+"getActuator()\n"
+"\tReturn the Actuator with which the sensor operates.\n";
+PyObject* SCA_ActuatorSensor::PyGetActuator(PyObject* self, PyObject* args, PyObject* kwds) 
+{
+       return PyString_FromString(m_checkactname);
+}
+
+/* 4. setActuator */
+char SCA_ActuatorSensor::SetActuator_doc[] = 
+"setActuator(name)\n"
+"\t- name: string\n"
+"\tSets the Actuator with which to operate. If there is no Actuator\n"
+"\tof this name, the call is ignored.\n";
+PyObject* SCA_ActuatorSensor::PySetActuator(PyObject* self, PyObject* args, PyObject* kwds) 
+{
+       /* We should query whether the name exists. Or should we create a prop   */
+       /* on the fly?                                                           */
+       char *actNameArg = NULL;
+
+       if (!PyArg_ParseTuple(args, "s", &actNameArg)) {
+               return NULL;
+       }
+
+       SCA_IActuator* act = GetParent()->FindActuator(STR_String(actNameArg));
+       if (act) {
+               m_checkactname = actNameArg;
+               m_actuator = act;
+       } else {
+               ; /* error: bad actuator name */
+       }
+       Py_Return;
+}
+
+/* eof */
diff --git a/source/gameengine/GameLogic/SCA_ActuatorSensor.h b/source/gameengine/GameLogic/SCA_ActuatorSensor.h
new file mode 100644 (file)
index 0000000..f662c57
--- /dev/null
@@ -0,0 +1,74 @@
+/**
+ * Actuator sensor
+ *
+ * $Id: SCA_ActuatorSensor.h 15444 2008-07-05 17:05:05Z lukep $
+ *
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __KX_ACTUATORSENSOR
+#define __KX_ACTUATORSENSOR
+
+#include "SCA_ISensor.h"
+#include "SCA_IActuator.h"
+
+class SCA_ActuatorSensor : public SCA_ISensor
+{
+       Py_Header;
+       STR_String              m_checkactname;
+       bool                    m_lastresult;
+       bool                    m_midresult;
+ protected:
+       SCA_IActuator*  m_actuator;
+public:
+       SCA_ActuatorSensor(class SCA_EventManager* eventmgr,
+                                         SCA_IObject* gameobj,
+                                         const STR_String& actname,
+                                         PyTypeObject* T=&Type );
+       
+       virtual ~SCA_ActuatorSensor();
+       virtual CValue* GetReplica();
+       virtual void Init();
+       virtual bool Evaluate(CValue* event);
+       virtual bool    IsPositiveTrigger();
+       virtual void    ReParent(SCA_IObject* parent);
+       void Update();
+
+       /* --------------------------------------------------------------------- */
+       /* Python interface ---------------------------------------------------- */
+       /* --------------------------------------------------------------------- */
+
+       virtual PyObject* _getattr(const STR_String& attr);
+
+       /* 3. setProperty */
+       KX_PYMETHOD_DOC(SCA_ActuatorSensor,SetActuator);
+       /* 4. getProperty */
+       KX_PYMETHOD_DOC(SCA_ActuatorSensor,GetActuator);
+       
+};
+
+#endif
+
index 76386079bdf13d71ba8cb88313f79009f9294251..01ae4072335d30023f1aa64986187e05e539b5ea 100644 (file)
@@ -116,7 +116,7 @@ CValue* SCA_PythonController::GetReplica()
 
 void SCA_PythonController::SetScriptText(const STR_String& text)
 { 
-       m_scriptText = "import GameLogic\n" + text;
+       m_scriptText = text;
        m_bModified = true;
 }
 
@@ -354,8 +354,10 @@ SCA_PythonController::PyGetSensor(PyObject* self, PyObject* value)
                        return sensor->AddRef();
                }
        }
-               
-       PyErr_SetString(PyExc_AttributeError, "Unable to find requested sensor");
+       
+       char emsg[96];
+       PyOS_snprintf( emsg, sizeof( emsg ), "Unable to find requested sensor \"%s\"", scriptArg );
+       PyErr_SetString(PyExc_AttributeError, emsg);
        return NULL;
 }
 
@@ -382,8 +384,10 @@ SCA_PythonController::PyGetActuator(PyObject* self, PyObject* value)
                        return actua->AddRef();
                }
        }
-               
-       PyErr_SetString(PyExc_AttributeError, "Unable to find requested actuator");
+       
+       char emsg[96];
+       PyOS_snprintf( emsg, sizeof( emsg ), "Unable to find requested actuator \"%s\"", scriptArg );
+       PyErr_SetString(PyExc_AttributeError, emsg);
        return NULL;
 }
 
index d6908b53d405f0761a50d0efc752d584c488cdc5..b5ebffb93784e3652ddcfee0920dd460e04d1899 100644 (file)
@@ -644,7 +644,7 @@ bool GPG_Application::startEngine(void)
                PyObject* dictionaryobject = initGamePlayerPythonScripting("Ketsji", psl_Lowest);
                m_ketsjiengine->SetPythonDictionary(dictionaryobject);
                initRasterizer(m_rasterizer, m_canvas);
-               PyObject *gameLogic = initGameLogic(startscene);
+               PyDict_SetItemString(dictionaryobject, "GameLogic", initGameLogic(startscene)); // Same as importing the module
                initGameKeys();
                initPythonConstraintBinding();
 
index 20187a193ba41151d9dee599dc4b2bd8f0cee057..db099d56b558f6c0f469a75f4cdcc2fb46b8429d 100644 (file)
@@ -231,7 +231,10 @@ void KX_KetsjiEngine::SetRasterizer(RAS_IRasterizer* rasterizer)
 }
 
 
-
+/*
+ * At the moment the GameLogic module is imported into 'pythondictionary' after this function is called.
+ * if this function ever changes to assign a copy, make sure the game logic module is imported into this dictionary before hand.
+ */
 void KX_KetsjiEngine::SetPythonDictionary(PyObject* pythondictionary)
 {
        MT_assert(pythondictionary);
index 433e0636833c914c3afef50edd21b59dd60418a3..61ed8b6a8e4a8567e8e92e03dedba20c75bc514a 100644 (file)
@@ -828,20 +828,9 @@ PyObject* initGameLogic(KX_Scene* scene) // quick hack to get gravity hook
                Py_FatalError("can't initialize module GameLogic");
     }
 
-       return d;
+       return m;
 }
 
-void dictionaryClearByHand(PyObject *dict)
-{
-       // Clears the dictionary by hand:
-       // This prevents, extra references to global variables
-       // inside the GameLogic dictionary when the python interpreter is finalized.
-       // which allows the scene to safely delete them :)
-       // see: (space.c)->start_game
-       if(dict) PyDict_Clear(dict);
-}
-
-
 // Python Sandbox code
 // override builtin functions import() and open()
 
index c7d8f1b78bc00f966bf20fa41073ae2326f30342..41cf7fd67b3389db4dea906fa9a7def3ee5a5ea9 100644 (file)
@@ -47,7 +47,6 @@ PyObject*     initGamePlayerPythonScripting(const STR_String& progname, TPythonSecur
 void           exitGamePlayerPythonScripting();
 PyObject*      initGamePythonScripting(const STR_String& progname, TPythonSecurityLevel level);
 void           exitGamePythonScripting();
-void           dictionaryClearByHand(PyObject *dict);
 
 void PHY_SetActiveScene(class KX_Scene* scene);
 class KX_Scene* PHY_GetActiveScene();
index 949156571a7de05a19b5d6326744f1cecd631749..34a3baec0933f29a5895048ed8f190d464261a08 100644 (file)
@@ -291,7 +291,8 @@ PyObject* KX_SoundActuator::PyGetFilename(PyObject* self, PyObject* args, PyObje
        char* name = objectname.Ptr();
        
        if (!name) {
-               Py_Return;                                      /* internal error */
+               PyErr_SetString(PyExc_RuntimeError, "Unable to get sound filename");
+               return NULL;
        } else
                return PyString_FromString(name);
 }